fix: libzkp v0.5.13 (#779)

Co-authored-by: HAOYUatHZ <haoyu@protonmail.com>

bridge/conf/config.json

@@ -27,12 +27,8 @@
         "gas_price_diff": 50000
       },
       "finalize_batch_interval_sec": 0,
-      "message_sender_private_keys": [
-        "1212121212121212121212121212121212121212121212121212121212121212"
-      ],
-      "gas_oracle_sender_private_keys": [
-        "1313131313131313131313131313131313131313131313131313131313131313"
-      ]
+      "message_sender_private_key": "1212121212121212121212121212121212121212121212121212121212121212",
+      "gas_oracle_sender_private_key": "1313131313131313131313131313131313131313131313131313131313131313"
     }
   },
   "l2_config": {
@@ -62,15 +58,10 @@
         "gas_price_diff": 50000
       },
       "finalize_batch_interval_sec": 0,
-      "message_sender_private_keys": [
-        "1212121212121212121212121212121212121212121212121212121212121212"
-      ],
-      "gas_oracle_sender_private_keys": [
-        "1313131313131313131313131313131313131313131313131313131313131313"
-      ],
-      "rollup_sender_private_keys": [
-        "1414141414141414141414141414141414141414141414141414141414141414"
-      ]
+      "message_sender_private_key": "1212121212121212121212121212121212121212121212121212121212121212",
+      "gas_oracle_sender_private_key": "1313131313131313131313131313131313131313131313131313131313131313",
+      "commit_sender_private_key": "1414141414141414141414141414141414141414141414141414141414141414",
+      "finalize_sender_private_key": "1515151515151515151515151515151515151515151515151515151515151515"
     },
     "chunk_proposer_config": {
       "max_tx_gas_per_chunk": 1123456,

bridge/go.mod

@@ -4,13 +4,11 @@ go 1.19
 
 require (
 	github.com/agiledragon/gomonkey/v2 v2.9.0
-	github.com/orcaman/concurrent-map v1.0.0
 	github.com/orcaman/concurrent-map/v2 v2.0.1
 	github.com/scroll-tech/go-ethereum v1.10.14-0.20230804022247-26eeb40ea3ca
 	github.com/smartystreets/goconvey v1.8.0
 	github.com/stretchr/testify v1.8.3
 	github.com/urfave/cli/v2 v2.25.7
-	golang.org/x/sync v0.3.0
 	gorm.io/gorm v1.25.2
 )
 
@@ -53,6 +51,7 @@ require (
 	github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 // indirect
 	github.com/yusufpapurcu/wmi v1.2.2 // indirect
 	golang.org/x/crypto v0.11.0 // indirect
+	golang.org/x/sync v0.3.0 // indirect
 	golang.org/x/sys v0.10.0 // indirect
 	golang.org/x/time v0.3.0 // indirect
 	gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect

bridge/go.sum

@@ -84,8 +84,6 @@ github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N
 github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
 github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
 github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
-github.com/orcaman/concurrent-map v1.0.0 h1:I/2A2XPCb4IuQWcQhBhSwGfiuybl/J0ev9HDbW65HOY=
-github.com/orcaman/concurrent-map v1.0.0/go.mod h1:Lu3tH6HLW3feq74c2GC+jIMS/K2CFcDWnWD9XkenwhI=
 github.com/orcaman/concurrent-map/v2 v2.0.1 h1:jOJ5Pg2w1oeB6PeDurIYf6k9PQ+aTITr/6lP/L/zp6c=
 github.com/orcaman/concurrent-map/v2 v2.0.1/go.mod h1:9Eq3TG2oBe5FirmYWQfYO5iH1q0Jv47PLaNK++uCdOM=
 github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=

bridge/internal/config/config_test.go

@@ -15,10 +15,6 @@ func TestConfig(t *testing.T) {
 		cfg, err := NewConfig("../../conf/config.json")
 		assert.NoError(t, err)
 
-		assert.Len(t, cfg.L1Config.RelayerConfig.MessageSenderPrivateKeys, 1)
-		assert.Len(t, cfg.L2Config.RelayerConfig.MessageSenderPrivateKeys, 1)
-		assert.Len(t, cfg.L2Config.RelayerConfig.RollupSenderPrivateKeys, 1)
-
 		data, err := json.Marshal(cfg)
 		assert.NoError(t, err)
 

bridge/internal/config/relayer.go

@@ -34,12 +34,11 @@ type SenderConfig struct {
 	// The interval (in seconds) to check balance and top up sender's accounts
 	CheckBalanceTime uint64 `json:"check_balance_time"`
 	// The sender's pending count limit.
-	PendingLimit int `json:"pending_limit,omitempty"`
+	PendingLimit int `json:"pending_limit"`
 }
 
 // RelayerConfig loads relayer configuration items.
 // What we need to pay attention to is that
-// `MessageSenderPrivateKeys` and `RollupSenderPrivateKeys` cannot have common private keys.
 type RelayerConfig struct {
 	// RollupContractAddress store the rollup contract address.
 	RollupContractAddress common.Address `json:"rollup_contract_address,omitempty"`
@@ -56,9 +55,10 @@ type RelayerConfig struct {
 	// MessageRelayMinGasLimit to avoid OutOfGas error
 	MessageRelayMinGasLimit uint64 `json:"message_relay_min_gas_limit,omitempty"`
 	// The private key of the relayer
-	MessageSenderPrivateKeys   []*ecdsa.PrivateKey `json:"-"`
-	GasOracleSenderPrivateKeys []*ecdsa.PrivateKey `json:"-"`
-	RollupSenderPrivateKeys    []*ecdsa.PrivateKey `json:"-"`
+	MessageSenderPrivateKey   *ecdsa.PrivateKey `json:"-"`
+	GasOracleSenderPrivateKey *ecdsa.PrivateKey `json:"-"`
+	CommitSenderPrivateKey    *ecdsa.PrivateKey `json:"-"`
+	FinalizeSenderPrivateKey  *ecdsa.PrivateKey `json:"-"`
 }
 
 // GasOracleConfig The config for updating gas price oracle.
@@ -72,46 +72,61 @@ type GasOracleConfig struct {
 // relayerConfigAlias RelayerConfig alias name
 type relayerConfigAlias RelayerConfig
 
+func convertAndCheck(key string, uniqueAddressesSet map[string]struct{}) (*ecdsa.PrivateKey, error) {
+	if key == "" {
+		return nil, nil
+	}
+
+	privKey, err := crypto.ToECDSA(common.FromHex(key))
+	if err != nil {
+		return nil, err
+	}
+
+	addr := crypto.PubkeyToAddress(privKey.PublicKey).Hex()
+	if _, exists := uniqueAddressesSet[addr]; exists {
+		return nil, fmt.Errorf("detected duplicated address for private key: %s", addr)
+	}
+	uniqueAddressesSet[addr] = struct{}{}
+
+	return privKey, nil
+}
+
 // UnmarshalJSON unmarshal relayer_config struct.
 func (r *RelayerConfig) UnmarshalJSON(input []byte) error {
-	var jsonConfig struct {
+	var privateKeysConfig struct {
 		relayerConfigAlias
-		// The private key of the relayer
-		MessageSenderPrivateKeys   []string `json:"message_sender_private_keys"`
-		GasOracleSenderPrivateKeys []string `json:"gas_oracle_sender_private_keys"`
-		RollupSenderPrivateKeys    []string `json:"rollup_sender_private_keys,omitempty"`
+		MessageSenderPrivateKey   string `json:"message_sender_private_key"`
+		GasOracleSenderPrivateKey string `json:"gas_oracle_sender_private_key"`
+		CommitSenderPrivateKey    string `json:"commit_sender_private_key"`
+		FinalizeSenderPrivateKey  string `json:"finalize_sender_private_key"`
 	}
-	if err := json.Unmarshal(input, &jsonConfig); err != nil {
-		return err
+	var err error
+	if err = json.Unmarshal(input, &privateKeysConfig); err != nil {
+		return fmt.Errorf("failed to unmarshal private keys config: %w", err)
 	}
 
-	*r = RelayerConfig(jsonConfig.relayerConfigAlias)
+	*r = RelayerConfig(privateKeysConfig.relayerConfigAlias)
 
-	// Get messenger private key list.
-	for _, privStr := range jsonConfig.MessageSenderPrivateKeys {
-		priv, err := crypto.ToECDSA(common.FromHex(privStr))
-		if err != nil {
-			return fmt.Errorf("incorrect private_key_list format, err: %v", err)
-		}
-		r.MessageSenderPrivateKeys = append(r.MessageSenderPrivateKeys, priv)
+	uniqueAddressesSet := make(map[string]struct{})
+
+	r.MessageSenderPrivateKey, err = convertAndCheck(privateKeysConfig.MessageSenderPrivateKey, uniqueAddressesSet)
+	if err != nil {
+		return fmt.Errorf("error converting and checking message sender private key: %w", err)
 	}
 
-	// Get gas oracle private key list.
-	for _, privStr := range jsonConfig.GasOracleSenderPrivateKeys {
-		priv, err := crypto.ToECDSA(common.FromHex(privStr))
-		if err != nil {
-			return fmt.Errorf("incorrect private_key_list format, err: %v", err)
-		}
-		r.GasOracleSenderPrivateKeys = append(r.GasOracleSenderPrivateKeys, priv)
+	r.GasOracleSenderPrivateKey, err = convertAndCheck(privateKeysConfig.GasOracleSenderPrivateKey, uniqueAddressesSet)
+	if err != nil {
+		return fmt.Errorf("error converting and checking gas oracle sender private key: %w", err)
 	}
 
-	// Get rollup private key
-	for _, privStr := range jsonConfig.RollupSenderPrivateKeys {
-		priv, err := crypto.ToECDSA(common.FromHex(privStr))
-		if err != nil {
-			return fmt.Errorf("incorrect prover_private_key format, err: %v", err)
-		}
-		r.RollupSenderPrivateKeys = append(r.RollupSenderPrivateKeys, priv)
+	r.CommitSenderPrivateKey, err = convertAndCheck(privateKeysConfig.CommitSenderPrivateKey, uniqueAddressesSet)
+	if err != nil {
+		return fmt.Errorf("error converting and checking commit sender private key: %w", err)
+	}
+
+	r.FinalizeSenderPrivateKey, err = convertAndCheck(privateKeysConfig.FinalizeSenderPrivateKey, uniqueAddressesSet)
+	if err != nil {
+		return fmt.Errorf("error converting and checking finalize sender private key: %w", err)
 	}
 
 	return nil
@@ -119,28 +134,20 @@ func (r *RelayerConfig) UnmarshalJSON(input []byte) error {
 
 // MarshalJSON marshal RelayerConfig config, transfer private keys.
 func (r *RelayerConfig) MarshalJSON() ([]byte, error) {
-	jsonConfig := struct {
+	privateKeysConfig := struct {
 		relayerConfigAlias
 		// The private key of the relayer
-		MessageSenderPrivateKeys   []string `json:"message_sender_private_keys"`
-		GasOracleSenderPrivateKeys []string `json:"gas_oracle_sender_private_keys,omitempty"`
-		RollupSenderPrivateKeys    []string `json:"rollup_sender_private_keys,omitempty"`
-	}{relayerConfigAlias(*r), nil, nil, nil}
+		MessageSenderPrivateKey   string `json:"message_sender_private_key"`
+		GasOracleSenderPrivateKey string `json:"gas_oracle_sender_private_key"`
+		CommitSenderPrivateKey    string `json:"commit_sender_private_key"`
+		FinalizeSenderPrivateKey  string `json:"finalize_sender_private_key"`
+	}{}
 
-	// Transfer message sender private keys to hex type.
-	for _, priv := range r.MessageSenderPrivateKeys {
-		jsonConfig.MessageSenderPrivateKeys = append(jsonConfig.MessageSenderPrivateKeys, common.Bytes2Hex(crypto.FromECDSA(priv)))
-	}
+	privateKeysConfig.relayerConfigAlias = relayerConfigAlias(*r)
+	privateKeysConfig.MessageSenderPrivateKey = common.Bytes2Hex(crypto.FromECDSA(r.MessageSenderPrivateKey))
+	privateKeysConfig.GasOracleSenderPrivateKey = common.Bytes2Hex(crypto.FromECDSA(r.GasOracleSenderPrivateKey))
+	privateKeysConfig.CommitSenderPrivateKey = common.Bytes2Hex(crypto.FromECDSA(r.CommitSenderPrivateKey))
+	privateKeysConfig.FinalizeSenderPrivateKey = common.Bytes2Hex(crypto.FromECDSA(r.FinalizeSenderPrivateKey))
 
-	// Transfer rollup sender private keys to hex type.
-	for _, priv := range r.GasOracleSenderPrivateKeys {
-		jsonConfig.GasOracleSenderPrivateKeys = append(jsonConfig.GasOracleSenderPrivateKeys, common.Bytes2Hex(crypto.FromECDSA(priv)))
-	}
-
-	// Transfer rollup sender private keys to hex type.
-	for _, priv := range r.RollupSenderPrivateKeys {
-		jsonConfig.RollupSenderPrivateKeys = append(jsonConfig.RollupSenderPrivateKeys, common.Bytes2Hex(crypto.FromECDSA(priv)))
-	}
-
-	return json.Marshal(&jsonConfig)
+	return json.Marshal(&privateKeysConfig)
 }

bridge/internal/controller/relayer/l1_relayer.go

@@ -3,6 +3,7 @@ package relayer
 import (
 	"context"
 	"errors"
+	"fmt"
 	"math/big"
 
 	// not sure if this will make problems when relay with l1geth
@@ -57,19 +58,16 @@ type Layer1Relayer struct {
 
 // NewLayer1Relayer will return a new instance of Layer1RelayerClient
 func NewLayer1Relayer(ctx context.Context, db *gorm.DB, cfg *config.RelayerConfig) (*Layer1Relayer, error) {
-	messageSender, err := sender.NewSender(ctx, cfg.SenderConfig, cfg.MessageSenderPrivateKeys)
+	messageSender, err := sender.NewSender(ctx, cfg.SenderConfig, cfg.MessageSenderPrivateKey)
 	if err != nil {
-		addr := crypto.PubkeyToAddress(cfg.MessageSenderPrivateKeys[0].PublicKey)
-		log.Error("new MessageSender failed", "main address", addr.String(), "err", err)
-		return nil, err
+		addr := crypto.PubkeyToAddress(cfg.MessageSenderPrivateKey.PublicKey)
+		return nil, fmt.Errorf("new message sender failed for address %s, err: %v", addr.Hex(), err)
 	}
 
-	// @todo make sure only one sender is available
-	gasOracleSender, err := sender.NewSender(ctx, cfg.SenderConfig, cfg.GasOracleSenderPrivateKeys)
+	gasOracleSender, err := sender.NewSender(ctx, cfg.SenderConfig, cfg.GasOracleSenderPrivateKey)
 	if err != nil {
-		addr := crypto.PubkeyToAddress(cfg.GasOracleSenderPrivateKeys[0].PublicKey)
-		log.Error("new GasOracleSender failed", "main address", addr.String(), "err", err)
-		return nil, err
+		addr := crypto.PubkeyToAddress(cfg.GasOracleSenderPrivateKey.PublicKey)
+		return nil, fmt.Errorf("new gas oracle sender failed for address %s, err: %v", addr.Hex(), err)
 	}
 
 	var minGasPrice uint64

bridge/internal/controller/relayer/l2_relayer.go

@@ -11,6 +11,7 @@ import (
 	"github.com/scroll-tech/go-ethereum/accounts/abi"
 	"github.com/scroll-tech/go-ethereum/common"
 	gethTypes "github.com/scroll-tech/go-ethereum/core/types"
+	"github.com/scroll-tech/go-ethereum/crypto"
 	"github.com/scroll-tech/go-ethereum/ethclient"
 	"github.com/scroll-tech/go-ethereum/log"
 	gethMetrics "github.com/scroll-tech/go-ethereum/metrics"
@@ -53,8 +54,9 @@ type Layer2Relayer struct {
 	messageSender  *sender.Sender
 	l1MessengerABI *abi.ABI
 
-	rollupSender *sender.Sender
-	l1RollupABI  *abi.ABI
+	commitSender   *sender.Sender
+	finalizeSender *sender.Sender
+	l1RollupABI    *abi.ABI
 
 	gasOracleSender *sender.Sender
 	l2GasOracleABI  *abi.ABI
@@ -80,23 +82,28 @@ type Layer2Relayer struct {
 
 // NewLayer2Relayer will return a new instance of Layer2RelayerClient
 func NewLayer2Relayer(ctx context.Context, l2Client *ethclient.Client, db *gorm.DB, cfg *config.RelayerConfig, initGenesis bool) (*Layer2Relayer, error) {
-	// @todo use different sender for relayer, block commit and proof finalize
-	messageSender, err := sender.NewSender(ctx, cfg.SenderConfig, cfg.MessageSenderPrivateKeys)
+	messageSender, err := sender.NewSender(ctx, cfg.SenderConfig, cfg.MessageSenderPrivateKey)
 	if err != nil {
-		log.Error("Failed to create messenger sender", "err", err)
-		return nil, err
+		addr := crypto.PubkeyToAddress(cfg.MessageSenderPrivateKey.PublicKey)
+		return nil, fmt.Errorf("new message sender failed for address %s, err: %w", addr.Hex(), err)
 	}
 
-	rollupSender, err := sender.NewSender(ctx, cfg.SenderConfig, cfg.RollupSenderPrivateKeys)
+	commitSender, err := sender.NewSender(ctx, cfg.SenderConfig, cfg.CommitSenderPrivateKey)
 	if err != nil {
-		log.Error("Failed to create rollup sender", "err", err)
-		return nil, err
+		addr := crypto.PubkeyToAddress(cfg.CommitSenderPrivateKey.PublicKey)
+		return nil, fmt.Errorf("new commit sender failed for address %s, err: %w", addr.Hex(), err)
 	}
 
-	gasOracleSender, err := sender.NewSender(ctx, cfg.SenderConfig, cfg.GasOracleSenderPrivateKeys)
+	finalizeSender, err := sender.NewSender(ctx, cfg.SenderConfig, cfg.FinalizeSenderPrivateKey)
 	if err != nil {
-		log.Error("Failed to create gas oracle sender", "err", err)
-		return nil, err
+		addr := crypto.PubkeyToAddress(cfg.FinalizeSenderPrivateKey.PublicKey)
+		return nil, fmt.Errorf("new finalize sender failed for address %s, err: %w", addr.Hex(), err)
+	}
+
+	gasOracleSender, err := sender.NewSender(ctx, cfg.SenderConfig, cfg.GasOracleSenderPrivateKey)
+	if err != nil {
+		addr := crypto.PubkeyToAddress(cfg.GasOracleSenderPrivateKey.PublicKey)
+		return nil, fmt.Errorf("new gas oracle sender failed for address %s, err: %w", addr.Hex(), err)
 	}
 
 	var minGasPrice uint64
@@ -127,8 +134,9 @@ func NewLayer2Relayer(ctx context.Context, l2Client *ethclient.Client, db *gorm.
 		messageSender:  messageSender,
 		l1MessengerABI: bridgeAbi.L1ScrollMessengerABI,
 
-		rollupSender: rollupSender,
-		l1RollupABI:  bridgeAbi.ScrollChainABI,
+		commitSender:   commitSender,
+		finalizeSender: finalizeSender,
+		l1RollupABI:    bridgeAbi.ScrollChainABI,
 
 		gasOracleSender: gasOracleSender,
 		l2GasOracleABI:  bridgeAbi.L2GasPriceOracleABI,
@@ -230,7 +238,7 @@ func (r *Layer2Relayer) commitGenesisBatch(batchHash string, batchHeader []byte,
 	}
 
 	// submit genesis batch to L1 rollup contract
-	txHash, err := r.rollupSender.SendTransaction(batchHash, &r.cfg.RollupContractAddress, big.NewInt(0), calldata, 0)
+	txHash, err := r.commitSender.SendTransaction(batchHash, &r.cfg.RollupContractAddress, big.NewInt(0), calldata, 0)
 	if err != nil {
 		return fmt.Errorf("failed to send import genesis batch tx to L1, error: %v", err)
 	}
@@ -245,14 +253,14 @@ func (r *Layer2Relayer) commitGenesisBatch(batchHash string, batchHeader []byte,
 		select {
 		// print progress
 		case <-ticker.C:
-			log.Info("Waiting for confirmation", "pending count", r.rollupSender.PendingCount())
+			log.Info("Waiting for confirmation")
 
 		// timeout
 		case <-time.After(5 * time.Minute):
 			return fmt.Errorf("import genesis timeout after 5 minutes, original txHash: %v", txHash.String())
 
 		// handle confirmation
-		case confirmation := <-r.rollupSender.ConfirmChan():
+		case confirmation := <-r.commitSender.ConfirmChan():
 			if confirmation.ID != batchHash {
 				return fmt.Errorf("unexpected import genesis confirmation id, expected: %v, got: %v", batchHash, confirmation.ID)
 			}
@@ -374,7 +382,7 @@ func (r *Layer2Relayer) ProcessPendingBatches() {
 
 		// send transaction
 		txID := batch.Hash + "-commit"
-		txHash, err := r.rollupSender.SendTransaction(txID, &r.cfg.RollupContractAddress, big.NewInt(0), calldata, 0)
+		txHash, err := r.commitSender.SendTransaction(txID, &r.cfg.RollupContractAddress, big.NewInt(0), calldata, 0)
 		if err != nil {
 			log.Error(
 				"Failed to send commitBatch tx to layer1",
@@ -468,7 +476,7 @@ func (r *Layer2Relayer) ProcessCommittedBatches() {
 
 		txID := hash + "-finalize"
 		// add suffix `-finalize` to avoid duplication with commit tx in unit tests
-		txHash, err := r.rollupSender.SendTransaction(txID, &r.cfg.RollupContractAddress, big.NewInt(0), data, 0)
+		txHash, err := r.finalizeSender.SendTransaction(txID, &r.cfg.RollupContractAddress, big.NewInt(0), data, 0)
 		finalizeTxHash := &txHash
 		if err != nil {
 			if !errors.Is(err, sender.ErrNoAvailableAccount) && !errors.Is(err, sender.ErrFullPending) {
@@ -577,7 +585,9 @@ func (r *Layer2Relayer) handleConfirmLoop(ctx context.Context) {
 			return
 		case confirmation := <-r.messageSender.ConfirmChan():
 			r.handleConfirmation(confirmation)
-		case confirmation := <-r.rollupSender.ConfirmChan():
+		case confirmation := <-r.commitSender.ConfirmChan():
+			r.handleConfirmation(confirmation)
+		case confirmation := <-r.finalizeSender.ConfirmChan():
 			r.handleConfirmation(confirmation)
 		case cfm := <-r.gasOracleSender.ConfirmChan():
 			if !cfm.IsSuccessful {

bridge/internal/controller/relayer/l2_relayer_test.go

@@ -106,7 +106,7 @@ func testL2RelayerProcessCommittedBatches(t *testing.T) {
 	assert.Equal(t, types.RollupFinalizing, statuses[0])
 }
 
-func testL2RelayerRollupConfirm(t *testing.T) {
+func testL2RelayerCommitConfirm(t *testing.T) {
 	db := setupL2RelayerDB(t)
 	defer database.CloseDB(db)
 
@@ -118,8 +118,8 @@ func testL2RelayerRollupConfirm(t *testing.T) {
 	assert.NoError(t, err)
 
 	// Simulate message confirmations.
-	processingKeys := []string{"committed-1", "committed-2", "finalized-1", "finalized-2"}
-	isSuccessful := []bool{true, false, true, false}
+	processingKeys := []string{"committed-1", "committed-2"}
+	isSuccessful := []bool{true, false}
 
 	batchOrm := orm.NewBatch(db)
 	batchHashes := make([]string, len(processingKeys))
@@ -129,29 +129,68 @@ func testL2RelayerRollupConfirm(t *testing.T) {
 		batchHashes[i] = batch.Hash
 	}
 
-	for i, key := range processingKeys[:2] {
+	for i, key := range processingKeys {
 		l2Relayer.processingCommitment.Store(key, batchHashes[i])
-		l2Relayer.rollupSender.SendConfirmation(&sender.Confirmation{
+		l2Relayer.commitSender.SendConfirmation(&sender.Confirmation{
 			ID:           key,
 			IsSuccessful: isSuccessful[i],
 			TxHash:       common.HexToHash("0x123456789abcdef"),
 		})
 	}
 
-	for i, key := range processingKeys[2:] {
-		l2Relayer.processingFinalization.Store(key, batchHashes[i+2])
-		l2Relayer.rollupSender.SendConfirmation(&sender.Confirmation{
-			ID:           key,
-			IsSuccessful: isSuccessful[i+2],
-			TxHash:       common.HexToHash("0x123456789abcdef"),
-		})
-	}
-
 	// Check the database for the updated status using TryTimes.
 	ok := utils.TryTimes(5, func() bool {
 		expectedStatuses := []types.RollupStatus{
 			types.RollupCommitted,
 			types.RollupCommitFailed,
+		}
+
+		for i, batchHash := range batchHashes {
+			batchInDB, err := batchOrm.GetBatches(context.Background(), map[string]interface{}{"hash": batchHash}, nil, 0)
+			if err != nil || len(batchInDB) != 1 || types.RollupStatus(batchInDB[0].RollupStatus) != expectedStatuses[i] {
+				return false
+			}
+		}
+		return true
+	})
+	assert.True(t, ok)
+}
+
+func testL2RelayerFinalizeConfirm(t *testing.T) {
+	db := setupL2RelayerDB(t)
+	defer database.CloseDB(db)
+
+	// Create and set up the Layer2 Relayer.
+	l2Cfg := cfg.L2Config
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	l2Relayer, err := NewLayer2Relayer(ctx, l2Cli, db, l2Cfg.RelayerConfig, false)
+	assert.NoError(t, err)
+
+	// Simulate message confirmations.
+	processingKeys := []string{"finalized-1", "finalized-2"}
+	isSuccessful := []bool{true, false}
+
+	batchOrm := orm.NewBatch(db)
+	batchHashes := make([]string, len(processingKeys))
+	for i := range batchHashes {
+		batch, err := batchOrm.InsertBatch(context.Background(), 0, 1, chunkHash1.Hex(), chunkHash2.Hex(), []*types.Chunk{chunk1, chunk2})
+		assert.NoError(t, err)
+		batchHashes[i] = batch.Hash
+	}
+
+	for i, key := range processingKeys {
+		l2Relayer.processingFinalization.Store(key, batchHashes[i])
+		l2Relayer.finalizeSender.SendConfirmation(&sender.Confirmation{
+			ID:           key,
+			IsSuccessful: isSuccessful[i],
+			TxHash:       common.HexToHash("0x123456789abcdef"),
+		})
+	}
+
+	// Check the database for the updated status using TryTimes.
+	ok := utils.TryTimes(5, func() bool {
+		expectedStatuses := []types.RollupStatus{
 			types.RollupFinalized,
 			types.RollupFinalizeFailed,
 		}

bridge/internal/controller/relayer/relayer_test.go

@@ -97,7 +97,8 @@ func TestFunctions(t *testing.T) {
 	t.Run("TestCreateNewRelayer", testCreateNewRelayer)
 	t.Run("TestL2RelayerProcessPendingBatches", testL2RelayerProcessPendingBatches)
 	t.Run("TestL2RelayerProcessCommittedBatches", testL2RelayerProcessCommittedBatches)
-	t.Run("TestL2RelayerRollupConfirm", testL2RelayerRollupConfirm)
+	t.Run("TestL2RelayerCommitConfirm", testL2RelayerCommitConfirm)
+	t.Run("TestL2RelayerFinalizeConfirm", testL2RelayerFinalizeConfirm)
 	t.Run("TestL2RelayerGasOracleConfirm", testL2RelayerGasOracleConfirm)
 	t.Run("TestLayer2RelayerProcessGasPriceOracle", testLayer2RelayerProcessGasPriceOracle)
 }

bridge/internal/controller/sender/account_pool.go

@@ -1,165 +0,0 @@
-package sender
-
-import (
-	"context"
-	"crypto/ecdsa"
-	"fmt"
-	"math/big"
-
-	"github.com/scroll-tech/go-ethereum/accounts/abi/bind"
-	"github.com/scroll-tech/go-ethereum/common"
-	"github.com/scroll-tech/go-ethereum/core/types"
-	"github.com/scroll-tech/go-ethereum/ethclient"
-	"github.com/scroll-tech/go-ethereum/log"
-)
-
-type accountPool struct {
-	client *ethclient.Client
-
-	minBalance *big.Int
-	accounts   map[common.Address]*bind.TransactOpts
-	accsCh     chan *bind.TransactOpts
-}
-
-// newAccounts creates an accountPool instance.
-func newAccountPool(ctx context.Context, minBalance *big.Int, client *ethclient.Client, privs []*ecdsa.PrivateKey) (*accountPool, error) {
-	accs := &accountPool{
-		client:     client,
-		minBalance: minBalance,
-		accounts:   make(map[common.Address]*bind.TransactOpts, len(privs)),
-		accsCh:     make(chan *bind.TransactOpts, len(privs)+2),
-	}
-
-	// get chainID from client
-	chainID, err := client.ChainID(ctx)
-	if err != nil {
-		return nil, err
-	}
-
-	for _, privStr := range privs {
-		auth, err := bind.NewKeyedTransactorWithChainID(privStr, chainID)
-		if err != nil {
-			log.Error("failed to create account", "chainID", chainID.String(), "err", err)
-			return nil, err
-		}
-
-		// Set pending nonce
-		nonce, err := client.PendingNonceAt(ctx, auth.From)
-		if err != nil {
-			return nil, err
-		}
-		auth.Nonce = big.NewInt(int64(nonce))
-		accs.accounts[auth.From] = auth
-		accs.accsCh <- auth
-	}
-
-	return accs, accs.checkAndSetBalances(ctx)
-}
-
-// getAccount get auth from channel.
-func (a *accountPool) getAccount() *bind.TransactOpts {
-	select {
-	case auth := <-a.accsCh:
-		return auth
-	default:
-		return nil
-	}
-}
-
-// releaseAccount set used auth into channel.
-func (a *accountPool) releaseAccount(auth *bind.TransactOpts) {
-	a.accsCh <- auth
-}
-
-// reSetNonce reset nonce if send signed tx failed.
-func (a *accountPool) resetNonce(ctx context.Context, auth *bind.TransactOpts) {
-	nonce, err := a.client.PendingNonceAt(ctx, auth.From)
-	if err != nil {
-		log.Warn("failed to reset nonce", "address", auth.From.String(), "err", err)
-		return
-	}
-	auth.Nonce = big.NewInt(int64(nonce))
-}
-
-// checkAndSetBalance check balance and set min balance.
-func (a *accountPool) checkAndSetBalances(ctx context.Context) error {
-	var (
-		root      *bind.TransactOpts
-		maxBls    = big.NewInt(0)
-		lostAuths []*bind.TransactOpts
-	)
-
-	for addr, auth := range a.accounts {
-		bls, err := a.client.BalanceAt(ctx, addr, nil)
-		if err != nil || bls.Cmp(a.minBalance) < 0 {
-			if err != nil {
-				log.Warn("failed to get balance", "address", addr.String(), "err", err)
-				return err
-			}
-			lostAuths = append(lostAuths, auth)
-			continue
-		} else if bls.Cmp(maxBls) > 0 { // Find the biggest balance account.
-			root, maxBls = auth, bls
-		}
-	}
-	if root == nil {
-		return fmt.Errorf("no account has enough balance")
-	}
-	if len(lostAuths) == 0 {
-		return nil
-	}
-
-	var (
-		tx  *types.Transaction
-		err error
-	)
-	for _, auth := range lostAuths {
-		tx, err = a.createSignedTx(root, &auth.From, a.minBalance)
-		if err != nil {
-			return err
-		}
-		err = a.client.SendTransaction(ctx, tx)
-		if err != nil {
-			log.Error("Failed to send balance to account", "err", err)
-			return err
-		}
-		log.Debug("send balance to account", "account", auth.From.String(), "balance", a.minBalance.String())
-	}
-	// wait util mined
-	if _, err = bind.WaitMined(ctx, a.client, tx); err != nil {
-		return err
-	}
-
-	// Reset root's nonce.
-	a.resetNonce(ctx, root)
-
-	return nil
-}
-
-func (a *accountPool) createSignedTx(from *bind.TransactOpts, to *common.Address, value *big.Int) (*types.Transaction, error) {
-	gasPrice, err := a.client.SuggestGasPrice(context.Background())
-	if err != nil {
-		return nil, err
-	}
-	gasPrice.Mul(gasPrice, big.NewInt(2))
-
-	// Get pending nonce
-	nonce, err := a.client.PendingNonceAt(context.Background(), from.From)
-	if err != nil {
-		return nil, err
-	}
-
-	tx := types.NewTx(&types.LegacyTx{
-		Nonce:    nonce,
-		To:       to,
-		Value:    value,
-		Gas:      500000,
-		GasPrice: gasPrice,
-	})
-	signedTx, err := from.Signer(from.From, tx)
-	if err != nil {
-		return nil, err
-	}
-
-	return signedTx, nil
-}

bridge/internal/controller/sender/sender.go

@@ -39,10 +39,6 @@ var (
 	ErrFullPending = errors.New("sender's pending pool is full")
 )
 
-var (
-	defaultPendingLimit = 10
-)
-
 // Confirmation struct used to indicate transaction confirmation details
 type Confirmation struct {
 	ID           string
@@ -75,8 +71,8 @@ type Sender struct {
 	chainID *big.Int          // The chain id of the endpoint
 	ctx     context.Context
 
-	// account fields.
-	auths *accountPool
+	auth       *bind.TransactOpts
+	minBalance *big.Int
 
 	blockNumber   uint64                                            // Current block number on chain.
 	baseFeePerGas uint64                                            // Current base fee per gas on chain
@@ -88,27 +84,34 @@ type Sender struct {
 
 // NewSender returns a new instance of transaction sender
 // txConfirmationCh is used to notify confirmed transaction
-func NewSender(ctx context.Context, config *config.SenderConfig, privs []*ecdsa.PrivateKey) (*Sender, error) {
+func NewSender(ctx context.Context, config *config.SenderConfig, priv *ecdsa.PrivateKey) (*Sender, error) {
 	client, err := ethclient.Dial(config.Endpoint)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("failed to dial eth client, err: %w", err)
 	}
 
 	// get chainID from client
 	chainID, err := client.ChainID(ctx)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("failed to get chain ID, err: %w", err)
 	}
 
-	auths, err := newAccountPool(ctx, config.MinBalance, client, privs)
+	auth, err := bind.NewKeyedTransactorWithChainID(priv, chainID)
 	if err != nil {
-		return nil, fmt.Errorf("failed to create account pool, err: %v", err)
+		return nil, fmt.Errorf("failed to create transactor with chain ID %v, err: %w", chainID, err)
 	}
 
+	// Set pending nonce
+	nonce, err := client.PendingNonceAt(ctx, auth.From)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get pending nonce for address %s, err: %w", auth.From.Hex(), err)
+	}
+	auth.Nonce = big.NewInt(int64(nonce))
+
 	// get header by number
 	header, err := client.HeaderByNumber(ctx, nil)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("failed to get header by number, err: %w", err)
 	}
 
 	var baseFeePerGas uint64
@@ -116,21 +119,17 @@ func NewSender(ctx context.Context, config *config.SenderConfig, privs []*ecdsa.
 		if header.BaseFee != nil {
 			baseFeePerGas = header.BaseFee.Uint64()
 		} else {
-			return nil, errors.New("DynamicFeeTxType not supported, header.BaseFee nil")
+			return nil, errors.New("dynamic fee tx type not supported: header.BaseFee is nil")
 		}
 	}
 
-	// initialize pending limit with a default value
-	if config.PendingLimit == 0 {
-		config.PendingLimit = defaultPendingLimit
-	}
-
 	sender := &Sender{
 		ctx:           ctx,
 		config:        config,
 		client:        client,
 		chainID:       chainID,
-		auths:         auths,
+		auth:          auth,
+		minBalance:    config.MinBalance,
 		confirmCh:     make(chan *Confirmation, 128),
 		blockNumber:   header.Number.Uint64(),
 		baseFeePerGas: baseFeePerGas,
@@ -175,11 +174,6 @@ func (s *Sender) SendConfirmation(cfm *Confirmation) {
 	s.confirmCh <- cfm
 }
 
-// NumberOfAccounts return the count of accounts.
-func (s *Sender) NumberOfAccounts() int {
-	return len(s.auths.accounts)
-}
-
 func (s *Sender) getFeeData(auth *bind.TransactOpts, target *common.Address, value *big.Int, data []byte, minGasLimit uint64) (*FeeData, error) {
 	if s.config.TxType == DynamicFeeTxType {
 		return s.estimateDynamicGas(auth, target, value, data, minGasLimit)
@@ -188,53 +182,39 @@ func (s *Sender) getFeeData(auth *bind.TransactOpts, target *common.Address, val
 }
 
 // SendTransaction send a signed L2tL1 transaction.
-func (s *Sender) SendTransaction(ID string, target *common.Address, value *big.Int, data []byte, minGasLimit uint64) (hash common.Hash, err error) {
+func (s *Sender) SendTransaction(ID string, target *common.Address, value *big.Int, data []byte, minGasLimit uint64) (common.Hash, error) {
 	if s.IsFull() {
 		return common.Hash{}, ErrFullPending
 	}
-	// We occupy the ID, in case some other threads call with the same ID in the same time
 	if ok := s.pendingTxs.SetIfAbsent(ID, nil); !ok {
-		return common.Hash{}, fmt.Errorf("has the repeat tx ID, ID: %s", ID)
+		return common.Hash{}, fmt.Errorf("repeat transaction ID: %s", ID)
 	}
-	// get
-	auth := s.auths.getAccount()
-	if auth == nil {
-		s.pendingTxs.Remove(ID) // release the ID on failure
-		return common.Hash{}, ErrNoAvailableAccount
-	}
-
-	defer s.auths.releaseAccount(auth)
-	defer func() {
-		if err != nil {
-			s.pendingTxs.Remove(ID) // release the ID on failure
-		}
-	}()
 
 	var (
 		feeData *FeeData
 		tx      *types.Transaction
+		err     error
 	)
-	// estimate gas fee
-	if feeData, err = s.getFeeData(auth, target, value, data, minGasLimit); err != nil {
-		return
+	if feeData, err = s.getFeeData(s.auth, target, value, data, minGasLimit); err != nil {
+		return common.Hash{}, fmt.Errorf("failed to get fee data, err: %w", err)
 	}
-	if tx, err = s.createAndSendTx(auth, feeData, target, value, data, nil); err == nil {
-		// add pending transaction to queue
-		pending := &PendingTransaction{
-			tx:       tx,
-			id:       ID,
-			signer:   auth,
-			submitAt: atomic.LoadUint64(&s.blockNumber),
-			feeData:  feeData,
-		}
-		s.pendingTxs.Set(ID, pending)
-		return tx.Hash(), nil
+	if tx, err = s.createAndSendTx(s.auth, feeData, target, value, data, nil); err != nil {
+		return common.Hash{}, fmt.Errorf("failed to create and send transaction, err: %w", err)
 	}
 
-	return
+	// add pending transaction
+	pending := &PendingTransaction{
+		tx:       tx,
+		id:       ID,
+		signer:   s.auth,
+		submitAt: atomic.LoadUint64(&s.blockNumber),
+		feeData:  feeData,
+	}
+	s.pendingTxs.Set(ID, pending)
+	return tx.Hash(), nil
 }
 
-func (s *Sender) createAndSendTx(auth *bind.TransactOpts, feeData *FeeData, target *common.Address, value *big.Int, data []byte, overrideNonce *uint64) (tx *types.Transaction, err error) {
+func (s *Sender) createAndSendTx(auth *bind.TransactOpts, feeData *FeeData, target *common.Address, value *big.Int, data []byte, overrideNonce *uint64) (*types.Transaction, error) {
 	var (
 		nonce  = auth.Nonce.Uint64()
 		txData types.TxData
@@ -292,26 +272,36 @@ func (s *Sender) createAndSendTx(auth *bind.TransactOpts, feeData *FeeData, targ
 	}
 
 	// sign and send
-	tx, err = auth.Signer(auth.From, types.NewTx(txData))
+	tx, err := auth.Signer(auth.From, types.NewTx(txData))
 	if err != nil {
 		log.Error("failed to sign tx", "err", err)
-		return
+		return nil, err
 	}
 	if err = s.client.SendTransaction(s.ctx, tx); err != nil {
 		log.Error("failed to send tx", "tx hash", tx.Hash().String(), "err", err)
 		// Check if contain nonce, and reset nonce
 		// only reset nonce when it is not from resubmit
 		if strings.Contains(err.Error(), "nonce") && overrideNonce == nil {
-			s.auths.resetNonce(context.Background(), auth)
+			s.resetNonce(context.Background())
 		}
-		return
+		return nil, err
 	}
 
 	// update nonce when it is not from resubmit
 	if overrideNonce == nil {
 		auth.Nonce = big.NewInt(int64(nonce + 1))
 	}
-	return
+	return tx, nil
+}
+
+// reSetNonce reset nonce if send signed tx failed.
+func (s *Sender) resetNonce(ctx context.Context) {
+	nonce, err := s.client.PendingNonceAt(ctx, s.auth.From)
+	if err != nil {
+		log.Warn("failed to reset nonce", "address", s.auth.From.String(), "err", err)
+		return
+	}
+	s.auth.Nonce = big.NewInt(int64(nonce))
 }
 
 func (s *Sender) resubmitTransaction(feeData *FeeData, auth *bind.TransactOpts, tx *types.Transaction) (*types.Transaction, error) {
@@ -448,6 +438,22 @@ func (s *Sender) checkPendingTransaction(header *types.Header, confirmed uint64)
 	}
 }
 
+// checkBalance checks balance and print error log if balance is under a threshold.
+func (s *Sender) checkBalance(ctx context.Context) error {
+	bls, err := s.client.BalanceAt(ctx, s.auth.From, nil)
+	if err != nil {
+		log.Warn("failed to get balance", "address", s.auth.From.String(), "err", err)
+		return err
+	}
+
+	if bls.Cmp(s.minBalance) < 0 {
+		return fmt.Errorf("insufficient account balance - actual balance: %s, minimum required balance: %s",
+			bls.String(), s.minBalance.String())
+	}
+
+	return nil
+}
+
 // Loop is the main event loop
 func (s *Sender) loop(ctx context.Context) {
 	checkTick := time.NewTicker(time.Duration(s.config.CheckPendingTime) * time.Second)
@@ -474,7 +480,9 @@ func (s *Sender) loop(ctx context.Context) {
 			s.checkPendingTransaction(header, confirmed)
 		case <-checkBalanceTicker.C:
 			// Check and set balance.
-			_ = s.auths.checkAndSetBalances(ctx)
+			if err := s.checkBalance(ctx); err != nil {
+				log.Error("check balance, err: %w", err)
+			}
 		case <-ctx.Done():
 			return
 		case <-s.stopCh:

bridge/internal/controller/sender/sender_test.go

@@ -7,10 +7,8 @@ import (
 	"math/big"
 	"strconv"
 	"testing"
-	"time"
 
 	"github.com/agiledragon/gomonkey/v2"
-	cmap "github.com/orcaman/concurrent-map"
 	"github.com/scroll-tech/go-ethereum/accounts/abi/bind"
 	"github.com/scroll-tech/go-ethereum/common"
 	"github.com/scroll-tech/go-ethereum/core/types"
@@ -18,7 +16,6 @@ import (
 	"github.com/scroll-tech/go-ethereum/ethclient"
 	"github.com/scroll-tech/go-ethereum/rpc"
 	"github.com/stretchr/testify/assert"
-	"golang.org/x/sync/errgroup"
 
 	"scroll-tech/common/docker"
 
@@ -28,10 +25,10 @@ import (
 const TXBatch = 50
 
 var (
-	privateKeys []*ecdsa.PrivateKey
-	cfg         *config.Config
-	base        *docker.App
-	txTypes     = []string{"LegacyTx", "AccessListTx", "DynamicFeeTx"}
+	privateKey *ecdsa.PrivateKey
+	cfg        *config.Config
+	base       *docker.App
+	txTypes    = []string{"LegacyTx", "AccessListTx", "DynamicFeeTx"}
 )
 
 func TestMain(m *testing.M) {
@@ -50,7 +47,7 @@ func setupEnv(t *testing.T) {
 	priv, err := crypto.HexToECDSA("1212121212121212121212121212121212121212121212121212121212121212")
 	assert.NoError(t, err)
 	// Load default private key.
-	privateKeys = []*ecdsa.PrivateKey{priv}
+	privateKey = priv
 
 	cfg.L1Config.RelayerConfig.SenderConfig.Endpoint = base.L1gethImg.Endpoint()
 	cfg.L1Config.RelayerConfig.SenderConfig.CheckBalanceTime = 1
@@ -62,15 +59,10 @@ func TestSender(t *testing.T) {
 
 	t.Run("test new sender", testNewSender)
 	t.Run("test pending limit", testPendLimit)
-
 	t.Run("test min gas limit", testMinGasLimit)
 	t.Run("test resubmit transaction", testResubmitTransaction)
 	t.Run("test resubmit transaction with rising base fee", testResubmitTransactionWithRisingBaseFee)
 	t.Run("test check pending transaction", testCheckPendingTransaction)
-
-	t.Run("test 1 account sender", func(t *testing.T) { testBatchSender(t, 1) })
-	t.Run("test 3 account sender", func(t *testing.T) { testBatchSender(t, 3) })
-	t.Run("test 8 account sender", func(t *testing.T) { testBatchSender(t, 8) })
 }
 
 func testNewSender(t *testing.T) {
@@ -78,7 +70,7 @@ func testNewSender(t *testing.T) {
 		// exit by Stop()
 		cfgCopy1 := *cfg.L1Config.RelayerConfig.SenderConfig
 		cfgCopy1.TxType = txType
-		newSender1, err := NewSender(context.Background(), &cfgCopy1, privateKeys)
+		newSender1, err := NewSender(context.Background(), &cfgCopy1, privateKey)
 		assert.NoError(t, err)
 		newSender1.Stop()
 
@@ -86,7 +78,7 @@ func testNewSender(t *testing.T) {
 		cfgCopy2 := *cfg.L1Config.RelayerConfig.SenderConfig
 		cfgCopy2.TxType = txType
 		subCtx, cancel := context.WithCancel(context.Background())
-		_, err = NewSender(subCtx, &cfgCopy2, privateKeys)
+		_, err = NewSender(subCtx, &cfgCopy2, privateKey)
 		assert.NoError(t, err)
 		cancel()
 	}
@@ -98,7 +90,7 @@ func testPendLimit(t *testing.T) {
 		cfgCopy.TxType = txType
 		cfgCopy.Confirmations = rpc.LatestBlockNumber
 		cfgCopy.PendingLimit = 2
-		newSender, err := NewSender(context.Background(), &cfgCopy, privateKeys)
+		newSender, err := NewSender(context.Background(), &cfgCopy, privateKey)
 		assert.NoError(t, err)
 
 		for i := 0; i < 2*newSender.PendingLimit(); i++ {
@@ -115,7 +107,7 @@ func testMinGasLimit(t *testing.T) {
 		cfgCopy := *cfg.L1Config.RelayerConfig.SenderConfig
 		cfgCopy.TxType = txType
 		cfgCopy.Confirmations = rpc.LatestBlockNumber
-		newSender, err := NewSender(context.Background(), &cfgCopy, privateKeys)
+		newSender, err := NewSender(context.Background(), &cfgCopy, privateKey)
 		assert.NoError(t, err)
 
 		client, err := ethclient.Dial(cfgCopy.Endpoint)
@@ -143,13 +135,12 @@ func testResubmitTransaction(t *testing.T) {
 	for _, txType := range txTypes {
 		cfgCopy := *cfg.L1Config.RelayerConfig.SenderConfig
 		cfgCopy.TxType = txType
-		s, err := NewSender(context.Background(), &cfgCopy, privateKeys)
+		s, err := NewSender(context.Background(), &cfgCopy, privateKey)
 		assert.NoError(t, err)
-		auth := s.auths.getAccount()
-		tx := types.NewTransaction(auth.Nonce.Uint64(), common.Address{}, big.NewInt(0), 0, big.NewInt(0), nil)
-		feeData, err := s.getFeeData(auth, &common.Address{}, big.NewInt(0), nil, 0)
+		tx := types.NewTransaction(s.auth.Nonce.Uint64(), common.Address{}, big.NewInt(0), 0, big.NewInt(0), nil)
+		feeData, err := s.getFeeData(s.auth, &common.Address{}, big.NewInt(0), nil, 0)
 		assert.NoError(t, err)
-		_, err = s.resubmitTransaction(feeData, auth, tx)
+		_, err = s.resubmitTransaction(feeData, s.auth, tx)
 		assert.NoError(t, err)
 		s.Stop()
 	}
@@ -160,17 +151,16 @@ func testResubmitTransactionWithRisingBaseFee(t *testing.T) {
 
 	cfgCopy := *cfg.L1Config.RelayerConfig.SenderConfig
 	cfgCopy.TxType = txType
-	s, err := NewSender(context.Background(), &cfgCopy, privateKeys)
+	s, err := NewSender(context.Background(), &cfgCopy, privateKey)
 	assert.NoError(t, err)
-	auth := s.auths.getAccount()
-	tx := types.NewTransaction(auth.Nonce.Uint64(), common.Address{}, big.NewInt(0), 0, big.NewInt(0), nil)
+	tx := types.NewTransaction(s.auth.Nonce.Uint64(), common.Address{}, big.NewInt(0), 0, big.NewInt(0), nil)
 	s.baseFeePerGas = 1000
-	feeData, err := s.getFeeData(auth, &common.Address{}, big.NewInt(0), nil, 0)
+	feeData, err := s.getFeeData(s.auth, &common.Address{}, big.NewInt(0), nil, 0)
 	assert.NoError(t, err)
 	// bump the basefee by 10x
 	s.baseFeePerGas *= 10
 	// resubmit and check that the gas fee has been adjusted accordingly
-	newTx, err := s.resubmitTransaction(feeData, auth, tx)
+	newTx, err := s.resubmitTransaction(feeData, s.auth, tx)
 	assert.NoError(t, err)
 
 	escalateMultipleNum := new(big.Int).SetUint64(s.config.EscalateMultipleNum)
@@ -196,14 +186,13 @@ func testCheckPendingTransaction(t *testing.T) {
 	for _, txType := range txTypes {
 		cfgCopy := *cfg.L1Config.RelayerConfig.SenderConfig
 		cfgCopy.TxType = txType
-		s, err := NewSender(context.Background(), &cfgCopy, privateKeys)
+		s, err := NewSender(context.Background(), &cfgCopy, privateKey)
 		assert.NoError(t, err)
 
 		header := &types.Header{Number: big.NewInt(100), BaseFee: big.NewInt(100)}
 		confirmed := uint64(100)
 		receipt := &types.Receipt{Status: types.ReceiptStatusSuccessful, BlockNumber: big.NewInt(90)}
-		auth := s.auths.getAccount()
-		tx := types.NewTransaction(auth.Nonce.Uint64(), common.Address{}, big.NewInt(0), 0, big.NewInt(0), nil)
+		tx := types.NewTransaction(s.auth.Nonce.Uint64(), common.Address{}, big.NewInt(0), 0, big.NewInt(0), nil)
 
 		testCases := []struct {
 			name          string
@@ -280,66 +269,3 @@ func testCheckPendingTransaction(t *testing.T) {
 		s.Stop()
 	}
 }
-
-func testBatchSender(t *testing.T, batchSize int) {
-	for _, txType := range txTypes {
-		for len(privateKeys) < batchSize {
-			priv, err := crypto.GenerateKey()
-			assert.NoError(t, err)
-			privateKeys = append(privateKeys, priv)
-		}
-
-		cfgCopy := *cfg.L1Config.RelayerConfig.SenderConfig
-		cfgCopy.Confirmations = rpc.LatestBlockNumber
-		cfgCopy.PendingLimit = batchSize * TXBatch
-		cfgCopy.TxType = txType
-		newSender, err := NewSender(context.Background(), &cfgCopy, privateKeys)
-		assert.NoError(t, err)
-
-		// send transactions
-		var (
-			eg        errgroup.Group
-			idCache   = cmap.New()
-			confirmCh = newSender.ConfirmChan()
-		)
-		for idx := 0; idx < newSender.NumberOfAccounts(); idx++ {
-			index := idx
-			eg.Go(func() error {
-				for i := 0; i < TXBatch; i++ {
-					toAddr := common.HexToAddress("0x4592d8f8d7b001e72cb26a73e4fa1806a51ac79d")
-					id := strconv.Itoa(i + index*1000)
-					_, err := newSender.SendTransaction(id, &toAddr, big.NewInt(1), nil, 0)
-					if errors.Is(err, ErrNoAvailableAccount) || errors.Is(err, ErrFullPending) {
-						<-time.After(time.Second)
-						continue
-					}
-					assert.NoError(t, err)
-					idCache.Set(id, struct{}{})
-				}
-				return nil
-			})
-		}
-		assert.NoError(t, eg.Wait())
-		t.Logf("successful send batch txs, batch size: %d, total count: %d", newSender.NumberOfAccounts(), TXBatch*newSender.NumberOfAccounts())
-
-		// avoid 10 mins cause testcase panic
-		after := time.After(80 * time.Second)
-		isDone := false
-		for !isDone {
-			select {
-			case cmsg := <-confirmCh:
-				assert.Equal(t, true, cmsg.IsSuccessful)
-				_, exist := idCache.Pop(cmsg.ID)
-				assert.Equal(t, true, exist)
-				// Receive all confirmed txs.
-				if idCache.Count() == 0 {
-					isDone = true
-				}
-			case <-after:
-				t.Error("newSender test failed because of timeout")
-				isDone = true
-			}
-		}
-		newSender.Stop()
-	}
-}

bridge/internal/controller/watcher/l2_watcher_test.go

@@ -50,7 +50,7 @@ func testCreateNewWatcherAndStop(t *testing.T) {
 
 	l1cfg := cfg.L1Config
 	l1cfg.RelayerConfig.SenderConfig.Confirmations = rpc.LatestBlockNumber
-	newSender, err := sender.NewSender(context.Background(), l1cfg.RelayerConfig.SenderConfig, l1cfg.RelayerConfig.MessageSenderPrivateKeys)
+	newSender, err := sender.NewSender(context.Background(), l1cfg.RelayerConfig.SenderConfig, l1cfg.RelayerConfig.MessageSenderPrivateKey)
 	assert.NoError(t, err)
 
 	// Create several transactions and commit to block
@@ -71,7 +71,7 @@ func testFetchRunningMissingBlocks(t *testing.T) {
 	_, db := setupL2Watcher(t)
 	defer database.CloseDB(db)
 
-	auth := prepareAuth(t, l2Cli, cfg.L2Config.RelayerConfig.MessageSenderPrivateKeys[0])
+	auth := prepareAuth(t, l2Cli, cfg.L2Config.RelayerConfig.MessageSenderPrivateKey)
 
 	// deploy mock bridge
 	_, tx, _, err := mock_bridge.DeployMockBridgeL2(auth, l2Cli)

bridge/tests/bridge_test.go

@@ -83,10 +83,10 @@ func setupEnv(t *testing.T) {
 	l2Cfg.Confirmations = 0
 	l2Cfg.RelayerConfig.SenderConfig.Confirmations = 0
 
-	l1Auth, err = bind.NewKeyedTransactorWithChainID(bridgeApp.Config.L2Config.RelayerConfig.MessageSenderPrivateKeys[0], base.L1gethImg.ChainID())
+	l1Auth, err = bind.NewKeyedTransactorWithChainID(bridgeApp.Config.L2Config.RelayerConfig.MessageSenderPrivateKey, base.L1gethImg.ChainID())
 	assert.NoError(t, err)
 
-	l2Auth, err = bind.NewKeyedTransactorWithChainID(bridgeApp.Config.L1Config.RelayerConfig.MessageSenderPrivateKeys[0], base.L2gethImg.ChainID())
+	l2Auth, err = bind.NewKeyedTransactorWithChainID(bridgeApp.Config.L1Config.RelayerConfig.MessageSenderPrivateKey, base.L2gethImg.ChainID())
 	assert.NoError(t, err)
 }
 

common/libzkp/impl/Cargo.lock

@@ -32,13 +32,14 @@ dependencies = [
 [[package]]
 name = "aggregator"
 version = "0.1.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.5.12#554bdcf00334bab45670b8daa72d687a7ff2b919"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.5.13#a8c59b2e6e0a845c78d6b93a80c0a9c0601f59d0"
 dependencies = [
  "ark-std",
  "env_logger 0.10.0",
  "eth-types",
  "ethers-core",
  "halo2_proofs",
+ "hex",
  "itertools",
  "log",
  "rand",
@@ -432,7 +433,7 @@ checksum = "a3e2c3daef883ecc1b5d58c15adae93470a91d425f3532ba1695849656af3fc1"
 [[package]]
 name = "bus-mapping"
 version = "0.1.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.5.12#554bdcf00334bab45670b8daa72d687a7ff2b919"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.5.13#a8c59b2e6e0a845c78d6b93a80c0a9c0601f59d0"
 dependencies = [
  "eth-types",
  "ethers-core",
@@ -1048,7 +1049,7 @@ dependencies = [
 [[package]]
 name = "eth-types"
 version = "0.1.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.5.12#554bdcf00334bab45670b8daa72d687a7ff2b919"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.5.13#a8c59b2e6e0a845c78d6b93a80c0a9c0601f59d0"
 dependencies = [
  "ethers-core",
  "ethers-signers",
@@ -1225,7 +1226,7 @@ dependencies = [
 [[package]]
 name = "external-tracer"
 version = "0.1.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.5.12#554bdcf00334bab45670b8daa72d687a7ff2b919"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.5.13#a8c59b2e6e0a845c78d6b93a80c0a9c0601f59d0"
 dependencies = [
  "eth-types",
  "geth-utils",
@@ -1438,7 +1439,7 @@ dependencies = [
 [[package]]
 name = "gadgets"
 version = "0.1.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.5.12#554bdcf00334bab45670b8daa72d687a7ff2b919"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.5.13#a8c59b2e6e0a845c78d6b93a80c0a9c0601f59d0"
 dependencies = [
  "digest 0.7.6",
  "eth-types",
@@ -1478,7 +1479,7 @@ dependencies = [
 [[package]]
 name = "geth-utils"
 version = "0.1.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.5.12#554bdcf00334bab45670b8daa72d687a7ff2b919"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.5.13#a8c59b2e6e0a845c78d6b93a80c0a9c0601f59d0"
 dependencies = [
  "env_logger 0.9.3",
  "gobuild 0.1.0-alpha.2 (git+https://github.com/scroll-tech/gobuild.git)",
@@ -2076,7 +2077,7 @@ dependencies = [
 [[package]]
 name = "keccak256"
 version = "0.1.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.5.12#554bdcf00334bab45670b8daa72d687a7ff2b919"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.5.13#a8c59b2e6e0a845c78d6b93a80c0a9c0601f59d0"
 dependencies = [
  "env_logger 0.9.3",
  "eth-types",
@@ -2263,7 +2264,7 @@ dependencies = [
 [[package]]
 name = "mock"
 version = "0.1.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.5.12#554bdcf00334bab45670b8daa72d687a7ff2b919"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.5.13#a8c59b2e6e0a845c78d6b93a80c0a9c0601f59d0"
 dependencies = [
  "eth-types",
  "ethers-core",
@@ -2278,7 +2279,7 @@ dependencies = [
 [[package]]
 name = "mpt-zktrie"
 version = "0.1.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.5.12#554bdcf00334bab45670b8daa72d687a7ff2b919"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.5.13#a8c59b2e6e0a845c78d6b93a80c0a9c0601f59d0"
 dependencies = [
  "bus-mapping",
  "eth-types",
@@ -2754,7 +2755,7 @@ dependencies = [
 [[package]]
 name = "prover"
 version = "0.4.0"
-source = "git+https://github.com/scroll-tech/scroll-prover?tag=v0.5.12#ef945901bee26c4b79be8af60e259443392368fa"
+source = "git+https://github.com/scroll-tech/scroll-prover?tag=v0.5.13#0756ac68ee2f41c51f09a748cd28220290fe49ae"
 dependencies = [
  "aggregator",
  "anyhow",
@@ -4039,7 +4040,7 @@ checksum = "497961ef93d974e23eb6f433eb5fe1b7930b659f06d12dec6fc44a8f554c0bba"
 [[package]]
 name = "types"
 version = "0.4.0"
-source = "git+https://github.com/scroll-tech/scroll-prover?tag=v0.5.12#ef945901bee26c4b79be8af60e259443392368fa"
+source = "git+https://github.com/scroll-tech/scroll-prover?tag=v0.5.13#0756ac68ee2f41c51f09a748cd28220290fe49ae"
 dependencies = [
  "base64 0.13.1",
  "blake2",
@@ -4490,7 +4491,7 @@ checksum = "2a0956f1ba7c7909bfb66c2e9e4124ab6f6482560f6628b5aaeba39207c9aad9"
 [[package]]
 name = "zkevm-circuits"
 version = "0.1.0"
-source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.5.12#554bdcf00334bab45670b8daa72d687a7ff2b919"
+source = "git+https://github.com/scroll-tech/zkevm-circuits.git?tag=v0.5.13#a8c59b2e6e0a845c78d6b93a80c0a9c0601f59d0"
 dependencies = [
  "array-init",
  "bus-mapping",

common/libzkp/impl/Cargo.toml

@@ -20,8 +20,8 @@ maingate = { git = "https://github.com/scroll-tech/halo2wrong", branch = "halo2-
 halo2curves = { git = "https://github.com/scroll-tech/halo2curves.git", branch = "0.3.1-derive-serde" }
 
 [dependencies]
-prover = { git = "https://github.com/scroll-tech/scroll-prover", tag = "v0.5.12" }
-types = { git = "https://github.com/scroll-tech/scroll-prover", tag = "v0.5.12" }
+prover = { git = "https://github.com/scroll-tech/scroll-prover", tag = "v0.5.13" }
+types = { git = "https://github.com/scroll-tech/scroll-prover", tag = "v0.5.13" }
 halo2_proofs = { git = "https://github.com/scroll-tech/halo2.git", branch = "develop" }
 
 log = "0.4"

common/types/message/message.go

@@ -250,11 +250,12 @@ type ChunkInfo struct {
 
 // ChunkProof includes the proof info that are required for chunk verification and rollup.
 type ChunkProof struct {
-	StorageTrace []byte `json:"storage_trace"`
-	Protocol     []byte `json:"protocol"`
-	Proof        []byte `json:"proof"`
-	Instances    []byte `json:"instances"`
-	Vk           []byte `json:"vk"`
+	StorageTrace []byte     `json:"storage_trace"`
+	Protocol     []byte     `json:"protocol"`
+	Proof        []byte     `json:"proof"`
+	Instances    []byte     `json:"instances"`
+	Vk           []byte     `json:"vk"`
+	ChunkInfo    *ChunkInfo `json:"chunk_info,omitempty"` // cross-reference between cooridinator computation and prover compution
 }
 
 // BatchProof includes the proof info that are required for batch verification and rollup.

common/types/message/message_test.go

@@ -73,6 +73,7 @@ func TestProofMessageSignVerifyPublicKey(t *testing.T) {
 				Proof:        []byte("testProof"),
 				Instances:    []byte("testInstance"),
 				Vk:           []byte("testVk"),
+				ChunkInfo:    nil,
 			},
 			Error: "testError",
 		},
@@ -101,12 +102,13 @@ func TestProofDetailHash(t *testing.T) {
 			Proof:        []byte("testProof"),
 			Instances:    []byte("testInstance"),
 			Vk:           []byte("testVk"),
+			ChunkInfo:    nil,
 		},
 		Error: "testError",
 	}
 	hash, err := proofDetail.Hash()
 	assert.NoError(t, err)
-	expectedHash := "4165f5ab3399001002a5b8e4062914249a2deb72f6133d647b586f53e236802d"
+	expectedHash := "72a00232c1fcb100b1b67e6d12cd449e5d2d890e3a66e50f4c23499d4990766f"
 	assert.Equal(t, expectedHash, hex.EncodeToString(hash))
 }
 
@@ -136,6 +138,7 @@ func TestProofMsgPublicKey(t *testing.T) {
 				Proof:        []byte("testProof"),
 				Instances:    []byte("testInstance"),
 				Vk:           []byte("testVk"),
+				ChunkInfo:    nil,
 			},
 			Error: "testError",
 		},

common/version/version.go

@@ -6,7 +6,7 @@ import (
 	"strings"
 )
 
-var tag = "v4.1.31"
+var tag = "v4.1.36"
 
 var commit = func() string {
 	if info, ok := debug.ReadBuildInfo(); ok {

contracts/scripts/foundry/InitializeL1BridgeContracts.s.sol

@@ -23,7 +23,8 @@ contract InitializeL1BridgeContracts is Script {
     uint256 CHAIN_ID_L2 = vm.envUint("CHAIN_ID_L2");
     uint256 MAX_L2_TX_IN_CHUNK = vm.envUint("MAX_L2_TX_IN_CHUNK");
     uint256 MAX_L1_MESSAGE_GAS_LIMIT = vm.envUint("MAX_L1_MESSAGE_GAS_LIMIT");
-    address L1_ROLLUP_OPERATOR_ADDR = vm.envAddress("L1_ROLLUP_OPERATOR_ADDR");
+    address L1_COMMIT_SENDER_ADDRESS = vm.envAddress("L1_COMMIT_SENDER_ADDRESS");
+    address L1_FINALIZE_SENDER_ADDRESS = vm.envAddress("L1_FINALIZE_SENDER_ADDRESS");
     address L1_FEE_VAULT_ADDR = vm.envAddress("L1_FEE_VAULT_ADDR");
     address L1_WETH_ADDR = vm.envAddress("L1_WETH_ADDR");
 
@@ -67,8 +68,8 @@ contract InitializeL1BridgeContracts is Script {
             L1_MULTIPLE_VERSION_ROLLUP_VERIFIER_ADDR,
             MAX_L2_TX_IN_CHUNK
         );
-        ScrollChain(L1_SCROLL_CHAIN_PROXY_ADDR).addSequencer(L1_ROLLUP_OPERATOR_ADDR);
-        ScrollChain(L1_SCROLL_CHAIN_PROXY_ADDR).addProver(L1_ROLLUP_OPERATOR_ADDR);
+        ScrollChain(L1_SCROLL_CHAIN_PROXY_ADDR).addSequencer(L1_COMMIT_SENDER_ADDRESS);
+        ScrollChain(L1_SCROLL_CHAIN_PROXY_ADDR).addProver(L1_FINALIZE_SENDER_ADDRESS);
 
         // initialize L2GasPriceOracle
         L2GasPriceOracle(L2_GAS_PRICE_ORACLE_PROXY_ADDR).initialize(

coordinator/internal/controller/cron/collect_proof.go

@@ -66,50 +66,48 @@ func (c *Collector) timeoutProofTask() {
 	for {
 		select {
 		case <-ticker.C:
-			assignedProverTasks, err := c.proverTaskOrm.GetAssignedProverTasks(c.ctx, 10)
+			timeout := time.Duration(c.cfg.ProverManager.CollectionTimeSec) * time.Second
+			assignedProverTasks, err := c.proverTaskOrm.GetTimeoutAssignedProverTasks(c.ctx, 10, timeout)
 			if err != nil {
 				log.Error("get unassigned session info failure", "error", err)
 				break
 			}
 
+			// here not update the block batch proving status failed, because the collector loop will check
+			// the attempt times. if reach the times, the collector will set the block batch proving status.
 			for _, assignedProverTask := range assignedProverTasks {
-				timeoutDuration := time.Duration(c.cfg.ProverManager.CollectionTimeSec) * time.Second
-				// here not update the block batch proving status failed, because the collector loop will check
-				// the attempt times. if reach the times, the collector will set the block batch proving status.
-				if time.Since(assignedProverTask.AssignedAt) >= timeoutDuration {
-					log.Warn("proof task have reach the timeout", "task id", assignedProverTask.TaskID,
-						"prover public key", assignedProverTask.ProverPublicKey, "prover name", assignedProverTask.ProverName, "task type", assignedProverTask.TaskType)
-					err = c.db.Transaction(func(tx *gorm.DB) error {
-						// update prover task proving status as ProverProofInvalid
-						if err = c.proverTaskOrm.UpdateProverTaskProvingStatus(c.ctx, message.ProofType(assignedProverTask.TaskType),
-							assignedProverTask.TaskID, assignedProverTask.ProverPublicKey, types.ProverProofInvalid, tx); err != nil {
-							log.Error("update prover task proving status failure", "hash", assignedProverTask.TaskID, "pubKey", assignedProverTask.ProverPublicKey, "err", err)
-							return err
-						}
-
-						// update prover task failure type
-						if err = c.proverTaskOrm.UpdateProverTaskFailureType(c.ctx, message.ProofType(assignedProverTask.TaskType),
-							assignedProverTask.TaskID, assignedProverTask.ProverPublicKey, types.ProverTaskFailureTypeTimeout, tx); err != nil {
-							log.Error("update prover task failure type failure", "hash", assignedProverTask.TaskID, "pubKey", assignedProverTask.ProverPublicKey, "err", err)
-							return err
-						}
-
-						// update the task to unassigned, let collector restart it
-						if message.ProofType(assignedProverTask.TaskType) == message.ProofTypeChunk {
-							if err = c.chunkOrm.UpdateProvingStatus(c.ctx, assignedProverTask.TaskID, types.ProvingTaskUnassigned, tx); err != nil {
-								log.Error("update chunk proving status to unassigned to restart it failure", "hash", assignedProverTask.TaskID, "err", err)
-							}
-						}
-						if message.ProofType(assignedProverTask.TaskType) == message.ProofTypeBatch {
-							if err = c.batchOrm.UpdateProvingStatus(c.ctx, assignedProverTask.TaskID, types.ProvingTaskUnassigned, tx); err != nil {
-								log.Error("update batch proving status to unassigned to restart it failure", "hash", assignedProverTask.TaskID, "err", err)
-							}
-						}
-						return nil
-					})
-					if err != nil {
-						log.Error("check task proof is timeout failure", "error", err)
+				log.Warn("proof task have reach the timeout", "task id", assignedProverTask.TaskID,
+					"prover public key", assignedProverTask.ProverPublicKey, "prover name", assignedProverTask.ProverName, "task type", assignedProverTask.TaskType)
+				err = c.db.Transaction(func(tx *gorm.DB) error {
+					// update prover task proving status as ProverProofInvalid
+					if err = c.proverTaskOrm.UpdateProverTaskProvingStatus(c.ctx, message.ProofType(assignedProverTask.TaskType),
+						assignedProverTask.TaskID, assignedProverTask.ProverPublicKey, types.ProverProofInvalid, tx); err != nil {
+						log.Error("update prover task proving status failure", "hash", assignedProverTask.TaskID, "pubKey", assignedProverTask.ProverPublicKey, "err", err)
+						return err
 					}
+
+					// update prover task failure type
+					if err = c.proverTaskOrm.UpdateProverTaskFailureType(c.ctx, message.ProofType(assignedProverTask.TaskType),
+						assignedProverTask.TaskID, assignedProverTask.ProverPublicKey, types.ProverTaskFailureTypeTimeout, tx); err != nil {
+						log.Error("update prover task failure type failure", "hash", assignedProverTask.TaskID, "pubKey", assignedProverTask.ProverPublicKey, "err", err)
+						return err
+					}
+
+					// update the task to unassigned, let collector restart it
+					if message.ProofType(assignedProverTask.TaskType) == message.ProofTypeChunk {
+						if err = c.chunkOrm.UpdateProvingStatus(c.ctx, assignedProverTask.TaskID, types.ProvingTaskUnassigned, tx); err != nil {
+							log.Error("update chunk proving status to unassigned to restart it failure", "hash", assignedProverTask.TaskID, "err", err)
+						}
+					}
+					if message.ProofType(assignedProverTask.TaskType) == message.ProofTypeBatch {
+						if err = c.batchOrm.UpdateProvingStatus(c.ctx, assignedProverTask.TaskID, types.ProvingTaskUnassigned, tx); err != nil {
+							log.Error("update batch proving status to unassigned to restart it failure", "hash", assignedProverTask.TaskID, "err", err)
+						}
+					}
+					return nil
+				})
+				if err != nil {
+					log.Error("check task proof is timeout failure", "error", err)
 				}
 			}
 		case <-c.ctx.Done():

coordinator/internal/logic/provertask/batch_prover_task.go

@@ -59,6 +59,15 @@ func (bp *BatchProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinato
 		return nil, fmt.Errorf("incompatible prover version. please upgrade your prover, expect version: %s, actual version: %s", proverVersion.(string), version.Version)
 	}
 
+	isAssigned, err := bp.proverTaskOrm.IsProverAssigned(ctx, publicKey.(string))
+	if err != nil {
+		return nil, fmt.Errorf("failed to check if prover is assigned a task: %w", err)
+	}
+
+	if isAssigned {
+		return nil, fmt.Errorf("prover with publicKey %s is already assigned a task", publicKey)
+	}
+
 	batchTasks, err := bp.batchOrm.UpdateUnassignedBatchReturning(ctx, 1)
 	if err != nil {
 		return nil, fmt.Errorf("failed to get unassigned batch proving tasks, error:%w", err)

coordinator/internal/logic/provertask/chunk_prover_task.go

@@ -59,6 +59,15 @@ func (cp *ChunkProverTask) Assign(ctx *gin.Context, getTaskParameter *coordinato
 		return nil, fmt.Errorf("incompatible prover version. please upgrade your prover, expect version: %s, actual version: %s", version.Version, proverVersion.(string))
 	}
 
+	isAssigned, err := cp.proverTaskOrm.IsProverAssigned(ctx, publicKey.(string))
+	if err != nil {
+		return nil, fmt.Errorf("failed to check if prover is assigned a task: %w", err)
+	}
+
+	if isAssigned {
+		return nil, fmt.Errorf("prover with publicKey %s is already assigned a task", publicKey)
+	}
+
 	// load and send chunk tasks
 	chunkTasks, err := cp.chunkOrm.UpdateUnassignedChunkReturning(ctx, getTaskParameter.ProverHeight, 1)
 	if err != nil {

coordinator/internal/orm/prover_task.go

@@ -11,6 +11,7 @@ import (
 
 	"scroll-tech/common/types"
 	"scroll-tech/common/types/message"
+	"scroll-tech/common/utils"
 )
 
 // ProverTask is assigned provers info of chunk/batch proof prover task
@@ -51,6 +52,20 @@ func (*ProverTask) TableName() string {
 	return "prover_task"
 }
 
+// IsProverAssigned checks if a prover with the given public key has been assigned a task.
+func (o *ProverTask) IsProverAssigned(ctx context.Context, publicKey string) (bool, error) {
+	db := o.db.WithContext(ctx)
+	var task ProverTask
+	err := db.Where("prover_public_key = ? AND proving_status = ?", publicKey, types.ProverAssigned).First(&task).Error
+	if err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return false, nil
+		}
+		return false, err
+	}
+	return true, nil
+}
+
 // GetProverTasks get prover tasks
 func (o *ProverTask) GetProverTasks(ctx context.Context, fields map[string]interface{}, orderByList []string, offset, limit int) ([]ProverTask, error) {
 	db := o.db.WithContext(ctx)
@@ -126,11 +141,12 @@ func (o *ProverTask) GetProvingStatusByTaskID(ctx context.Context, taskID string
 	return types.ProverProveStatus(proverTask.ProvingStatus), nil
 }
 
-// GetAssignedProverTasks get the assigned prover task
-func (o *ProverTask) GetAssignedProverTasks(ctx context.Context, limit int) ([]ProverTask, error) {
+// GetTimeoutAssignedProverTasks get the timeout and assigned proving_status prover task
+func (o *ProverTask) GetTimeoutAssignedProverTasks(ctx context.Context, limit int, timeout time.Duration) ([]ProverTask, error) {
 	db := o.db.WithContext(ctx)
 	db = db.Model(&ProverTask{})
 	db = db.Where("proving_status", int(types.ProverAssigned))
+	db = db.Where("assigned_at < ?", utils.NowUTC().Add(-timeout))
 	db = db.Limit(limit)
 
 	var proverTasks []ProverTask

prover/client/client.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"crypto/ecdsa"
 	"fmt"
+	"net/http"
 	"sync"
 	"time"
 
@@ -33,7 +34,18 @@ func NewCoordinatorClient(cfg *config.CoordinatorConfig, proverName string, priv
 		SetTimeout(time.Duration(cfg.ConnectionTimeoutSec) * time.Second).
 		SetRetryCount(cfg.RetryCount).
 		SetRetryWaitTime(time.Duration(cfg.RetryWaitTimeSec) * time.Second).
-		SetBaseURL(cfg.BaseURL)
+		SetBaseURL(cfg.BaseURL).
+		AddRetryCondition(func(r *resty.Response, _ error) bool {
+			// Check for HTTP 5xx errors, e.g., coordinator is restarting.
+			log.Warn("Received unexpected HTTP response. Retrying...", "status code", r.StatusCode())
+			return r.StatusCode() >= http.StatusInternalServerError
+		})
+
+	log.Info("successfully initialized prover client",
+		"base url", cfg.BaseURL,
+		"connection timeout (second)", cfg.ConnectionTimeoutSec,
+		"retry count", cfg.RetryCount,
+		"retry wait time (second)", cfg.RetryWaitTimeSec)
 
 	return &CoordinatorClient{
 		client:     client,

tests/integration-test/contracts_test.go

@@ -26,7 +26,7 @@ func TestERC20(t *testing.T) {
 	token, err := erc20.NewERC20Mock(erc20Address, l2Cli)
 	assert.NoError(t, err)
 
-	auth, err := bind.NewKeyedTransactorWithChainID(bridgeApp.Config.L2Config.RelayerConfig.MessageSenderPrivateKeys[0], base.L2gethImg.ChainID())
+	auth, err := bind.NewKeyedTransactorWithChainID(bridgeApp.Config.L2Config.RelayerConfig.MessageSenderPrivateKey, base.L2gethImg.ChainID())
 	assert.NoError(t, err)
 
 	authBls0, err := token.BalanceOf(nil, auth.From)
@@ -57,7 +57,7 @@ func TestGreeter(t *testing.T) {
 	l2Cli, err := base.L2Client()
 	assert.Nil(t, err)
 
-	auth, err := bind.NewKeyedTransactorWithChainID(bridgeApp.Config.L2Config.RelayerConfig.MessageSenderPrivateKeys[0], base.L2gethImg.ChainID())
+	auth, err := bind.NewKeyedTransactorWithChainID(bridgeApp.Config.L2Config.RelayerConfig.MessageSenderPrivateKey, base.L2gethImg.ChainID())
 	assert.NoError(t, err)
 
 	token, err := greeter.NewGreeter(greeterAddress, l2Cli)