fix bundle task detail bug (#1460)

Co-authored-by: colin <102356659+colinlyguo@users.noreply.github.com>
Co-authored-by: Suuuuuuperrrrr fred <FredrikaPhililip@proton.me>
Co-authored-by: colinlyguo <colinlyguo@users.noreply.github.com>
Co-authored-by: sbaizet <74511063+sbaizet-ledger@users.noreply.github.com>
Co-authored-by: caseylove <casey4love@foxmail.com>
Co-authored-by: BoxChen <13927203+nishuzumi@users.noreply.github.com>
Co-authored-by: HAOYUatHZ <37070449+HAOYUatHZ@users.noreply.github.com>
Co-authored-by: colinlyguo <colinlyguo@scroll.io>

bridge-history-api/go.mod

@@ -89,7 +89,7 @@ require (
 	github.com/rjeczalik/notify v0.9.1 // indirect
 	github.com/rs/cors v1.7.0 // indirect
 	github.com/russross/blackfriday/v2 v2.1.0 // indirect
-	github.com/scroll-tech/da-codec v0.0.0-20240730031611-1b736159d5cb // indirect
+	github.com/scroll-tech/da-codec v0.0.0-20240718144756-1875fd490923 // indirect
 	github.com/scroll-tech/zktrie v0.8.4 // indirect
 	github.com/sethvargo/go-retry v0.2.4 // indirect
 	github.com/shirou/gopsutil v3.21.11+incompatible // indirect

bridge-history-api/go.sum

@@ -308,8 +308,8 @@ github.com/rs/cors v1.7.0 h1:+88SsELBHx5r+hZ8TCkggzSstaWNbDvThkVK8H6f9ik=
 github.com/rs/cors v1.7.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU=
 github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/scroll-tech/da-codec v0.0.0-20240730031611-1b736159d5cb h1:uOKdmDT0LsuS3gfynEjR4zA3Ooh6p2Z3O+IMRj2r8LA=
-github.com/scroll-tech/da-codec v0.0.0-20240730031611-1b736159d5cb/go.mod h1:D6XEESeNVJkQJlv3eK+FyR+ufPkgVQbJzERylQi53Bs=
+github.com/scroll-tech/da-codec v0.0.0-20240718144756-1875fd490923 h1:QKgfS8G0btzg7nmFjSjllaxGkns3yg7g2/tG1nWExEI=
+github.com/scroll-tech/da-codec v0.0.0-20240718144756-1875fd490923/go.mod h1:D6XEESeNVJkQJlv3eK+FyR+ufPkgVQbJzERylQi53Bs=
 github.com/scroll-tech/go-ethereum v1.10.14-0.20240626125436-418bc6f728b6 h1:Q8YyvrcPIcXQwE4ucm4bqmPh6TP6IB1GUTXripf2WyQ=
 github.com/scroll-tech/go-ethereum v1.10.14-0.20240626125436-418bc6f728b6/go.mod h1:byf/mZ8jLYUCnUePTicjJWn+RvKdxDn7buS6glTnMwQ=
 github.com/scroll-tech/zktrie v0.8.4 h1:UagmnZ4Z3ITCk+aUq9NQZJNAwnWl4gSxsLb2Nl7IgRE=

bridge-history-api/internal/logic/event_update.go

@@ -2,7 +2,7 @@ package logic
 
 import (
 	"context"
-	"errors"
+	"fmt"
 
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
@@ -153,7 +153,7 @@ func (b *EventUpdateLogic) updateL2WithdrawMessageInfos(ctx context.Context, bat
 
 	if withdrawTrie.NextMessageNonce != l2WithdrawMessages[0].MessageNonce {
 		log.Error("nonce mismatch", "expected next message nonce", withdrawTrie.NextMessageNonce, "actual next message nonce", l2WithdrawMessages[0].MessageNonce)
-		return errors.New("nonce mismatch")
+		return fmt.Errorf("nonce mismatch")
 	}
 
 	messageHashes := make([]common.Hash, len(l2WithdrawMessages))

bridge-history-api/internal/logic/l1_event_parser.go

@@ -320,16 +320,6 @@ func (e *L1EventParser) ParseL1MessageQueueEventLogs(logs []types.Log, l1Deposit
 					QueueIndex: index,
 				})
 			}
-		case backendabi.L1ResetDequeuedTransactionEventSig:
-			event := backendabi.L1ResetDequeuedTransactionEvent{}
-			if err := utils.UnpackLog(backendabi.IL1MessageQueueABI, &event, "ResetDequeuedTransaction", vlog); err != nil {
-				log.Error("Failed to unpack ResetDequeuedTransaction event", "err", err)
-				return nil, err
-			}
-			l1MessageQueueEvents = append(l1MessageQueueEvents, &orm.MessageQueueEvent{
-				EventType:  btypes.MessageQueueEventTypeResetDequeuedTransaction,
-				QueueIndex: event.StartIndex.Uint64(),
-			})
 		case backendabi.L1DropTransactionEventSig:
 			event := backendabi.L1DropTransactionEvent{}
 			if err := utils.UnpackLog(backendabi.IL1MessageQueueABI, &event, "DropTransaction", vlog); err != nil {

bridge-history-api/internal/logic/l1_fetcher.go

@@ -210,7 +210,7 @@ func (f *L1FetcherLogic) l1FetcherLogs(ctx context.Context, from, to uint64) ([]
 		Topics:    make([][]common.Hash, 1),
 	}
 
-	query.Topics[0] = make([]common.Hash, 15)
+	query.Topics[0] = make([]common.Hash, 14)
 	query.Topics[0][0] = backendabi.L1DepositETHSig
 	query.Topics[0][1] = backendabi.L1DepositERC20Sig
 	query.Topics[0][2] = backendabi.L1DepositERC721Sig
@@ -224,8 +224,7 @@ func (f *L1FetcherLogic) l1FetcherLogs(ctx context.Context, from, to uint64) ([]
 	query.Topics[0][10] = backendabi.L1QueueTransactionEventSig
 	query.Topics[0][11] = backendabi.L1DequeueTransactionEventSig
 	query.Topics[0][12] = backendabi.L1DropTransactionEventSig
-	query.Topics[0][13] = backendabi.L1ResetDequeuedTransactionEventSig
-	query.Topics[0][14] = backendabi.L1BridgeBatchDepositSig
+	query.Topics[0][13] = backendabi.L1BridgeBatchDepositSig
 
 	eventLogs, err := f.client.FilterLogs(ctx, query)
 	if err != nil {
@@ -340,10 +339,6 @@ func (f *L1FetcherLogic) updateMetrics(res L1FilterResult) {
 			f.l1FetcherLogicFetchedTotal.WithLabelValues("L1_skip_message").Add(1)
 		case btypes.MessageQueueEventTypeDropTransaction:
 			f.l1FetcherLogicFetchedTotal.WithLabelValues("L1_drop_message").Add(1)
-		// one ResetDequeuedTransaction event could indicate reset multiple skipped messages,
-		// this metric only counts the number of events, not the number of skipped messages.
-		case btypes.MessageQueueEventTypeResetDequeuedTransaction:
-			f.l1FetcherLogicFetchedTotal.WithLabelValues("L1_reset_skipped_messages").Add(1)
 		}
 	}
 

bridge-history-api/internal/orm/cross_message.go

@@ -217,12 +217,6 @@ func (c *CrossMessage) UpdateL1MessageQueueEventsInfo(ctx context.Context, l1Mes
 			db = db.Where("message_nonce = ?", l1MessageQueueEvent.QueueIndex)
 			db = db.Where("message_type = ?", btypes.MessageTypeL1SentMessage)
 			txStatusUpdateFields["tx_status"] = types.TxStatusTypeDropped
-		case btypes.MessageQueueEventTypeResetDequeuedTransaction:
-			db = db.Where("tx_status = ?", types.TxStatusTypeSkipped)
-			// reset skipped messages that the nonce is greater than or equal to the queue index.
-			db = db.Where("message_nonce >= ?", l1MessageQueueEvent.QueueIndex)
-			db = db.Where("message_type = ?", btypes.MessageTypeL1SentMessage)
-			txStatusUpdateFields["tx_status"] = types.TxStatusTypeSent
 		}
 		if err := db.Updates(txStatusUpdateFields).Error; err != nil {
 			return fmt.Errorf("failed to update tx statuses of L1 message queue events, update fields: %v, error: %w", txStatusUpdateFields, err)
@@ -236,7 +230,7 @@ func (c *CrossMessage) UpdateL1MessageQueueEventsInfo(ctx context.Context, l1Mes
 		db = db.Model(&CrossMessage{})
 		txHashUpdateFields := make(map[string]interface{})
 		switch l1MessageQueueEvent.EventType {
-		case btypes.MessageQueueEventTypeDequeueTransaction, btypes.MessageQueueEventTypeResetDequeuedTransaction:
+		case btypes.MessageQueueEventTypeDequeueTransaction:
 			continue
 		case btypes.MessageQueueEventTypeQueueTransaction:
 			// only replayMessages or enforced txs (whose message hashes would not be found), sendMessages have been filtered out.

bridge-history-api/internal/types/events.go

@@ -70,7 +70,6 @@ const (
 	MessageQueueEventTypeQueueTransaction
 	MessageQueueEventTypeDequeueTransaction
 	MessageQueueEventTypeDropTransaction
-	MessageQueueEventTypeResetDequeuedTransaction
 )
 
 // BatchStatusType represents the type of batch status.

bridge-history-api/internal/utils/utils.go

@@ -38,7 +38,7 @@ func GetBlockNumber(ctx context.Context, client *ethclient.Client, confirmations
 // @todo: add unit test.
 func UnpackLog(c *abi.ABI, out interface{}, event string, log types.Log) error {
 	if log.Topics[0] != c.Events[event].ID {
-		return errors.New("event signature mismatch")
+		return fmt.Errorf("event signature mismatch")
 	}
 	if len(log.Data) > 0 {
 		if err := c.UnpackIntoInterface(out, event, log.Data); err != nil {

build/dockerfiles/coordinator-api.Dockerfile

@@ -33,21 +33,16 @@ FROM base as builder
 COPY . .
 RUN cp -r ./common/libzkp/interface ./coordinator/internal/logic/verifier/lib
 COPY --from=zkp-builder /app/target/release/libzkp.so ./coordinator/internal/logic/verifier/lib/
-RUN cd ./coordinator && \
-    CGO_LDFLAGS="-Wl,--no-as-needed -ldl" make coordinator_api_skip_libzkp && \
-    mv ./build/bin/coordinator_api /bin/coordinator_api && \
-    mv internal/logic/verifier/lib /bin/ && \
-    cp ./download_assets.sh /bin/
+RUN cd ./coordinator && CGO_LDFLAGS="-Wl,--no-as-needed -ldl" make coordinator_api_skip_libzkp && mv ./build/bin/coordinator_api /bin/coordinator_api && mv internal/logic/verifier/lib /bin/
 
 # Pull coordinator into a second stage deploy ubuntu container
 FROM ubuntu:20.04
 ENV LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/src/coordinator/internal/logic/verifier/lib
 ENV CGO_LDFLAGS="-Wl,--no-as-needed -ldl"
+# ENV CHAIN_ID=534353
 RUN mkdir -p /src/coordinator/internal/logic/verifier/lib
 COPY --from=builder /bin/lib /src/coordinator/internal/logic/verifier/lib
 COPY --from=builder /bin/coordinator_api /bin/
-COPY --from=builder /bin/download_assets.sh /bin/
-RUN /bin/download_assets.sh
 RUN /bin/coordinator_api --version
 WORKDIR /app
 ENTRYPOINT ["/bin/coordinator_api"]

common/forks/forks.go

@@ -1,12 +1,83 @@
 package forks
 
 import (
+	"math"
 	"math/big"
+	"sort"
 
 	"github.com/scroll-tech/da-codec/encoding"
 	"github.com/scroll-tech/go-ethereum/params"
 )
 
+// CollectSortedForkHeights returns a sorted set of block numbers that one or more forks are activated on
+func CollectSortedForkHeights(config *params.ChainConfig) ([]uint64, map[uint64]bool, map[string]uint64) {
+	type nameFork struct {
+		name  string
+		block *big.Int
+	}
+
+	forkHeightNameMap := make(map[uint64]string)
+
+	for _, fork := range []nameFork{
+		{name: "homestead", block: config.HomesteadBlock},
+		{name: "daoFork", block: config.DAOForkBlock},
+		{name: "eip150", block: config.EIP150Block},
+		{name: "eip155", block: config.EIP155Block},
+		{name: "eip158", block: config.EIP158Block},
+		{name: "byzantium", block: config.ByzantiumBlock},
+		{name: "constantinople", block: config.ConstantinopleBlock},
+		{name: "petersburg", block: config.PetersburgBlock},
+		{name: "istanbul", block: config.IstanbulBlock},
+		{name: "muirGlacier", block: config.MuirGlacierBlock},
+		{name: "berlin", block: config.BerlinBlock},
+		{name: "london", block: config.LondonBlock},
+		{name: "arrowGlacier", block: config.ArrowGlacierBlock},
+		{name: "archimedes", block: config.ArchimedesBlock},
+		{name: "shanghai", block: config.ShanghaiBlock},
+		{name: "bernoulli", block: config.BernoulliBlock},
+		{name: "curie", block: config.CurieBlock},
+	} {
+		if fork.block == nil {
+			continue
+		}
+		height := fork.block.Uint64()
+
+		// only keep latest fork for at each height, discard the rest
+		forkHeightNameMap[height] = fork.name
+	}
+
+	forkHeightsMap := make(map[uint64]bool)
+	forkNameHeightMap := make(map[string]uint64)
+
+	for height, name := range forkHeightNameMap {
+		forkHeightsMap[height] = true
+		forkNameHeightMap[name] = height
+	}
+
+	var forkHeights []uint64
+	for height := range forkHeightsMap {
+		forkHeights = append(forkHeights, height)
+	}
+	sort.Slice(forkHeights, func(i, j int) bool {
+		return forkHeights[i] < forkHeights[j]
+	})
+	return forkHeights, forkHeightsMap, forkNameHeightMap
+}
+
+// BlockRange returns the block range of the hard fork
+// Need ensure the forkHeights is incremental
+func BlockRange(currentForkHeight uint64, forkHeights []uint64) (from, to uint64) {
+	to = math.MaxInt64
+	for _, height := range forkHeights {
+		if currentForkHeight < height {
+			to = height
+			return
+		}
+		from = height
+	}
+	return
+}
+
 // GetHardforkName returns the name of the hardfork active at the given block height and timestamp.
 // It checks the chain configuration to determine which hardfork is active.
 func GetHardforkName(config *params.ChainConfig, blockHeight, blockTimestamp uint64) string {

common/forks/forks_test.go

@@ -0,0 +1,102 @@
+package forks
+
+import (
+	"math"
+	"math/big"
+	"testing"
+
+	"github.com/scroll-tech/go-ethereum/params"
+	"github.com/stretchr/testify/require"
+)
+
+func TestCollectSortedForkBlocks(t *testing.T) {
+	l, m, n := CollectSortedForkHeights(&params.ChainConfig{
+		ArchimedesBlock: big.NewInt(0),
+		ShanghaiBlock:   big.NewInt(3),
+		BernoulliBlock:  big.NewInt(3),
+		CurieBlock:      big.NewInt(4),
+	})
+	require.Equal(t, l, []uint64{
+		0,
+		3,
+		4,
+	})
+	require.Equal(t, map[uint64]bool{
+		3: true,
+		4: true,
+		0: true,
+	}, m)
+	require.Equal(t, map[string]uint64{
+		"archimedes": 0,
+		"bernoulli":  3,
+		"curie":      4,
+	}, n)
+}
+
+func TestBlockRange(t *testing.T) {
+	tests := []struct {
+		name         string
+		forkHeight   uint64
+		forkHeights  []uint64
+		expectedFrom uint64
+		expectedTo   uint64
+	}{
+		{
+			name:         "ToInfinite",
+			forkHeight:   300,
+			forkHeights:  []uint64{100, 200, 300},
+			expectedFrom: 300,
+			expectedTo:   math.MaxInt64,
+		},
+		{
+			name:         "To300",
+			forkHeight:   200,
+			forkHeights:  []uint64{100, 200, 300},
+			expectedFrom: 200,
+			expectedTo:   300,
+		},
+		{
+			name:         "To200",
+			forkHeight:   100,
+			forkHeights:  []uint64{100, 200, 300},
+			expectedFrom: 100,
+			expectedTo:   200,
+		},
+		{
+			name:         "To100",
+			forkHeight:   0,
+			forkHeights:  []uint64{100, 200, 300},
+			expectedFrom: 0,
+			expectedTo:   100,
+		},
+		{
+			name:         "To200-1",
+			forkHeight:   100,
+			forkHeights:  []uint64{100, 200},
+			expectedFrom: 100,
+			expectedTo:   200,
+		},
+		{
+			name:         "To2",
+			forkHeight:   1,
+			forkHeights:  []uint64{1, 2},
+			expectedFrom: 1,
+			expectedTo:   2,
+		},
+		{
+			name:         "ToInfinite-1",
+			forkHeight:   0,
+			forkHeights:  []uint64{0},
+			expectedFrom: 0,
+			expectedTo:   math.MaxInt64,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			from, to := BlockRange(test.forkHeight, test.forkHeights)
+			require.Equal(t, test.expectedFrom, from)
+			require.Equal(t, test.expectedTo, to)
+		})
+	}
+}

common/go.mod

@@ -13,7 +13,7 @@ require (
 	github.com/modern-go/reflect2 v1.0.2
 	github.com/orcaman/concurrent-map v1.0.0
 	github.com/prometheus/client_golang v1.19.0
-	github.com/scroll-tech/da-codec v0.0.0-20240730031611-1b736159d5cb
+	github.com/scroll-tech/da-codec v0.0.0-20240718144756-1875fd490923
 	github.com/scroll-tech/go-ethereum v1.10.14-0.20240626125436-418bc6f728b6
 	github.com/stretchr/testify v1.9.0
 	github.com/testcontainers/testcontainers-go v0.30.0

common/go.sum

@@ -633,8 +633,8 @@ github.com/rs/cors v1.7.0 h1:+88SsELBHx5r+hZ8TCkggzSstaWNbDvThkVK8H6f9ik=
 github.com/rs/cors v1.7.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU=
 github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/scroll-tech/da-codec v0.0.0-20240730031611-1b736159d5cb h1:uOKdmDT0LsuS3gfynEjR4zA3Ooh6p2Z3O+IMRj2r8LA=
-github.com/scroll-tech/da-codec v0.0.0-20240730031611-1b736159d5cb/go.mod h1:D6XEESeNVJkQJlv3eK+FyR+ufPkgVQbJzERylQi53Bs=
+github.com/scroll-tech/da-codec v0.0.0-20240718144756-1875fd490923 h1:QKgfS8G0btzg7nmFjSjllaxGkns3yg7g2/tG1nWExEI=
+github.com/scroll-tech/da-codec v0.0.0-20240718144756-1875fd490923/go.mod h1:D6XEESeNVJkQJlv3eK+FyR+ufPkgVQbJzERylQi53Bs=
 github.com/scroll-tech/go-ethereum v1.10.14-0.20240626125436-418bc6f728b6 h1:Q8YyvrcPIcXQwE4ucm4bqmPh6TP6IB1GUTXripf2WyQ=
 github.com/scroll-tech/go-ethereum v1.10.14-0.20240626125436-418bc6f728b6/go.mod h1:byf/mZ8jLYUCnUePTicjJWn+RvKdxDn7buS6glTnMwQ=
 github.com/scroll-tech/zktrie v0.8.4 h1:UagmnZ4Z3ITCk+aUq9NQZJNAwnWl4gSxsLb2Nl7IgRE=

common/libzkp/impl/Cargo.lock

@@ -65,7 +65,7 @@ dependencies = [
 [[package]]
 name = "aggregator"
 version = "0.12.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0-rc.3#706ba9ee7292b8e15a4fa0d4634a65dffa999402"
 dependencies = [
  "ark-std 0.3.0",
  "bitstream-io",
@@ -598,7 +598,7 @@ dependencies = [
 [[package]]
 name = "bus-mapping"
 version = "0.12.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0-rc.3#706ba9ee7292b8e15a4fa0d4634a65dffa999402"
 dependencies = [
  "eth-types 0.12.0",
  "ethers-core",
@@ -1214,7 +1214,7 @@ dependencies = [
 [[package]]
 name = "eth-types"
 version = "0.12.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0-rc.3#706ba9ee7292b8e15a4fa0d4634a65dffa999402"
 dependencies = [
  "base64 0.13.1",
  "ethers-core",
@@ -1383,7 +1383,7 @@ dependencies = [
 [[package]]
 name = "external-tracer"
 version = "0.12.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0-rc.3#706ba9ee7292b8e15a4fa0d4634a65dffa999402"
 dependencies = [
  "eth-types 0.12.0",
  "geth-utils 0.12.0",
@@ -1577,7 +1577,7 @@ dependencies = [
 [[package]]
 name = "gadgets"
 version = "0.12.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0-rc.3#706ba9ee7292b8e15a4fa0d4634a65dffa999402"
 dependencies = [
  "eth-types 0.12.0",
  "halo2_proofs",
@@ -1610,7 +1610,7 @@ dependencies = [
 [[package]]
 name = "geth-utils"
 version = "0.12.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0-rc.3#706ba9ee7292b8e15a4fa0d4634a65dffa999402"
 dependencies = [
  "env_logger 0.10.0",
  "gobuild",
@@ -2374,7 +2374,7 @@ dependencies = [
 [[package]]
 name = "mock"
 version = "0.12.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0-rc.3#706ba9ee7292b8e15a4fa0d4634a65dffa999402"
 dependencies = [
  "eth-types 0.12.0",
  "ethers-core",
@@ -2403,7 +2403,7 @@ dependencies = [
 [[package]]
 name = "mpt-zktrie"
 version = "0.12.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0-rc.3#706ba9ee7292b8e15a4fa0d4634a65dffa999402"
 dependencies = [
  "eth-types 0.12.0",
  "halo2curves",
@@ -2909,7 +2909,7 @@ dependencies = [
 [[package]]
 name = "prover"
 version = "0.12.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0-rc.3#706ba9ee7292b8e15a4fa0d4634a65dffa999402"
 dependencies = [
  "aggregator 0.12.0",
  "anyhow",
@@ -4588,7 +4588,7 @@ dependencies = [
 [[package]]
 name = "zkevm-circuits"
 version = "0.12.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0-rc.3#706ba9ee7292b8e15a4fa0d4634a65dffa999402"
 dependencies = [
  "array-init",
  "bus-mapping 0.12.0",

common/libzkp/impl/Cargo.toml

@@ -13,6 +13,8 @@ halo2curves = { git = "https://github.com/scroll-tech/halo2curves", branch = "v0
 ethers-core = { git = "https://github.com/scroll-tech/ethers-rs.git", branch = "v2.0.7" }
 ethers-providers = { git = "https://github.com/scroll-tech/ethers-rs.git", branch = "v2.0.7" }
 ethers-signers  = { git = "https://github.com/scroll-tech/ethers-rs.git", branch = "v2.0.7" }
+#ethers-etherscan = { git = "https://github.com/scroll-tech/ethers-rs.git", branch = "v2.0.7" }
+#ethers = { git = "https://github.com/scroll-tech/ethers-rs.git", branch = "v2.0.7" }
 [patch."https://github.com/privacy-scaling-explorations/halo2.git"]
 halo2_proofs = { git = "https://github.com/scroll-tech/halo2.git", branch = "v1.1"  }
 [patch."https://github.com/privacy-scaling-explorations/poseidon.git"]
@@ -27,7 +29,7 @@ snark-verifier-sdk = { git = "https://github.com/scroll-tech/snark-verifier", br
 # curie
 prover_v3 = { git = "https://github.com/scroll-tech/zkevm-circuits.git", tag = "v0.11.4", package = "prover", default-features = false, features = ["parallel_syn", "scroll"] }
 # darwin
-prover_v4 = { git = "https://github.com/scroll-tech/zkevm-circuits.git", tag = "v0.12.0", package = "prover", default-features = false, features = ["parallel_syn", "scroll"] }
+prover_v4 = { git = "https://github.com/scroll-tech/zkevm-circuits.git", tag = "v0.12.0-rc.3", package = "prover", default-features = false, features = ["parallel_syn", "scroll"] }
 
 base64 = "0.13.0"
 env_logger = "0.9.0"

common/libzkp/impl/src/batch.rs

@@ -1,14 +1,46 @@
-use crate::utils::{c_char_to_str, c_char_to_vec, panic_catch};
+use crate::{
+    types::{CheckChunkProofsResponse, ProofResult},
+    utils::{
+        c_char_to_str, c_char_to_vec, file_exists, panic_catch, string_to_c_char, vec_to_c_char,
+        OUTPUT_DIR,
+    },
+};
 use libc::c_char;
-use prover_v3::BatchProof as BatchProofLoVersion;
+use prover_v3::BatchProof as BatchProofV3;
 use prover_v4::{
-    aggregator::Verifier as VerifierHiVersion, utils::init_env_and_log,
-    BatchProof as BatchProofHiVersion, BundleProof,
+    aggregator::{Prover, Verifier as VerifierV4},
+    check_chunk_hashes,
+    consts::BATCH_VK_FILENAME,
+    utils::{chunk_trace_to_witness_block, init_env_and_log},
+    BatchHeader, BatchProof as BatchProofV4, BatchProvingTask, BlockTrace, BundleProof,
+    BundleProvingTask, ChunkInfo, ChunkProof, MAX_AGG_SNARKS,
 };
 use snark_verifier_sdk::verify_evm_calldata;
-use std::{cell::OnceCell, env};
+use std::{cell::OnceCell, env, ptr::null};
 
-static mut VERIFIER: OnceCell<VerifierHiVersion> = OnceCell::new();
+static mut PROVER: OnceCell<Prover> = OnceCell::new();
+static mut VERIFIER_V4: OnceCell<VerifierV4> = OnceCell::new();
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn init_batch_prover(params_dir: *const c_char, assets_dir: *const c_char) {
+    init_env_and_log("ffi_batch_prove");
+
+    let params_dir = c_char_to_str(params_dir);
+    let assets_dir = c_char_to_str(assets_dir);
+
+    // TODO: add a settings in scroll-prover.
+    env::set_var("SCROLL_PROVER_ASSETS_DIR", assets_dir);
+
+    // VK file must exist, it is optional and logged as a warning in prover.
+    if !file_exists(assets_dir, &BATCH_VK_FILENAME) {
+        panic!("{} must exist in folder {}", *BATCH_VK_FILENAME, assets_dir);
+    }
+
+    let prover = Prover::from_dirs(params_dir, assets_dir);
+
+    PROVER.set(prover).unwrap();
+}
 
 /// # Safety
 #[no_mangle]
@@ -20,9 +52,122 @@ pub unsafe extern "C" fn init_batch_verifier(params_dir: *const c_char, assets_d
 
     // TODO: add a settings in scroll-prover.
     env::set_var("SCROLL_PROVER_ASSETS_DIR", assets_dir);
-    let verifier_hi = VerifierHiVersion::from_dirs(params_dir, assets_dir);
+    let verifier_v4 = VerifierV4::from_dirs(params_dir, assets_dir);
 
-    VERIFIER.set(verifier_hi).unwrap();
+    VERIFIER_V4.set(verifier_v4).unwrap();
+}
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn get_batch_vk() -> *const c_char {
+    let vk_result = panic_catch(|| PROVER.get_mut().unwrap().get_batch_vk());
+
+    vk_result
+        .ok()
+        .flatten()
+        .map_or(null(), |vk| string_to_c_char(base64::encode(vk)))
+}
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn get_bundle_vk() -> *const c_char {
+    let vk_result = panic_catch(|| PROVER.get_mut().unwrap().get_bundle_vk());
+
+    vk_result
+        .ok()
+        .flatten()
+        .map_or(null(), |vk| string_to_c_char(base64::encode(vk)))
+}
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn check_chunk_proofs(chunk_proofs: *const c_char) -> *const c_char {
+    let check_result: Result<bool, String> = panic_catch(|| {
+        let chunk_proofs = c_char_to_vec(chunk_proofs);
+        let chunk_proofs = serde_json::from_slice::<Vec<ChunkProof>>(&chunk_proofs)
+            .map_err(|e| format!("failed to deserialize chunk proofs: {e:?}"))?;
+
+        if chunk_proofs.is_empty() {
+            return Err("provided chunk proofs are empty.".to_string());
+        }
+
+        let prover_ref = PROVER.get().expect("failed to get reference to PROVER.");
+
+        let valid = prover_ref.check_protocol_of_chunks(&chunk_proofs);
+        Ok(valid)
+    })
+    .unwrap_or_else(|e| Err(format!("unwind error: {e:?}")));
+
+    let r = match check_result {
+        Ok(valid) => CheckChunkProofsResponse {
+            ok: valid,
+            error: None,
+        },
+        Err(err) => CheckChunkProofsResponse {
+            ok: false,
+            error: Some(err),
+        },
+    };
+
+    serde_json::to_vec(&r).map_or(null(), vec_to_c_char)
+}
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn gen_batch_proof(
+    chunk_hashes: *const c_char,
+    chunk_proofs: *const c_char,
+    batch_header: *const c_char,
+) -> *const c_char {
+    let proof_result: Result<Vec<u8>, String> = panic_catch(|| {
+        let chunk_hashes = c_char_to_vec(chunk_hashes);
+        let chunk_proofs = c_char_to_vec(chunk_proofs);
+        let batch_header = c_char_to_vec(batch_header);
+
+        let chunk_hashes = serde_json::from_slice::<Vec<ChunkInfo>>(&chunk_hashes)
+            .map_err(|e| format!("failed to deserialize chunk hashes: {e:?}"))?;
+        let chunk_proofs = serde_json::from_slice::<Vec<ChunkProof>>(&chunk_proofs)
+            .map_err(|e| format!("failed to deserialize chunk proofs: {e:?}"))?;
+        let batch_header = serde_json::from_slice::<BatchHeader<MAX_AGG_SNARKS>>(&batch_header)
+            .map_err(|e| format!("failed to deserialize batch header: {e:?}"))?;
+
+        if chunk_hashes.len() != chunk_proofs.len() {
+            return Err(format!("chunk hashes and chunk proofs lengths mismatch: chunk_hashes.len() = {}, chunk_proofs.len() = {}",
+                chunk_hashes.len(), chunk_proofs.len()));
+        }
+
+        let chunk_hashes_proofs: Vec<(_,_)> = chunk_hashes
+            .into_iter()
+            .zip(chunk_proofs.clone())
+            .collect();
+        check_chunk_hashes("", &chunk_hashes_proofs).map_err(|e| format!("failed to check chunk info: {e:?}"))?;
+
+        let batch = BatchProvingTask {
+            chunk_proofs,
+            batch_header,
+        };
+        let proof = PROVER
+            .get_mut()
+            .expect("failed to get mutable reference to PROVER.")
+            .gen_batch_proof(batch, None, OUTPUT_DIR.as_deref())
+            .map_err(|e| format!("failed to generate proof: {e:?}"))?;
+
+        serde_json::to_vec(&proof).map_err(|e| format!("failed to serialize the proof: {e:?}"))
+    })
+    .unwrap_or_else(|e| Err(format!("unwind error: {e:?}")));
+
+    let r = match proof_result {
+        Ok(proof_bytes) => ProofResult {
+            message: Some(proof_bytes),
+            error: None,
+        },
+        Err(err) => ProofResult {
+            message: None,
+            error: Some(err),
+        },
+    };
+
+    serde_json::to_vec(&r).map_or(null(), vec_to_c_char)
 }
 
 /// # Safety
@@ -44,7 +189,7 @@ pub unsafe extern "C" fn verify_batch_proof(
     let verified = panic_catch(|| {
         if fork_id == 3 {
             // As of upgrade #3 (Curie), we verify batch proofs on-chain (EVM).
-            let proof = serde_json::from_slice::<BatchProofLoVersion>(proof.as_slice()).unwrap();
+            let proof = serde_json::from_slice::<BatchProofV3>(proof.as_slice()).unwrap();
             verify_evm_calldata(
                 include_bytes!("plonk_verifier_0.11.4.bin").to_vec(),
                 proof.calldata(),
@@ -52,18 +197,66 @@ pub unsafe extern "C" fn verify_batch_proof(
         } else {
             // Post upgrade #4 (Darwin), batch proofs are not EVM-verifiable. Instead they are
             // halo2 proofs meant to be bundled recursively.
-            let proof = serde_json::from_slice::<BatchProofHiVersion>(proof.as_slice()).unwrap();
-            VERIFIER.get().unwrap().verify_batch_proof(&proof)
+            let proof = serde_json::from_slice::<BatchProofV4>(proof.as_slice()).unwrap();
+            VERIFIER_V4.get().unwrap().verify_batch_proof(&proof)
         }
     });
     verified.unwrap_or(false) as c_char
 }
 
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn gen_bundle_proof(batch_proofs: *const c_char) -> *const c_char {
+    let proof_result: Result<Vec<u8>, String> = panic_catch(|| {
+        let batch_proofs = c_char_to_vec(batch_proofs);
+        let batch_proofs = serde_json::from_slice::<Vec<BatchProofV4>>(&batch_proofs)
+            .map_err(|e| format!("failed to deserialize batch proofs: {e:?}"))?;
+
+        let bundle = BundleProvingTask { batch_proofs };
+        let proof = PROVER
+            .get_mut()
+            .expect("failed to get mutable reference to PROVER.")
+            .gen_bundle_proof(bundle, None, OUTPUT_DIR.as_deref())
+            .map_err(|e| format!("failed to generate bundle proof: {e:?}"))?;
+
+        serde_json::to_vec(&proof)
+            .map_err(|e| format!("failed to serialize the bundle proof: {e:?}"))
+    })
+    .unwrap_or_else(|e| Err(format!("unwind error: {e:?}")));
+
+    let r = match proof_result {
+        Ok(proof_bytes) => ProofResult {
+            message: Some(proof_bytes),
+            error: None,
+        },
+        Err(err) => ProofResult {
+            message: None,
+            error: Some(err),
+        },
+    };
+
+    serde_json::to_vec(&r).map_or(null(), vec_to_c_char)
+}
+
 /// # Safety
 #[no_mangle]
 pub unsafe extern "C" fn verify_bundle_proof(proof: *const c_char) -> c_char {
     let proof = c_char_to_vec(proof);
     let proof = serde_json::from_slice::<BundleProof>(proof.as_slice()).unwrap();
-    let verified = panic_catch(|| VERIFIER.get().unwrap().verify_bundle_proof(proof));
+    let verified = panic_catch(|| VERIFIER_V4.get().unwrap().verify_bundle_proof(proof));
     verified.unwrap_or(false) as c_char
 }
+
+// This function is only used for debugging on Go side.
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn block_traces_to_chunk_info(block_traces: *const c_char) -> *const c_char {
+    let block_traces = c_char_to_vec(block_traces);
+    let block_traces = serde_json::from_slice::<Vec<BlockTrace>>(&block_traces).unwrap();
+
+    let witness_block = chunk_trace_to_witness_block(block_traces).unwrap();
+    let chunk_info = ChunkInfo::from_witness_block(&witness_block, false);
+
+    let chunk_info_bytes = serde_json::to_vec(&chunk_info).unwrap();
+    vec_to_c_char(chunk_info_bytes)
+}

common/libzkp/impl/src/chunk.rs

@@ -1,36 +1,104 @@
-use crate::utils::{c_char_to_str, c_char_to_vec, panic_catch};
-use libc::c_char;
-use prover_v3::{zkevm::Verifier as VerifierLoVersion, ChunkProof as ChunkProofLoVersion};
-use prover_v4::{
-    utils::init_env_and_log, zkevm::Verifier as VerifierHiVersion,
-    ChunkProof as ChunkProofHiVersion,
+use crate::{
+    types::ProofResult,
+    utils::{
+        c_char_to_str, c_char_to_vec, file_exists, panic_catch, string_to_c_char, vec_to_c_char,
+        OUTPUT_DIR,
+    },
 };
-use std::{cell::OnceCell, env};
+use libc::c_char;
+use prover_v3::{zkevm::Verifier as VerifierV3, ChunkProof as ChunkProofV3};
+use prover_v4::{
+    consts::CHUNK_VK_FILENAME,
+    utils::init_env_and_log,
+    zkevm::{Prover, Verifier as VerifierV4},
+    BlockTrace, ChunkProof as ChunkProofV4, ChunkProvingTask,
+};
+use std::{cell::OnceCell, env, ptr::null};
 
-static mut VERIFIER_LO_VERSION: OnceCell<VerifierLoVersion> = OnceCell::new();
-static mut VERIFIER_HI_VERSION: OnceCell<VerifierHiVersion> = OnceCell::new();
+static mut PROVER: OnceCell<Prover> = OnceCell::new();
+static mut VERIFIER_V3: OnceCell<VerifierV3> = OnceCell::new();
+static mut VERIFIER_V4: OnceCell<VerifierV4> = OnceCell::new();
 
 /// # Safety
 #[no_mangle]
-pub unsafe extern "C" fn init_chunk_verifier(
-    params_dir: *const c_char,
-    v3_assets_dir: *const c_char,
-    v4_assets_dir: *const c_char,
-) {
+pub unsafe extern "C" fn init_chunk_prover(params_dir: *const c_char, assets_dir: *const c_char) {
+    init_env_and_log("ffi_chunk_prove");
+
+    let params_dir = c_char_to_str(params_dir);
+    let assets_dir = c_char_to_str(assets_dir);
+
+    // TODO: add a settings in scroll-prover.
+    env::set_var("SCROLL_PROVER_ASSETS_DIR", assets_dir);
+
+    // VK file must exist, it is optional and logged as a warning in prover.
+    if !file_exists(assets_dir, &CHUNK_VK_FILENAME) {
+        panic!("{} must exist in folder {}", *CHUNK_VK_FILENAME, assets_dir);
+    }
+
+    let prover = Prover::from_dirs(params_dir, assets_dir);
+
+    PROVER.set(prover).unwrap();
+}
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn init_chunk_verifier(params_dir: *const c_char, assets_dir: *const c_char) {
     init_env_and_log("ffi_chunk_verify");
 
     let params_dir = c_char_to_str(params_dir);
-    let v3_assets_dir = c_char_to_str(v3_assets_dir);
-    let v4_assets_dir = c_char_to_str(v4_assets_dir);
+    let assets_dir = c_char_to_str(assets_dir);
 
     // TODO: add a settings in scroll-prover.
-    env::set_var("SCROLL_PROVER_ASSETS_DIR", v3_assets_dir);
-    let verifier_lo = VerifierLoVersion::from_dirs(params_dir, v3_assets_dir);
-    env::set_var("SCROLL_PROVER_ASSETS_DIR", v4_assets_dir);
-    let verifier_hi = VerifierHiVersion::from_dirs(params_dir, v4_assets_dir);
+    env::set_var("SCROLL_PROVER_ASSETS_DIR", assets_dir);
+    let verifier_v3 = VerifierV3::from_dirs(params_dir, assets_dir);
+    let verifier_v4 = VerifierV4::from_dirs(params_dir, assets_dir);
 
-    VERIFIER_LO_VERSION.set(verifier_lo).unwrap();
-    VERIFIER_HI_VERSION.set(verifier_hi).unwrap();
+    VERIFIER_V3.set(verifier_v3).unwrap();
+    VERIFIER_V4.set(verifier_v4).unwrap();
+}
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn get_chunk_vk() -> *const c_char {
+    let vk_result = panic_catch(|| PROVER.get_mut().unwrap().get_vk());
+
+    vk_result
+        .ok()
+        .flatten()
+        .map_or(null(), |vk| string_to_c_char(base64::encode(vk)))
+}
+
+/// # Safety
+#[no_mangle]
+pub unsafe extern "C" fn gen_chunk_proof(block_traces: *const c_char) -> *const c_char {
+    let proof_result: Result<Vec<u8>, String> = panic_catch(|| {
+        let block_traces = c_char_to_vec(block_traces);
+        let block_traces = serde_json::from_slice::<Vec<BlockTrace>>(&block_traces)
+            .map_err(|e| format!("failed to deserialize block traces: {e:?}"))?;
+        let chunk = ChunkProvingTask::from(block_traces);
+
+        let proof = PROVER
+            .get_mut()
+            .expect("failed to get mutable reference to PROVER.")
+            .gen_chunk_proof(chunk, None, None, OUTPUT_DIR.as_deref())
+            .map_err(|e| format!("failed to generate proof: {e:?}"))?;
+
+        serde_json::to_vec(&proof).map_err(|e| format!("failed to serialize the proof: {e:?}"))
+    })
+    .unwrap_or_else(|e| Err(format!("unwind error: {e:?}")));
+
+    let r = match proof_result {
+        Ok(proof_bytes) => ProofResult {
+            message: Some(proof_bytes),
+            error: None,
+        },
+        Err(err) => ProofResult {
+            message: None,
+            error: Some(err),
+        },
+    };
+
+    serde_json::to_vec(&r).map_or(null(), vec_to_c_char)
 }
 
 /// # Safety
@@ -52,11 +120,11 @@ pub unsafe extern "C" fn verify_chunk_proof(
     };
     let verified = panic_catch(|| {
         if fork_id == 3 {
-            let proof = serde_json::from_slice::<ChunkProofLoVersion>(proof.as_slice()).unwrap();
-            VERIFIER_LO_VERSION.get().unwrap().verify_chunk_proof(proof)
+            let proof = serde_json::from_slice::<ChunkProofV3>(proof.as_slice()).unwrap();
+            VERIFIER_V3.get().unwrap().verify_chunk_proof(proof)
         } else {
-            let proof = serde_json::from_slice::<ChunkProofHiVersion>(proof.as_slice()).unwrap();
-            VERIFIER_HI_VERSION.get().unwrap().verify_chunk_proof(proof)
+            let proof = serde_json::from_slice::<ChunkProofV4>(proof.as_slice()).unwrap();
+            VERIFIER_V4.get().unwrap().verify_chunk_proof(proof)
         }
     });
     verified.unwrap_or(false) as c_char

common/libzkp/impl/src/utils.rs

@@ -1,9 +1,29 @@
+use once_cell::sync::Lazy;
 use std::{
-    ffi::CStr,
+    env,
+    ffi::{CStr, CString},
     os::raw::c_char,
     panic::{catch_unwind, AssertUnwindSafe},
+    path::PathBuf,
 };
 
+// Only used for debugging.
+pub(crate) static OUTPUT_DIR: Lazy<Option<String>> =
+    Lazy::new(|| env::var("PROVER_OUTPUT_DIR").ok());
+
+/// # Safety
+#[no_mangle]
+pub extern "C" fn free_c_chars(ptr: *mut c_char) {
+    if ptr.is_null() {
+        log::warn!("Try to free an empty pointer!");
+        return;
+    }
+
+    unsafe {
+        let _ = CString::from_raw(ptr);
+    }
+}
+
 pub(crate) fn c_char_to_str(c: *const c_char) -> &'static str {
     let cstr = unsafe { CStr::from_ptr(c) };
     cstr.to_str().unwrap()
@@ -14,6 +34,21 @@ pub(crate) fn c_char_to_vec(c: *const c_char) -> Vec<u8> {
     cstr.to_bytes().to_vec()
 }
 
+pub(crate) fn string_to_c_char(string: String) -> *const c_char {
+    CString::new(string).unwrap().into_raw()
+}
+
+pub(crate) fn vec_to_c_char(bytes: Vec<u8>) -> *const c_char {
+    CString::new(bytes).unwrap().into_raw()
+}
+
+pub(crate) fn file_exists(dir: &str, filename: &str) -> bool {
+    let mut path = PathBuf::from(dir);
+    path.push(filename);
+
+    path.exists()
+}
+
 pub(crate) fn panic_catch<F: FnOnce() -> R, R>(f: F) -> Result<R, String> {
     catch_unwind(AssertUnwindSafe(f)).map_err(|err| {
         if let Some(s) = err.downcast_ref::<String>() {

common/libzkp/interface/libzkp.h

@@ -1,11 +1,26 @@
+// BatchProver is used to:
+// - Batch a list of chunk proofs
+// - Bundle a list of batch proofs
+void init_batch_prover(char* params_dir, char* assets_dir);
 // BatchVerifier is used to:
 // - Verify a batch proof
 // - Verify a bundle proof
 void init_batch_verifier(char* params_dir, char* assets_dir);
 
+char* get_batch_vk();
+char* check_chunk_proofs(char* chunk_proofs);
+char* gen_batch_proof(char* chunk_hashes, char* chunk_proofs, char* batch_header);
 char verify_batch_proof(char* proof, char* fork_name);
 
+char* get_bundle_vk();
+char* gen_bundle_proof(char* batch_proofs);
 char verify_bundle_proof(char* proof);
 
-void init_chunk_verifier(char* params_dir, char* v3_assets_dir, char* v4_assets_dir);
+void init_chunk_prover(char* params_dir, char* assets_dir);
+void init_chunk_verifier(char* params_dir, char* assets_dir);
+char* get_chunk_vk();
+char* gen_chunk_proof(char* block_traces);
 char verify_chunk_proof(char* proof, char* fork_name);
+
+char* block_traces_to_chunk_info(char* block_traces);
+void free_c_chars(char* ptr);

common/testcontainers/testcontainers.go

@@ -2,7 +2,6 @@ package testcontainers
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"log"
 	"os"
@@ -115,7 +114,7 @@ func (t *TestcontainerApps) StartPoSL1Container() error {
 // GetPoSL1EndPoint returns the endpoint of the running PoS L1 endpoint
 func (t *TestcontainerApps) GetPoSL1EndPoint() (string, error) {
 	if t.poSL1Container == nil {
-		return "", errors.New("PoS L1 container is not running")
+		return "", fmt.Errorf("PoS L1 container is not running")
 	}
 	contrainer, err := t.poSL1Container.ServiceContainer(context.Background(), "geth")
 	if err != nil {
@@ -136,7 +135,7 @@ func (t *TestcontainerApps) GetPoSL1Client() (*ethclient.Client, error) {
 // GetDBEndPoint returns the endpoint of the running postgres container
 func (t *TestcontainerApps) GetDBEndPoint() (string, error) {
 	if t.postgresContainer == nil || !t.postgresContainer.IsRunning() {
-		return "", errors.New("postgres is not running")
+		return "", fmt.Errorf("postgres is not running")
 	}
 	return t.postgresContainer.ConnectionString(context.Background(), "sslmode=disable")
 }
@@ -144,7 +143,7 @@ func (t *TestcontainerApps) GetDBEndPoint() (string, error) {
 // GetL2GethEndPoint returns the endpoint of the running L2Geth container
 func (t *TestcontainerApps) GetL2GethEndPoint() (string, error) {
 	if t.l2GethContainer == nil || !t.l2GethContainer.IsRunning() {
-		return "", errors.New("l2 geth is not running")
+		return "", fmt.Errorf("l2 geth is not running")
 	}
 	endpoint, err := t.l2GethContainer.PortEndpoint(context.Background(), "8546/tcp", "ws")
 	if err != nil {
@@ -218,7 +217,7 @@ func findProjectRootDir() (string, error) {
 
 		parentDir := filepath.Dir(currentDir)
 		if parentDir == currentDir {
-			return "", errors.New("go.work file not found in any parent directory")
+			return "", fmt.Errorf("go.work file not found in any parent directory")
 		}
 
 		currentDir = parentDir

common/types/db.go

@@ -109,10 +109,6 @@ const (
 	ProverTaskFailureTypeVerifiedFailed
 	// ProverTaskFailureTypeServerError collect occur error
 	ProverTaskFailureTypeServerError
-	// ProverTaskFailureTypeObjectAlreadyVerified object(batch/chunk) already verified, may exists in test env when ENABLE_TEST_ENV_BYPASS_FEATURES is true
-	ProverTaskFailureTypeObjectAlreadyVerified
-	// ProverTaskFailureTypeReassignedByAdmin reassigned by admin, this value is used in admin-system and defined here for clarity
-	ProverTaskFailureTypeReassignedByAdmin
 )
 
 func (r ProverTaskFailureType) String() string {
@@ -127,10 +123,6 @@ func (r ProverTaskFailureType) String() string {
 		return "prover task failure verified failed"
 	case ProverTaskFailureTypeServerError:
 		return "prover task failure server exception"
-	case ProverTaskFailureTypeObjectAlreadyVerified:
-		return "prover task failure object already verified"
-	case ProverTaskFailureTypeReassignedByAdmin:
-		return "prover task failure reassigned by admin"
 	default:
 		return fmt.Sprintf("illegal prover task failure type (%d)", int32(r))
 	}

common/utils/keystore.go

@@ -2,7 +2,6 @@ package utils
 
 import (
 	"crypto/ecdsa"
-	"errors"
 	"fmt"
 	"os"
 	"path/filepath"
@@ -29,7 +28,7 @@ func LoadOrCreateKey(keystorePath string, keystorePassword string) (*ecdsa.Priva
 	} else if err != nil {
 		return nil, err
 	} else if fi.IsDir() {
-		return nil, errors.New("keystorePath cannot be a dir")
+		return nil, fmt.Errorf("keystorePath cannot be a dir")
 	}
 
 	keyjson, err := os.ReadFile(filepath.Clean(keystorePath))

common/version/version.go

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

coordinator/cmd/tool/tool.go

@@ -25,7 +25,7 @@ func init() {
 	app = cli.NewApp()
 	app.Action = action
 	app.Name = "coordinator-tool"
-	app.Usage = "The Scroll L2 Coordinator Tool"
+	app.Usage = "The Scroll L2 Coordinator"
 	app.Version = version.Version
 	app.Flags = append(app.Flags, utils.CommonFlags...)
 	app.Before = func(ctx *cli.Context) error {
@@ -66,7 +66,7 @@ func action(ctx *cli.Context) error {
 	for _, batch := range batches {
 		var proof message.BatchProof
 		if encodeErr := json.Unmarshal(batch.Proof, &proof); encodeErr != nil {
-			log.Error("failed to unmarshal batch proof")
+			log.Error("failed to unmarshal proof")
 			return fmt.Errorf("failed to unmarshal proof: %w, bundle hash: %v, batch hash: %v", encodeErr, taskID, batch.Hash)
 		}
 		batchProofs = append(batchProofs, &proof)
@@ -78,8 +78,8 @@ func action(ctx *cli.Context) error {
 
 	batchProofsBytes, err := json.Marshal(taskDetail)
 	if err != nil {
-		log.Error("failed to marshal batch proof")
-		return fmt.Errorf("failed to marshal batch proofs, taskID:%s err:%w", taskID, err)
+		log.Error("failed to marshal proof")
+		return fmt.Errorf("failed to marshal chunk proofs, taskID:%s err:%w", taskID, err)
 	}
 
 	taskMsg := &coordinatorType.GetTaskSchema{

coordinator/conf/config.json

@@ -9,8 +9,7 @@
       "fork_name": "bernoulli",
       "mock_mode": true,
       "params_path": "",
-      "assets_path_lo": "",
-      "assets_path_hi": ""
+      "assets_path": ""
     },
     "max_verifier_workers": 4,
     "min_prover_version": "v1.0.0"

coordinator/download_assets.sh

@@ -1,126 +0,0 @@
-#!/bin/sh
-apt update
-apt install wget libdigest-sha-perl -y
-
-RELEASE_VERSION_HI=v0.12.0
-RELEASE_VERSION_LO=v0.11.4
-
-P_CHECKSUMS=$(wget -O- https://circuit-release.s3.us-west-2.amazonaws.com/setup/sha256sum)
-DOWNLOAD_RESULT=$?
-ERROR=$(echo "$P_CHECKSUMS" | grep "Error")
-
-if [ $DOWNLOAD_RESULT -ne 0 ] || [ "$ERROR" != "" ]; then
-	echo "Failed to download params checksums"
-	echo "$P_CHECKSUMS"
-	exit 1
-fi
-
-R_CHECKSUMS_HI=$(wget -O- https://circuit-release.s3.us-west-2.amazonaws.com/release-$RELEASE_VERSION_HI/sha256sum)
-DOWNLOAD_RESULT=$?
-ERROR=$(echo "$R_CHECKSUMS_HI" | grep "Error")
-if [ $DOWNLOAD_RESULT -ne 0 ] || [ "$ERROR" != "" ]; then
-	echo "Failed to download release checksum for $RELEASE_VERSION_HI"
-	echo "$R_CHECKSUMS_HI"
-	exit 1
-fi
-
-R_CHECKSUMS_LO=$(wget -O- https://circuit-release.s3.us-west-2.amazonaws.com/release-$RELEASE_VERSION_LO/sha256sum)
-DOWNLOAD_RESULT=$?
-ERROR=$(echo "$R_CHECKSUMS_LO" | grep "Error")
-if [ $DOWNLOAD_RESULT -ne 0 ] || [ "$ERROR" != "" ]; then
-	echo "Failed to download release checksum for $RELEASE_VERSION_LO"
-	echo "$R_CHECKSUMS_LO"
-	exit 1
-fi
-
-PARAMS20_SHASUM=$(echo "$P_CHECKSUMS" | grep "params20" | cut -d " " -f 1)
-PARAMS21_SHASUM=$(echo "$P_CHECKSUMS" | grep "params21" | cut -d " " -f 1)
-PARAMS24_SHASUM=$(echo "$P_CHECKSUMS" | grep "params24" | cut -d " " -f 1)
-PARAMS25_SHASUM=$(echo "$P_CHECKSUMS" | grep "params25" | cut -d " " -f 1)
-PARAMS26_SHASUM=$(echo "$P_CHECKSUMS" | grep "params26" | cut -d " " -f 1)
-
-# v0.12.0
-VK_CHUNK_SHASUM_HI=$(echo "$R_CHECKSUMS_HI" | grep "vk_chunk.vkey" | cut -d " " -f 1)
-VK_BATCH_SHASUM_HI=$(echo "$R_CHECKSUMS_HI" | grep "vk_batch.vkey" | cut -d " " -f 1)
-VK_BUNDLE_SHASUM_HI=$(echo "$R_CHECKSUMS_HI" | grep "vk_bundle.vkey" | cut -d " " -f 1)
-VRFR_SHASUM_HI=$(echo "$R_CHECKSUMS_HI" | grep "evm_verifier.bin" | cut -d " " -f 1)
-CFG2_SHASUM_HI=$(echo "$R_CHECKSUMS_HI" | grep "layer2.config" | cut -d " " -f 1)
-CFG4_SHASUM_HI=$(echo "$R_CHECKSUMS_HI" | grep "layer4.config" | cut -d " " -f 1)
-
-# v0.11.4
-VK_CHUNK_SHASUM_LO=$(echo "$R_CHECKSUMS_LO" | grep "chunk_vk.vkey" | cut -d " " -f 1)
-VK_BATCH_SHASUM_LO=$(echo "$R_CHECKSUMS_LO" | grep "agg_vk.vkey" | cut -d " " -f 1)
-VRFR_SHASUM_LO=$(echo "$R_CHECKSUMS_LO" | grep "evm_verifier.bin" | cut -d " " -f 1)
-CFG2_SHASUM_LO=$(echo "$R_CHECKSUMS_LO" | grep "layer2.config" | cut -d " " -f 1)
-CFG4_SHASUM_LO=$(echo "$R_CHECKSUMS_LO" | grep "layer4.config" | cut -d " " -f 1)
-
-check_shasum() {
-	SHASUM=$(shasum -a 256 $1 | cut -d " " -f 1)
-	if [ "$SHASUM" != "$2" ]; then
-		echo "Shasum mismatch: expected=$2, actual=$SHASUM"
-		return 1
-	else
-		return 0
-	fi
-}
-
-# check existing file checksums
-check_file() {
-	if [ -f $1 ]; then
-		if ! check_shasum $1 $2; then
-			echo "Removing incorrect file $1"
-			rm $1
-		fi
-	fi
-}
-
-# check existing common file
-check_file "/verifier/params/params20" "$PARAMS20_SHASUM"
-check_file "/verifier/params/params21" "$PARAMS21_SHASUM"
-check_file "/verifier/params/params24" "$PARAMS24_SHASUM"
-check_file "/verifier/params/params25" "$PARAMS25_SHASUM"
-check_file "/verifier/params/params26" "$PARAMS26_SHASUM"
-# check existing vk_hi file v0.12.0
-check_file "/verifier/assets/hi/vk_chunk.vkey" "$VK_CHUNK_SHASUM_HI"
-check_file "/verifier/assets/hi/vk_batch.vkey" "$VK_BATCH_SHASUM_HI"
-check_file "/verifier/assets/hi/vk_bundle.vkey" "$VK_BUNDLE_SHASUM_HI"
-check_file "/verifier/assets/hi/evm_verifier.bin" "$VRFR_SHASUM_HI"
-check_file "/verifier/assets/hi/layer2.config" "$CFG2_SHASUM_HI"
-check_file "/verifier/assets/hi/layer4.config" "$CFG4_SHASUM_HI"
-# check existing vk_lo file v0.11.4
-check_file "/verifier/assets/lo/chunk_vk.vkey" "$VK_CHUNK_SHASUM_LO"
-check_file "/verifier/assets/lo/agg_vk.vkey" "$VK_BATCH_SHASUM_LO"
-check_file "/verifier/assets/lo/evm_verifier.bin" "$VRFR_SHASUM_LO"
-check_file "/verifier/assets/lo/layer2.config" "$CFG2_SHASUM_LO"
-check_file "/verifier/assets/lo/layer4.config" "$CFG4_SHASUM_LO"
-
-# download missing files
-download_file() {
-	if [ ! -f $1 ]; then
-		mkdir -p $(dirname $1)
-		echo "Downloading $1..."
-		wget --progress=dot:mega $2 -O $1
-		echo "Download completed $1"
-		if ! check_shasum $1 $3; then exit 1; fi
-	fi
-}
-
-# download common
-download_file "/verifier/params/params20" "https://circuit-release.s3.us-west-2.amazonaws.com/setup/params20" "$PARAMS20_SHASUM"
-download_file "/verifier/params/params21" "https://circuit-release.s3.us-west-2.amazonaws.com/setup/params21" "$PARAMS21_SHASUM"
-download_file "/verifier/params/params24" "https://circuit-release.s3.us-west-2.amazonaws.com/setup/params24" "$PARAMS24_SHASUM"
-download_file "/verifier/params/params25" "https://circuit-release.s3.us-west-2.amazonaws.com/setup/params25" "$PARAMS25_SHASUM"
-download_file "/verifier/params/params26" "https://circuit-release.s3.us-west-2.amazonaws.com/setup/params26" "$PARAMS26_SHASUM"
-# download hi v0.12.0
-download_file "/verifier/assets/hi/vk_chunk.vkey" "https://circuit-release.s3.us-west-2.amazonaws.com/release-$RELEASE_VERSION_HI/vk_chunk.vkey" "$VK_CHUNK_SHASUM_HI"
-download_file "/verifier/assets/hi/vk_batch.vkey" "https://circuit-release.s3.us-west-2.amazonaws.com/release-$RELEASE_VERSION_HI/vk_batch.vkey" "$VK_BATCH_SHASUM_HI"
-download_file "/verifier/assets/hi/vk_bundle.vkey" "https://circuit-release.s3.us-west-2.amazonaws.com/release-$RELEASE_VERSION_HI/vk_bundle.vkey" "$VK_BUNDLE_SHASUM_HI"
-download_file "/verifier/assets/hi/evm_verifier.bin" "https://circuit-release.s3.us-west-2.amazonaws.com/release-$RELEASE_VERSION_HI/evm_verifier.bin" "$VRFR_SHASUM_HI"
-download_file "/verifier/assets/hi/layer2.config" "https://circuit-release.s3.us-west-2.amazonaws.com/release-$RELEASE_VERSION_HI/layer2.config" "$CFG2_SHASUM_HI"
-download_file "/verifier/assets/hi/layer4.config" "https://circuit-release.s3.us-west-2.amazonaws.com/release-$RELEASE_VERSION_HI/layer4.config" "$CFG4_SHASUM_HI"
-# download low v0.11.4
-download_file "/verifier/assets/lo/chunk_vk.vkey" "https://circuit-release.s3.us-west-2.amazonaws.com/release-$RELEASE_VERSION_LO/chunk_vk.vkey" "$VK_CHUNK_SHASUM_LO"
-download_file "/verifier/assets/lo/agg_vk.vkey" "https://circuit-release.s3.us-west-2.amazonaws.com/release-$RELEASE_VERSION_LO/agg_vk.vkey" "$VK_BATCH_SHASUM_LO"
-download_file "/verifier/assets/lo/evm_verifier.bin" "https://circuit-release.s3.us-west-2.amazonaws.com/release-$RELEASE_VERSION_LO/evm_verifier.bin" "$VRFR_SHASUM_LO"
-download_file "/verifier/assets/lo/layer2.config" "https://circuit-release.s3.us-west-2.amazonaws.com/release-$RELEASE_VERSION_LO/layer2.config" "$CFG2_SHASUM_LO"
-download_file "/verifier/assets/lo/layer4.config" "https://circuit-release.s3.us-west-2.amazonaws.com/release-$RELEASE_VERSION_LO/layer4.config" "$CFG4_SHASUM_LO"

coordinator/go.mod

@@ -45,7 +45,7 @@ require (
 require (
 	github.com/google/uuid v1.6.0
 	github.com/prometheus/client_golang v1.19.0
-	github.com/scroll-tech/da-codec v0.0.0-20240730031611-1b736159d5cb
+	github.com/scroll-tech/da-codec v0.0.0-20240718144756-1875fd490923
 )
 
 require (

coordinator/go.sum

@@ -173,8 +173,8 @@ github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjR
 github.com/rogpeppe/go-internal v1.10.0/go.mod h1:UQnix2H7Ngw/k4C5ijL5+65zddjncjaFoBhdsK/akog=
 github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/scroll-tech/da-codec v0.0.0-20240730031611-1b736159d5cb h1:uOKdmDT0LsuS3gfynEjR4zA3Ooh6p2Z3O+IMRj2r8LA=
-github.com/scroll-tech/da-codec v0.0.0-20240730031611-1b736159d5cb/go.mod h1:D6XEESeNVJkQJlv3eK+FyR+ufPkgVQbJzERylQi53Bs=
+github.com/scroll-tech/da-codec v0.0.0-20240718144756-1875fd490923 h1:QKgfS8G0btzg7nmFjSjllaxGkns3yg7g2/tG1nWExEI=
+github.com/scroll-tech/da-codec v0.0.0-20240718144756-1875fd490923/go.mod h1:D6XEESeNVJkQJlv3eK+FyR+ufPkgVQbJzERylQi53Bs=
 github.com/scroll-tech/go-ethereum v1.10.14-0.20240626125436-418bc6f728b6 h1:Q8YyvrcPIcXQwE4ucm4bqmPh6TP6IB1GUTXripf2WyQ=
 github.com/scroll-tech/go-ethereum v1.10.14-0.20240626125436-418bc6f728b6/go.mod h1:byf/mZ8jLYUCnUePTicjJWn+RvKdxDn7buS6glTnMwQ=
 github.com/scroll-tech/zktrie v0.8.4 h1:UagmnZ4Z3ITCk+aUq9NQZJNAwnWl4gSxsLb2Nl7IgRE=

coordinator/internal/config/config.go

@@ -52,11 +52,10 @@ type Config struct {
 
 // VerifierConfig load zk verifier config.
 type VerifierConfig struct {
-	ForkName     string `json:"fork_name"`
-	MockMode     bool   `json:"mock_mode"`
-	ParamsPath   string `json:"params_path"`
-	AssetsPathLo string `json:"assets_path_lo"` // lower version Verifier
-	AssetsPathHi string `json:"assets_path_hi"` // higher version Verifier
+	ForkName   string `json:"fork_name"`
+	MockMode   bool   `json:"mock_mode"`
+	ParamsPath string `json:"params_path"`
+	AssetsPath string `json:"assets_path"`
 }
 
 // NewConfig returns a new instance of Config.

coordinator/internal/controller/api/get_task.go

@@ -1,7 +1,6 @@
 package api
 
 import (
-	"errors"
 	"fmt"
 	"math/rand"
 
@@ -50,15 +49,15 @@ func NewGetTaskController(cfg *config.Config, chainCfg *params.ChainConfig, db *
 func (ptc *GetTaskController) incGetTaskAccessCounter(ctx *gin.Context) error {
 	publicKey, publicKeyExist := ctx.Get(coordinatorType.PublicKey)
 	if !publicKeyExist {
-		return errors.New("get public key from context failed")
+		return fmt.Errorf("get public key from context failed")
 	}
 	proverName, proverNameExist := ctx.Get(coordinatorType.ProverName)
 	if !proverNameExist {
-		return errors.New("get prover name from context failed")
+		return fmt.Errorf("get prover name from context failed")
 	}
 	proverVersion, proverVersionExist := ctx.Get(coordinatorType.ProverVersion)
 	if !proverVersionExist {
-		return errors.New("get prover version from context failed")
+		return fmt.Errorf("get prover version from context failed")
 	}
 
 	ptc.getTaskAccessCounter.With(prometheus.Labels{
@@ -98,7 +97,7 @@ func (ptc *GetTaskController) GetTasks(ctx *gin.Context) {
 	}
 
 	if result == nil {
-		nerr := errors.New("get empty prover task")
+		nerr := fmt.Errorf("get empty prover task")
 		types.RenderFailure(ctx, types.ErrCoordinatorEmptyProofData, nerr)
 		return
 	}

coordinator/internal/controller/cron/collect_proof.go

@@ -363,7 +363,7 @@ func (c *Collector) checkBundleAllBatchReady() {
 				for _, bundle := range bundles {
 					allReady, checkErr := c.batchOrm.CheckIfBundleBatchProofsAreReady(c.ctx, bundle.Hash)
 					if checkErr != nil {
-						log.Warn("checkBundleAllBatchReady CheckIfBundleBatchProofsAreReady failure", "error", checkErr, "hash", bundle.Hash)
+						log.Warn("checkBatchAllChunkReady CheckIfBatchChunkProofsAreReady failure", "error", checkErr, "hash", bundle.Hash)
 						continue
 					}
 
@@ -371,8 +371,8 @@ func (c *Collector) checkBundleAllBatchReady() {
 						continue
 					}
 
-					if updateErr := c.bundleOrm.UpdateBatchProofsStatusByBundleHash(c.ctx, bundle.Hash, types.BatchProofsStatusReady); updateErr != nil {
-						log.Warn("checkBundleAllBatchReady UpdateBatchProofsStatusByBundleHash failure", "error", checkErr, "hash", bundle.Hash)
+					if updateErr := c.bundleOrm.UpdateBatchProofsStatusByBatchHash(c.ctx, bundle.Hash, types.BatchProofsStatusReady); updateErr != nil {
+						log.Warn("checkBundleAllBatchReady UpdateBatchProofsStatusByBatchHash failure", "error", checkErr, "hash", bundle.Hash)
 					}
 				}
 

coordinator/internal/logic/auth/login.go

@@ -96,7 +96,7 @@ func (l *LoginLogic) Check(login *types.LoginParameter) error {
 						version.Version, login.Message.ProverVersion)
 				}
 				// if the prover reports a same prover version
-				return errors.New("incompatible vk. please check your params files or config files")
+				return fmt.Errorf("incompatible vk. please check your params files or config files")
 			}
 		}
 	}

coordinator/internal/logic/provertask/bundle_prover_task.go

@@ -205,7 +205,7 @@ func (bp *BundleProverTask) formatProverTask(ctx context.Context, task *orm.Prov
 
 	batchProofsBytes, err := json.Marshal(taskDetail)
 	if err != nil {
-		return nil, fmt.Errorf("failed to marshal batch proofs, taskID:%s err:%w", task.TaskID, err)
+		return nil, fmt.Errorf("failed to marshal chunk proofs, taskID:%s err:%w", task.TaskID, err)
 	}
 
 	taskMsg := &coordinatorType.GetTaskSchema{

coordinator/internal/logic/provertask/prover_task.go

@@ -1,7 +1,6 @@
 package provertask
 
 import (
-	"errors"
 	"fmt"
 	"sync"
 
@@ -18,7 +17,9 @@ import (
 
 var (
 	// ErrCoordinatorInternalFailure coordinator internal db failure
-	ErrCoordinatorInternalFailure = errors.New("coordinator internal error")
+	ErrCoordinatorInternalFailure = fmt.Errorf("coordinator internal error")
+	// ErrHardForkName indicates client request with the wrong hard fork name
+	ErrHardForkName = fmt.Errorf("wrong hard fork name")
 )
 
 var (
@@ -57,19 +58,19 @@ func (b *BaseProverTask) checkParameter(ctx *gin.Context) (*proverTaskContext, e
 
 	publicKey, publicKeyExist := ctx.Get(coordinatorType.PublicKey)
 	if !publicKeyExist {
-		return nil, errors.New("get public key from context failed")
+		return nil, fmt.Errorf("get public key from context failed")
 	}
 	ptc.PublicKey = publicKey.(string)
 
 	proverName, proverNameExist := ctx.Get(coordinatorType.ProverName)
 	if !proverNameExist {
-		return nil, errors.New("get prover name from context failed")
+		return nil, fmt.Errorf("get prover name from context failed")
 	}
 	ptc.ProverName = proverName.(string)
 
 	proverVersion, proverVersionExist := ctx.Get(coordinatorType.ProverVersion)
 	if !proverVersionExist {
-		return nil, errors.New("get prover version from context failed")
+		return nil, fmt.Errorf("get prover version from context failed")
 	}
 	ptc.ProverVersion = proverVersion.(string)
 

coordinator/internal/logic/submitproof/proof_receiver.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"encoding/json"
 	"errors"
+	"fmt"
 	"strings"
 	"time"
 
@@ -137,11 +138,11 @@ func (m *ProofReceiverLogic) HandleZkProof(ctx *gin.Context, proofParameter coor
 	m.proofReceivedTotal.Inc()
 	pk := ctx.GetString(coordinatorType.PublicKey)
 	if len(pk) == 0 {
-		return errors.New("get public key from context failed")
+		return fmt.Errorf("get public key from context failed")
 	}
 	pv := ctx.GetString(coordinatorType.ProverVersion)
 	if len(pv) == 0 {
-		return errors.New("get ProverVersion from context failed")
+		return fmt.Errorf("get ProverVersion from context failed")
 	}
 
 	proverTask, err := m.proverTaskOrm.GetProverTaskByUUIDAndPublicKey(ctx.Copy(), proofParameter.UUID, pk)
@@ -296,7 +297,6 @@ func (m *ProofReceiverLogic) validator(ctx context.Context, proverTask *orm.Prov
 
 	// if the batch/chunk have proved and verifier success, need skip this submit proof
 	if m.checkIsTaskSuccess(ctx, proofParameter.TaskID, message.ProofType(proofParameter.TaskType)) {
-		m.proofRecover(ctx, proverTask, types.ProverTaskFailureTypeObjectAlreadyVerified, proofParameter)
 		m.validateFailureProverTaskHaveVerifier.Inc()
 		log.Info("the prove task have proved and verifier success, skip this submit proof", "hash", proofParameter.TaskID,
 			"taskType", proverTask.TaskType, "proverName", proverTask.ProverName, "proverPublicKey", pk)

coordinator/internal/logic/verifier/verifier.go

@@ -36,16 +36,14 @@ func NewVerifier(cfg *config.VerifierConfig) (*Verifier, error) {
 		return &Verifier{cfg: cfg, ChunkVKMap: chunkVKMap, BatchVKMap: batchVKMap, BundleVkMap: bundleVKMap}, nil
 	}
 	paramsPathStr := C.CString(cfg.ParamsPath)
-	assetsPathLoStr := C.CString(cfg.AssetsPathLo)
-	assetsPathHiStr := C.CString(cfg.AssetsPathHi)
+	assetsPathStr := C.CString(cfg.AssetsPath)
 	defer func() {
 		C.free(unsafe.Pointer(paramsPathStr))
-		C.free(unsafe.Pointer(assetsPathLoStr))
-		C.free(unsafe.Pointer(assetsPathHiStr))
+		C.free(unsafe.Pointer(assetsPathStr))
 	}()
 
-	C.init_batch_verifier(paramsPathStr, assetsPathHiStr)
-	C.init_chunk_verifier(paramsPathStr, assetsPathLoStr, assetsPathHiStr)
+	C.init_batch_verifier(paramsPathStr, assetsPathStr)
+	C.init_chunk_verifier(paramsPathStr, assetsPathStr)
 
 	v := &Verifier{
 		cfg:         cfg,
@@ -54,15 +52,15 @@ func NewVerifier(cfg *config.VerifierConfig) (*Verifier, error) {
 		BundleVkMap: make(map[string]string),
 	}
 
-	bundleVK, err := v.readVK(path.Join(cfg.AssetsPathHi, "vk_bundle.vkey"))
+	bundleVK, err := v.readVK(path.Join(cfg.AssetsPath, "vk_bundle.vkey"))
 	if err != nil {
 		return nil, err
 	}
-	batchVK, err := v.readVK(path.Join(cfg.AssetsPathHi, "vk_batch.vkey"))
+	batchVK, err := v.readVK(path.Join(cfg.AssetsPath, "vk_batch.vkey"))
 	if err != nil {
 		return nil, err
 	}
-	chunkVK, err := v.readVK(path.Join(cfg.AssetsPathHi, "vk_chunk.vkey"))
+	chunkVK, err := v.readVK(path.Join(cfg.AssetsPath, "vk_chunk.vkey"))
 	if err != nil {
 		return nil, err
 	}

coordinator/internal/logic/verifier/verifier_test.go

@@ -18,8 +18,7 @@ import (
 
 var (
 	paramsPath      = flag.String("params", "/assets/test_params", "params dir")
-	assetsPathLo    = flag.String("assets", "/assets/test_assets_lo", "assets dir")
-	assetsPathHi    = flag.String("assets", "/assets/test_assets_hi", "assets dir")
+	assetsPath      = flag.String("assets", "/assets/test_assets", "assets dir")
 	batchProofPath  = flag.String("batch_proof", "/assets/proof_data/batch_proof", "batch proof file path")
 	chunkProofPath1 = flag.String("chunk_proof1", "/assets/proof_data/chunk_proof1", "chunk proof file path 1")
 	chunkProofPath2 = flag.String("chunk_proof2", "/assets/proof_data/chunk_proof2", "chunk proof file path 2")
@@ -29,10 +28,9 @@ func TestFFI(t *testing.T) {
 	as := assert.New(t)
 
 	cfg := &config.VerifierConfig{
-		MockMode:     false,
-		ParamsPath:   *paramsPath,
-		AssetsPathLo: *assetsPathLo,
-		AssetsPathHi: *assetsPathHi,
+		MockMode:   false,
+		ParamsPath: *paramsPath,
+		AssetsPath: *assetsPath,
 	}
 
 	v, err := NewVerifier(cfg)

coordinator/internal/orm/batch.go

@@ -211,6 +211,23 @@ func (o *Batch) GetBatchByHash(ctx context.Context, hash string) (*Batch, error)
 	return &batch, nil
 }
 
+// GetLatestFinalizedBatch retrieves the latest finalized batch from the database.
+func (o *Batch) GetLatestFinalizedBatch(ctx context.Context) (*Batch, error) {
+	db := o.db.WithContext(ctx)
+	db = db.Model(&Batch{})
+	db = db.Where("rollup_status = ?", int(types.RollupFinalized))
+	db = db.Order("index desc")
+
+	var latestFinalizedBatch Batch
+	if err := db.First(&latestFinalizedBatch).Error; err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+		return nil, fmt.Errorf("Batch.GetLatestBatch error: %w", err)
+	}
+	return &latestFinalizedBatch, nil
+}
+
 // GetBatchesByBundleHash retrieves the given batch.
 func (o *Batch) GetBatchesByBundleHash(ctx context.Context, bundleHash string) ([]*Batch, error) {
 	db := o.db.WithContext(ctx)

coordinator/internal/orm/bundle.go

@@ -28,6 +28,7 @@ type Bundle struct {
 	BatchProofsStatus int16      `json:"batch_proofs_status" gorm:"column:batch_proofs_status;default:1"`
 	ProvingStatus     int16      `json:"proving_status" gorm:"column:proving_status;default:1"`
 	Proof             []byte     `json:"proof" gorm:"column:proof;default:NULL"`
+	ProverAssignedAt  *time.Time `json:"prover_assigned_at" gorm:"column:prover_assigned_at;default:NULL"`
 	ProvedAt          *time.Time `json:"proved_at" gorm:"column:proved_at;default:NULL"`
 	ProofTimeSec      int32      `json:"proof_time_sec" gorm:"column:proof_time_sec;default:NULL"`
 	TotalAttempts     int16      `json:"total_attempts" gorm:"column:total_attempts;default:0"`
@@ -135,14 +136,14 @@ func (o *Bundle) GetUnassignedAndBatchesUnreadyBundles(ctx context.Context, offs
 	return bundles, nil
 }
 
-// UpdateBatchProofsStatusByBundleHash updates the status of batch_proofs_status field for a given bundle hash.
-func (o *Bundle) UpdateBatchProofsStatusByBundleHash(ctx context.Context, bundleHash string, status types.BatchProofsStatus) error {
+// UpdateBatchProofsStatusByBatchHash updates the status of batch_proofs_status field for a given bundle hash.
+func (o *Bundle) UpdateBatchProofsStatusByBatchHash(ctx context.Context, bundleHash string, status types.BatchProofsStatus) error {
 	db := o.db.WithContext(ctx)
 	db = db.Model(&Bundle{})
 	db = db.Where("hash = ?", bundleHash)
 
 	if err := db.Update("batch_proofs_status", status).Error; err != nil {
-		return fmt.Errorf("Bundle.UpdateBatchProofsStatusByBundleHash error: %w, bundle hash: %v, status: %v", err, bundleHash, status.String())
+		return fmt.Errorf("Bundle.UpdateBatchProofsStatusByBatchHash error: %w, bundle hash: %v, status: %v", err, bundleHash, status.String())
 	}
 	return nil
 }

coordinator/internal/orm/challenge.go

@@ -2,7 +2,6 @@ package orm
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"time"
 
@@ -54,7 +53,7 @@ func (r *Challenge) InsertChallenge(ctx context.Context, challengeString string)
 		return fmt.Errorf("the challenge string:%s have been used", challengeString)
 	}
 
-	return errors.New("insert challenge string affected rows more than 1")
+	return fmt.Errorf("insert challenge string affected rows more than 1")
 }
 
 // DeleteExpireChallenge delete the expire challenge

coordinator/test/api_test.go

@@ -250,12 +250,12 @@ func testGetTaskBlocked(t *testing.T) {
 	expectedErr := fmt.Errorf("return prover task err:check prover task parameter failed, error:public key %s is blocked from fetching tasks. ProverName: %s, ProverVersion: %s", chunkProver.publicKey(), chunkProver.proverName, chunkProver.proverVersion)
 	code, errMsg := chunkProver.tryGetProverTask(t, message.ProofTypeChunk)
 	assert.Equal(t, types.ErrCoordinatorGetTaskFailure, code)
-	assert.Equal(t, expectedErr, errors.New(errMsg))
+	assert.Equal(t, expectedErr, fmt.Errorf(errMsg))
 
-	expectedErr = errors.New("get empty prover task")
+	expectedErr = fmt.Errorf("get empty prover task")
 	code, errMsg = batchProver.tryGetProverTask(t, message.ProofTypeBatch)
 	assert.Equal(t, types.ErrCoordinatorEmptyProofData, code)
-	assert.Equal(t, expectedErr, errors.New(errMsg))
+	assert.Equal(t, expectedErr, fmt.Errorf(errMsg))
 
 	err = proverBlockListOrm.InsertProverPublicKey(context.Background(), batchProver.proverName, batchProver.publicKey())
 	assert.NoError(t, err)
@@ -263,15 +263,15 @@ func testGetTaskBlocked(t *testing.T) {
 	err = proverBlockListOrm.DeleteProverPublicKey(context.Background(), chunkProver.publicKey())
 	assert.NoError(t, err)
 
-	expectedErr = errors.New("get empty prover task")
+	expectedErr = fmt.Errorf("get empty prover task")
 	code, errMsg = chunkProver.tryGetProverTask(t, message.ProofTypeChunk)
 	assert.Equal(t, types.ErrCoordinatorEmptyProofData, code)
-	assert.Equal(t, expectedErr, errors.New(errMsg))
+	assert.Equal(t, expectedErr, fmt.Errorf(errMsg))
 
 	expectedErr = fmt.Errorf("return prover task err:check prover task parameter failed, error:public key %s is blocked from fetching tasks. ProverName: %s, ProverVersion: %s", batchProver.publicKey(), batchProver.proverName, batchProver.proverVersion)
 	code, errMsg = batchProver.tryGetProverTask(t, message.ProofTypeBatch)
 	assert.Equal(t, types.ErrCoordinatorGetTaskFailure, code)
-	assert.Equal(t, expectedErr, errors.New(errMsg))
+	assert.Equal(t, expectedErr, fmt.Errorf(errMsg))
 }
 
 func testOutdatedProverVersion(t *testing.T) {
@@ -291,12 +291,12 @@ func testOutdatedProverVersion(t *testing.T) {
 	expectedErr := fmt.Errorf("check the login parameter failure: incompatible prover version. please upgrade your prover, minimum allowed version: %s, actual version: %s", minProverVersion, chunkProver.proverVersion)
 	code, errMsg := chunkProver.tryGetProverTask(t, message.ProofTypeChunk)
 	assert.Equal(t, types.ErrJWTCommonErr, code)
-	assert.Equal(t, expectedErr, errors.New(errMsg))
+	assert.Equal(t, expectedErr, fmt.Errorf(errMsg))
 
 	expectedErr = fmt.Errorf("check the login parameter failure: incompatible prover version. please upgrade your prover, minimum allowed version: %s, actual version: %s", minProverVersion, batchProver.proverVersion)
 	code, errMsg = batchProver.tryGetProverTask(t, message.ProofTypeBatch)
 	assert.Equal(t, types.ErrJWTCommonErr, code)
-	assert.Equal(t, expectedErr, errors.New(errMsg))
+	assert.Equal(t, expectedErr, fmt.Errorf(errMsg))
 }
 
 func testValidProof(t *testing.T) {

database/migrate/migrations/00021_bundle.sql

@@ -14,6 +14,7 @@ CREATE TABLE bundle (
     batch_proofs_status     SMALLINT        NOT NULL DEFAULT 1,
     proving_status          SMALLINT        NOT NULL DEFAULT 1,
     proof                   BYTEA           DEFAULT NULL,
+    prover_assigned_at      TIMESTAMP(0)    DEFAULT NULL,
     proved_at               TIMESTAMP(0)    DEFAULT NULL,
     proof_time_sec          INTEGER         DEFAULT NULL,
     total_attempts          SMALLINT        NOT NULL DEFAULT 0,

prover/Cargo.lock

@@ -65,7 +65,7 @@ dependencies = [
 [[package]]
 name = "aggregator"
 version = "0.12.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0-rc.3#706ba9ee7292b8e15a4fa0d4634a65dffa999402"
 dependencies = [
  "ark-std 0.3.0",
  "bitstream-io",
@@ -662,7 +662,7 @@ dependencies = [
 [[package]]
 name = "bus-mapping"
 version = "0.12.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0-rc.3#706ba9ee7292b8e15a4fa0d4634a65dffa999402"
 dependencies = [
  "eth-types 0.12.0",
  "ethers-core 2.0.7 (git+https://github.com/scroll-tech/ethers-rs.git?branch=v2.0.7)",
@@ -1341,7 +1341,7 @@ dependencies = [
 [[package]]
 name = "eth-types"
 version = "0.12.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0-rc.3#706ba9ee7292b8e15a4fa0d4634a65dffa999402"
 dependencies = [
  "base64 0.13.1",
  "ethers-core 2.0.7 (git+https://github.com/scroll-tech/ethers-rs.git?branch=v2.0.7)",
@@ -1574,7 +1574,7 @@ dependencies = [
 [[package]]
 name = "external-tracer"
 version = "0.12.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0-rc.3#706ba9ee7292b8e15a4fa0d4634a65dffa999402"
 dependencies = [
  "eth-types 0.12.0",
  "geth-utils 0.12.0",
@@ -1803,7 +1803,7 @@ dependencies = [
 [[package]]
 name = "gadgets"
 version = "0.12.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0-rc.3#706ba9ee7292b8e15a4fa0d4634a65dffa999402"
 dependencies = [
  "eth-types 0.12.0",
  "halo2_proofs",
@@ -1836,7 +1836,7 @@ dependencies = [
 [[package]]
 name = "geth-utils"
 version = "0.12.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0-rc.3#706ba9ee7292b8e15a4fa0d4634a65dffa999402"
 dependencies = [
  "env_logger 0.10.2",
  "gobuild",
@@ -2691,7 +2691,7 @@ dependencies = [
 [[package]]
 name = "mock"
 version = "0.12.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0-rc.3#706ba9ee7292b8e15a4fa0d4634a65dffa999402"
 dependencies = [
  "eth-types 0.12.0",
  "ethers-core 2.0.7 (git+https://github.com/scroll-tech/ethers-rs.git?branch=v2.0.7)",
@@ -2720,7 +2720,7 @@ dependencies = [
 [[package]]
 name = "mpt-zktrie"
 version = "0.12.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0-rc.3#706ba9ee7292b8e15a4fa0d4634a65dffa999402"
 dependencies = [
  "eth-types 0.12.0",
  "halo2curves",
@@ -3346,7 +3346,7 @@ dependencies = [
 [[package]]
 name = "prover"
 version = "0.12.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0-rc.3#706ba9ee7292b8e15a4fa0d4634a65dffa999402"
 dependencies = [
  "aggregator 0.12.0",
  "anyhow",
@@ -5383,7 +5383,7 @@ dependencies = [
 [[package]]
 name = "zkevm-circuits"
 version = "0.12.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0#6a1f65a1f99429f3725ef4d6788f5643bb61aa6f"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.12.0-rc.3#706ba9ee7292b8e15a4fa0d4634a65dffa999402"
 dependencies = [
  "array-init",
  "bus-mapping 0.12.0",

prover/Cargo.toml

@@ -30,7 +30,7 @@ ethers-providers = { git = "https://github.com/scroll-tech/ethers-rs.git", branc
 halo2_proofs = { git = "https://github.com/scroll-tech/halo2.git", branch = "v1.1" }
 snark-verifier-sdk = { git = "https://github.com/scroll-tech/snark-verifier", branch = "develop", default-features = false, features = ["loader_halo2", "loader_evm", "halo2-pse"] }
 prover_curie = { git = "https://github.com/scroll-tech/zkevm-circuits.git", tag = "v0.11.5", package = "prover", default-features = false, features = ["parallel_syn", "scroll"] }
-prover_darwin = { git = "https://github.com/scroll-tech/zkevm-circuits.git", tag = "v0.12.0", package = "prover", default-features = false, features = ["parallel_syn", "scroll"] }
+prover_darwin = { git = "https://github.com/scroll-tech/zkevm-circuits.git", tag = "v0.12.0-rc.3", package = "prover", default-features = false, features = ["parallel_syn", "scroll"] }
 base64 = "0.13.1"
 reqwest = { version = "0.12.4", features = ["gzip"] }
 reqwest-middleware = "0.3"

prover/src/prover.rs

@@ -71,6 +71,7 @@ impl<'a> Prover<'a> {
         let mut req = GetTaskRequest {
             task_types: get_task_types(self.config.prover_type),
             prover_height: None,
+            // vks: self.circuits_handler_provider.borrow().get_vks(),
         };
 
         if self.config.prover_type == ProverType::Chunk {

rollup/cmd/rollup_relayer/app/app.go

@@ -85,8 +85,19 @@ func action(ctx *cli.Context) error {
 	}
 
 	chunkProposer := watcher.NewChunkProposer(subCtx, cfg.L2Config.ChunkProposerConfig, genesis.Config, db, registry)
+	if err != nil {
+		log.Crit("failed to create chunkProposer", "config file", cfgFile, "error", err)
+	}
+
 	batchProposer := watcher.NewBatchProposer(subCtx, cfg.L2Config.BatchProposerConfig, genesis.Config, db, registry)
+	if err != nil {
+		log.Crit("failed to create batchProposer", "config file", cfgFile, "error", err)
+	}
+
 	bundleProposer := watcher.NewBundleProposer(subCtx, cfg.L2Config.BundleProposerConfig, genesis.Config, db, registry)
+	if err != nil {
+		log.Crit("failed to create bundleProposer", "config file", cfgFile, "error", err)
+	}
 
 	l2watcher := watcher.NewL2WatcherClient(subCtx, l2client, cfg.L2Config.Confirmations, cfg.L2Config.L2MessageQueueAddress, cfg.L2Config.WithdrawTrieRootSlot, db, registry)
 
@@ -100,9 +111,9 @@ func action(ctx *cli.Context) error {
 		l2watcher.TryFetchRunningMissingBlocks(number)
 	})
 
-	go utils.Loop(subCtx, time.Duration(cfg.L2Config.ChunkProposerConfig.ProposeIntervalMilliseconds)*time.Millisecond, chunkProposer.TryProposeChunk)
+	go utils.Loop(subCtx, 2*time.Second, chunkProposer.TryProposeChunk)
 
-	go utils.Loop(subCtx, time.Duration(cfg.L2Config.BatchProposerConfig.ProposeIntervalMilliseconds)*time.Millisecond, batchProposer.TryProposeBatch)
+	go utils.Loop(subCtx, 10*time.Second, batchProposer.TryProposeBatch)
 
 	go utils.Loop(subCtx, 10*time.Second, bundleProposer.TryProposeBundle)
 

rollup/conf/config.json

@@ -62,7 +62,6 @@
       "l1_commit_gas_limit_multiplier": 1.2
     },
     "chunk_proposer_config": {
-      "propose_interval_milliseconds": 100,
       "max_block_num_per_chunk": 100,
       "max_tx_num_per_chunk": 100,
       "max_l1_commit_gas_per_chunk": 11234567,
@@ -73,7 +72,6 @@
       "max_uncompressed_batch_bytes_size": 634880
     },
     "batch_proposer_config": {
-      "propose_interval_milliseconds": 1000,
       "max_l1_commit_gas_per_batch": 11234567,
       "max_l1_commit_calldata_size_per_batch": 112345,
       "batch_timeout_sec": 300,

rollup/go.mod

@@ -10,7 +10,7 @@ require (
 	github.com/go-resty/resty/v2 v2.7.0
 	github.com/holiman/uint256 v1.2.4
 	github.com/prometheus/client_golang v1.16.0
-	github.com/scroll-tech/da-codec v0.0.0-20240730031611-1b736159d5cb
+	github.com/scroll-tech/da-codec v0.0.0-20240718144756-1875fd490923
 	github.com/scroll-tech/go-ethereum v1.10.14-0.20240626125436-418bc6f728b6
 	github.com/smartystreets/goconvey v1.8.0
 	github.com/stretchr/testify v1.9.0

rollup/go.sum

@@ -236,8 +236,8 @@ github.com/rs/cors v1.7.0 h1:+88SsELBHx5r+hZ8TCkggzSstaWNbDvThkVK8H6f9ik=
 github.com/rs/cors v1.7.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU=
 github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/scroll-tech/da-codec v0.0.0-20240730031611-1b736159d5cb h1:uOKdmDT0LsuS3gfynEjR4zA3Ooh6p2Z3O+IMRj2r8LA=
-github.com/scroll-tech/da-codec v0.0.0-20240730031611-1b736159d5cb/go.mod h1:D6XEESeNVJkQJlv3eK+FyR+ufPkgVQbJzERylQi53Bs=
+github.com/scroll-tech/da-codec v0.0.0-20240718144756-1875fd490923 h1:QKgfS8G0btzg7nmFjSjllaxGkns3yg7g2/tG1nWExEI=
+github.com/scroll-tech/da-codec v0.0.0-20240718144756-1875fd490923/go.mod h1:D6XEESeNVJkQJlv3eK+FyR+ufPkgVQbJzERylQi53Bs=
 github.com/scroll-tech/go-ethereum v1.10.14-0.20240626125436-418bc6f728b6 h1:Q8YyvrcPIcXQwE4ucm4bqmPh6TP6IB1GUTXripf2WyQ=
 github.com/scroll-tech/go-ethereum v1.10.14-0.20240626125436-418bc6f728b6/go.mod h1:byf/mZ8jLYUCnUePTicjJWn+RvKdxDn7buS6glTnMwQ=
 github.com/scroll-tech/zktrie v0.8.4 h1:UagmnZ4Z3ITCk+aUq9NQZJNAwnWl4gSxsLb2Nl7IgRE=

rollup/internal/config/l2.go

@@ -28,7 +28,6 @@ type L2Config struct {
 
 // ChunkProposerConfig loads chunk_proposer configuration items.
 type ChunkProposerConfig struct {
-	ProposeIntervalMilliseconds     uint64  `json:"propose_interval_milliseconds"`
 	MaxBlockNumPerChunk             uint64  `json:"max_block_num_per_chunk"`
 	MaxTxNumPerChunk                uint64  `json:"max_tx_num_per_chunk"`
 	MaxL1CommitGasPerChunk          uint64  `json:"max_l1_commit_gas_per_chunk"`
@@ -41,7 +40,6 @@ type ChunkProposerConfig struct {
 
 // BatchProposerConfig loads batch_proposer configuration items.
 type BatchProposerConfig struct {
-	ProposeIntervalMilliseconds     uint64  `json:"propose_interval_milliseconds"`
 	MaxL1CommitGasPerBatch          uint64  `json:"max_l1_commit_gas_per_batch"`
 	MaxL1CommitCalldataSizePerBatch uint64  `json:"max_l1_commit_calldata_size_per_batch"`
 	BatchTimeoutSec                 uint64  `json:"batch_timeout_sec"`

rollup/internal/controller/relayer/l1_relayer.go

@@ -2,7 +2,6 @@ package relayer
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"math"
 	"math/big"
@@ -62,7 +61,7 @@ func NewLayer1Relayer(ctx context.Context, db *gorm.DB, cfg *config.RelayerConfi
 
 		// Ensure test features aren't enabled on the scroll mainnet.
 		if gasOracleSender.GetChainID().Cmp(big.NewInt(534352)) == 0 && cfg.EnableTestEnvBypassFeatures {
-			return nil, errors.New("cannot enable test env features in mainnet")
+			return nil, fmt.Errorf("cannot enable test env features in mainnet")
 		}
 	default:
 		return nil, fmt.Errorf("invalid service type for l1_relayer: %v", serviceType)

rollup/internal/controller/relayer/l2_relayer.go

@@ -87,7 +87,7 @@ func NewLayer2Relayer(ctx context.Context, l2Client *ethclient.Client, db *gorm.
 
 		// Ensure test features aren't enabled on the ethereum mainnet.
 		if gasOracleSender.GetChainID().Cmp(big.NewInt(1)) == 0 && cfg.EnableTestEnvBypassFeatures {
-			return nil, errors.New("cannot enable test env features in mainnet")
+			return nil, fmt.Errorf("cannot enable test env features in mainnet")
 		}
 
 	case ServiceTypeL2RollupRelayer:
@@ -105,7 +105,7 @@ func NewLayer2Relayer(ctx context.Context, l2Client *ethclient.Client, db *gorm.
 
 		// Ensure test features aren't enabled on the ethereum mainnet.
 		if commitSender.GetChainID().Cmp(big.NewInt(1)) == 0 && cfg.EnableTestEnvBypassFeatures {
-			return nil, errors.New("cannot enable test env features in mainnet")
+			return nil, fmt.Errorf("cannot enable test env features in mainnet")
 		}
 
 	default:
@@ -283,7 +283,7 @@ func (r *Layer2Relayer) commitGenesisBatch(batchHash string, batchHeader []byte,
 				return fmt.Errorf("unexpected import genesis confirmation id, expected: %v, got: %v", batchHash, confirmation.ContextID)
 			}
 			if !confirmation.IsSuccessful {
-				return errors.New("import genesis batch tx failed")
+				return fmt.Errorf("import genesis batch tx failed")
 			}
 			log.Info("Successfully committed genesis batch on L1", "txHash", confirmation.TxHash.String())
 			return nil
@@ -490,6 +490,7 @@ func (r *Layer2Relayer) ProcessCommittedBatches() {
 			"batch proving failed",
 			"Index", batch.Index,
 			"Hash", batch.Hash,
+			"ProverAssignedAt", batch.ProverAssignedAt,
 			"ProvedAt", batch.ProvedAt,
 			"ProofTimeSec", batch.ProofTimeSec,
 		)
@@ -537,7 +538,7 @@ func (r *Layer2Relayer) ProcessPendingBundles() {
 		//     stop the ledger, fix the limit, revert all the violating blocks,
 		//     chunks, batches, bundles and all subsequent ones, and resume,
 		//     i.e. this case requires manual resolution.
-		log.Error("bundle proving failed", "index", bundle.Index, "hash", bundle.Hash, "proved at", bundle.ProvedAt, "proof time sec", bundle.ProofTimeSec)
+		log.Error("bundle proving failed", "index", bundle.Index, "hash", bundle.Hash, "prover assigned at", bundle.ProverAssignedAt, "proved at", bundle.ProvedAt, "proof time sec", bundle.ProofTimeSec)
 
 	default:
 		log.Error("encounter unreachable case in ProcessPendingBundles", "proving status", status)
@@ -562,7 +563,7 @@ func (r *Layer2Relayer) finalizeBatch(dbBatch *orm.Batch, withProof bool) error
 	}
 
 	if dbBatch.Index == 0 {
-		return errors.New("invalid args: batch index is 0, should only happen in finalizing genesis batch")
+		return fmt.Errorf("invalid args: batch index is 0, should only happen in finalizing genesis batch")
 	}
 
 	dbParentBatch, getErr := r.batchOrm.GetBatchByIndex(r.ctx, dbBatch.Index-1)
@@ -651,11 +652,11 @@ func (r *Layer2Relayer) finalizeBatch(dbBatch *orm.Batch, withProof bool) error
 	// 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 {
+		txErr := r.db.Transaction(func(tx *gorm.DB) error {
+			if updateErr := r.batchOrm.UpdateProvingStatus(r.ctx, dbBatch.Hash, types.ProvingTaskVerified); updateErr != nil {
 				return updateErr
 			}
-			if updateErr := r.chunkOrm.UpdateProvingStatusByBatchHash(r.ctx, dbBatch.Hash, types.ProvingTaskVerified, dbTX); updateErr != nil {
+			if updateErr := r.chunkOrm.UpdateProvingStatusByBatchHash(r.ctx, dbBatch.Hash, types.ProvingTaskVerified); updateErr != nil {
 				return updateErr
 			}
 			return nil
@@ -734,11 +735,11 @@ func (r *Layer2Relayer) finalizeBundle(bundle *orm.Bundle, withProof bool) error
 	// 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.bundleOrm.UpdateProvingStatus(r.ctx, bundle.Hash, types.ProvingTaskVerified, dbTX); updateErr != nil {
+		txErr := r.db.Transaction(func(tx *gorm.DB) error {
+			if updateErr := r.bundleOrm.UpdateProvingStatus(r.ctx, bundle.Hash, types.ProvingTaskVerified); updateErr != nil {
 				return updateErr
 			}
-			if updateErr := r.batchOrm.UpdateProvingStatusByBundleHash(r.ctx, bundle.Hash, types.ProvingTaskVerified, dbTX); updateErr != nil {
+			if updateErr := r.batchOrm.UpdateProvingStatusByBundleHash(r.ctx, bundle.Hash, types.ProvingTaskVerified); updateErr != nil {
 				return updateErr
 			}
 			for batchIndex := bundle.StartBatchIndex; batchIndex <= bundle.EndBatchIndex; batchIndex++ {
@@ -746,7 +747,7 @@ func (r *Layer2Relayer) finalizeBundle(bundle *orm.Bundle, withProof bool) error
 				if getErr != nil {
 					return getErr
 				}
-				if updateErr := r.chunkOrm.UpdateProvingStatusByBatchHash(r.ctx, tmpBatch.Hash, types.ProvingTaskVerified, dbTX); updateErr != nil {
+				if updateErr := r.chunkOrm.UpdateProvingStatusByBatchHash(r.ctx, tmpBatch.Hash, types.ProvingTaskVerified); updateErr != nil {
 					return updateErr
 				}
 			}

rollup/internal/controller/sender/estimategas.go

@@ -1,7 +1,7 @@
 package sender
 
 import (
-	"errors"
+	"fmt"
 	"math/big"
 
 	"github.com/scroll-tech/go-ethereum"
@@ -150,7 +150,7 @@ func (s *Sender) estimateGasLimit(to *common.Address, data []byte, sidecar *geth
 	}
 	if errStr != "" {
 		log.Error("CreateAccessList reported error", "error", errStr)
-		return gasLimitWithoutAccessList, nil, errors.New(errStr)
+		return gasLimitWithoutAccessList, nil, fmt.Errorf(errStr)
 	}
 
 	// Fine-tune accessList because 'to' address is automatically included in the access list by the Ethereum protocol: https://github.com/ethereum/go-ethereum/blob/v1.13.10/core/state/statedb.go#L1322

rollup/internal/controller/sender/sender_test.go

@@ -585,7 +585,7 @@ func testCheckPendingTransactionResubmitTxConfirmed(t *testing.T) {
 
 		patchGuard2 := gomonkey.ApplyMethodFunc(s.client, "TransactionReceipt", func(_ context.Context, hash common.Hash) (*gethTypes.Receipt, error) {
 			if hash == originTxHash {
-				return nil, errors.New("simulated transaction receipt error")
+				return nil, fmt.Errorf("simulated transaction receipt error")
 			}
 			return &gethTypes.Receipt{TxHash: hash, BlockNumber: big.NewInt(0), Status: gethTypes.ReceiptStatusSuccessful}, nil
 		})
@@ -657,7 +657,7 @@ func testCheckPendingTransactionReplacedTxConfirmed(t *testing.T) {
 					Status:      gethTypes.ReceiptStatusSuccessful,
 				}, nil
 			}
-			return nil, errors.New("simulated transaction receipt error")
+			return nil, fmt.Errorf("simulated transaction receipt error")
 		})
 
 		// Attempt to resubmit the transaction.
@@ -714,7 +714,7 @@ func testCheckPendingTransactionTxMultipleTimesWithOnlyOneTxPending(t *testing.T
 		assert.Equal(t, types.SenderTypeCommitBatch, txs[0].SenderType)
 
 		patchGuard2 := gomonkey.ApplyMethodFunc(s.client, "TransactionReceipt", func(_ context.Context, hash common.Hash) (*gethTypes.Receipt, error) {
-			return nil, errors.New("simulated transaction receipt error")
+			return nil, fmt.Errorf("simulated transaction receipt error")
 		})
 
 		for i := 1; i <= 6; i++ {

rollup/internal/orm/batch.go

@@ -488,7 +488,7 @@ func (o *Batch) UpdateProvingStatusByBundleHash(ctx context.Context, bundleHash
 	return nil
 }
 
-// UpdateFinalizeTxHashAndRollupStatusByBundleHash updates the finalize transaction hash and rollup status for batches with the specified bundle_hash
+// UpdateFinalizeTxHashAndRollupStatusByBundleHash updates the the finalize transaction hash and rollup status for batches within the specified bundle_hash
 func (o *Batch) UpdateFinalizeTxHashAndRollupStatusByBundleHash(ctx context.Context, bundleHash string, finalizeTxHash string, status types.RollupStatus, dbTX ...*gorm.DB) error {
 	updateFields := make(map[string]interface{})
 	updateFields["finalize_tx_hash"] = finalizeTxHash

rollup/internal/orm/bundle.go

@@ -35,6 +35,7 @@ type Bundle struct {
 	BatchProofsStatus int16      `json:"batch_proofs_status" gorm:"column:batch_proofs_status;default:1"`
 	ProvingStatus     int16      `json:"proving_status" gorm:"column:proving_status;default:1"`
 	Proof             []byte     `json:"proof" gorm:"column:proof;default:NULL"`
+	ProverAssignedAt  *time.Time `json:"prover_assigned_at" gorm:"column:prover_assigned_at;default:NULL"`
 	ProvedAt          *time.Time `json:"proved_at" gorm:"column:proved_at;default:NULL"`
 	ProofTimeSec      int32      `json:"proof_time_sec" gorm:"column:proof_time_sec;default:NULL"`
 
@@ -213,6 +214,10 @@ func (o *Bundle) UpdateProvingStatus(ctx context.Context, hash string, status ty
 	updateFields["proving_status"] = int(status)
 
 	switch status {
+	case types.ProvingTaskAssigned:
+		updateFields["prover_assigned_at"] = time.Now()
+	case types.ProvingTaskUnassigned:
+		updateFields["prover_assigned_at"] = nil
 	case types.ProvingTaskVerified:
 		updateFields["proved_at"] = time.Now()
 	}

rollup/internal/orm/orm_test.go

@@ -503,6 +503,7 @@ func TestBundleOrm(t *testing.T) {
 		err = db.Where("hash = ?", bundle1.Hash).First(&bundle).Error
 		assert.NoError(t, err)
 		assert.Equal(t, int16(types.ProvingTaskAssigned), bundle.ProvingStatus)
+		assert.NotNil(t, bundle.ProverAssignedAt)
 
 		err = bundleOrm.UpdateProvingStatus(context.Background(), bundle1.Hash, types.ProvingTaskVerified)
 		assert.NoError(t, err)

tests/integration-test/genesis.json

@@ -14,9 +14,9 @@
     "londonBlock": 0,
     "archimedesBlock": 0,
     "shanghaiBlock": 0,
-    "bernoulliBlock": 0,
-    "curieBlock": 0,
-    "darwinTime": 0,
+    "bernoulliBlock": 2,
+    "curieBlock": 3,
+    "darwinTime": 1719558098,
     "clique": {
       "period": 3,
       "epoch": 30000

tests/integration-test/go.mod

@@ -3,7 +3,7 @@ module scroll-tech/integration-test
 go 1.21
 
 require (
-	github.com/scroll-tech/da-codec v0.0.0-20240730031611-1b736159d5cb
+	github.com/scroll-tech/da-codec v0.0.0-20240718144756-1875fd490923
 	github.com/scroll-tech/go-ethereum v1.10.14-0.20240626125436-418bc6f728b6
 	github.com/stretchr/testify v1.9.0
 	gorm.io/gorm v1.25.7-0.20240204074919-46816ad31dde

tests/integration-test/go.sum

@@ -89,8 +89,8 @@ github.com/rjeczalik/notify v0.9.1 h1:CLCKso/QK1snAlnhNR/CNvNiFU2saUtjV0bx3EwNeC
 github.com/rjeczalik/notify v0.9.1/go.mod h1:rKwnCoCGeuQnwBtTSPL9Dad03Vh2n40ePRrjvIXnJho=
 github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjRBZyWFQ=
 github.com/rogpeppe/go-internal v1.10.0/go.mod h1:UQnix2H7Ngw/k4C5ijL5+65zddjncjaFoBhdsK/akog=
-github.com/scroll-tech/da-codec v0.0.0-20240730031611-1b736159d5cb h1:uOKdmDT0LsuS3gfynEjR4zA3Ooh6p2Z3O+IMRj2r8LA=
-github.com/scroll-tech/da-codec v0.0.0-20240730031611-1b736159d5cb/go.mod h1:D6XEESeNVJkQJlv3eK+FyR+ufPkgVQbJzERylQi53Bs=
+github.com/scroll-tech/da-codec v0.0.0-20240718144756-1875fd490923 h1:QKgfS8G0btzg7nmFjSjllaxGkns3yg7g2/tG1nWExEI=
+github.com/scroll-tech/da-codec v0.0.0-20240718144756-1875fd490923/go.mod h1:D6XEESeNVJkQJlv3eK+FyR+ufPkgVQbJzERylQi53Bs=
 github.com/scroll-tech/go-ethereum v1.10.14-0.20240626125436-418bc6f728b6 h1:Q8YyvrcPIcXQwE4ucm4bqmPh6TP6IB1GUTXripf2WyQ=
 github.com/scroll-tech/go-ethereum v1.10.14-0.20240626125436-418bc6f728b6/go.mod h1:byf/mZ8jLYUCnUePTicjJWn+RvKdxDn7buS6glTnMwQ=
 github.com/scroll-tech/zktrie v0.8.4 h1:UagmnZ4Z3ITCk+aUq9NQZJNAwnWl4gSxsLb2Nl7IgRE=