feat(rollup-relayer & gas-oracle): graceful restart (#1076)

Co-authored-by: colinlyguo <colinlyguo@users.noreply.github.com>
Co-authored-by: zzq0826 <770166635@qq.com>
Co-authored-by: HAOYUatHZ <37070449+HAOYUatHZ@users.noreply.github.com>

.github/workflows/docker.yml

@@ -5,6 +5,9 @@ on:
     tags:
       - v**
 
+env:
+  AWS_REGION: us-west-2
+
 jobs:
   event_watcher:
     runs-on: ubuntu-latest
@@ -29,6 +32,29 @@ jobs:
             scrolltech/event-watcher:latest
           # cache-from: type=gha,scope=${{ github.workflow }}
           # cache-to: type=gha,scope=${{ github.workflow }}
+
+      # build and push to aws ecr
+      - name: Configure AWS credentials
+        uses: aws-actions/configure-aws-credentials@0e613a0980cbf65ed5b322eb7a1e075d28913a83
+        with:
+          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
+          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+          aws-region: ${{ env.AWS_REGION }}
+      - name: Login to Amazon ECR
+        id: login-ecr
+        uses: aws-actions/amazon-ecr-login@62f4f872db3836360b72999f4b87f1ff13310f3a
+      - name: Build, tag, and push image to Amazon ECR
+        id: build-image
+        env:
+          ECR_REGISTRY: ${{ steps.login-ecr.outputs.registry }}
+          ECR_REPOSITORY: event-watcher
+          IMAGE_TAG: ${{github.ref_name}}
+        run: |
+          # Build a docker container and push it to ECR
+          # docker build -t $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG .
+          docker tag scrolltech/$ECR_REPOSITORY:$IMAGE_TAG $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG
+          docker push $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG
+
   gas_oracle:
     runs-on: ubuntu-latest
     steps:
@@ -52,6 +78,30 @@ jobs:
             scrolltech/gas-oracle:latest
           # cache-from: type=gha,scope=${{ github.workflow }}
           # cache-to: type=gha,scope=${{ github.workflow }}
+
+      # build and push to aws ecr
+      - name: Configure AWS credentials
+        uses: aws-actions/configure-aws-credentials@0e613a0980cbf65ed5b322eb7a1e075d28913a83
+        with:
+          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
+          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+          aws-region: ${{ env.AWS_REGION }}
+      - name: Login to Amazon ECR
+        id: login-ecr
+        uses: aws-actions/amazon-ecr-login@62f4f872db3836360b72999f4b87f1ff13310f3a
+
+      - name: Build, tag, and push image to Amazon ECR
+        id: build-image
+        env:
+          ECR_REGISTRY: ${{ steps.login-ecr.outputs.registry }}
+          ECR_REPOSITORY: gas-oracle
+          IMAGE_TAG: ${{github.ref_name}}
+        run: |
+          # Build a docker container and push it to ECR
+          # docker build -t $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG .
+          docker tag scrolltech/$ECR_REPOSITORY:$IMAGE_TAG $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG
+          docker push $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG
+
   rollup_relayer:
     runs-on: ubuntu-latest
     steps:
@@ -75,52 +125,124 @@ jobs:
             scrolltech/rollup-relayer:latest
           # cache-from: type=gha,scope=${{ github.workflow }}
           # cache-to: type=gha,scope=${{ github.workflow }}
+
+      # build and push to aws ecr
+      - name: Configure AWS credentials
+        uses: aws-actions/configure-aws-credentials@0e613a0980cbf65ed5b322eb7a1e075d28913a83
+        with:
+          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
+          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+          aws-region: ${{ env.AWS_REGION }}
+      - name: Login to Amazon ECR
+        id: login-ecr
+        uses: aws-actions/amazon-ecr-login@62f4f872db3836360b72999f4b87f1ff13310f3a
+
+      - name: Build, tag, and push image to Amazon ECR
+        id: build-image
+        env:
+          ECR_REGISTRY: ${{ steps.login-ecr.outputs.registry }}
+          ECR_REPOSITORY: rollup-relayer
+          IMAGE_TAG: ${{github.ref_name}}
+        run: |
+          # Build a docker container and push it to ECR
+          # docker build -t $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG .
+          docker tag scrolltech/$ECR_REPOSITORY:$IMAGE_TAG $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG
+          docker push $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG
+
   bridgehistoryapi-fetcher:
     runs-on: ubuntu-latest
     steps:
-    - name: Checkout code
-      uses: actions/checkout@v2
-    - name: Set up Docker Buildx
-      uses: docker/setup-buildx-action@v2
-    - name: Login to Docker Hub
-      uses: docker/login-action@v2
-      with:
-        username: ${{ secrets.DOCKERHUB_USERNAME }}
-        password: ${{ secrets.DOCKERHUB_TOKEN }}
-    - name: Build and push bridgehistoryapi-fetcher docker
-      uses: docker/build-push-action@v2
-      with:
-        context: .
-        file: ./build/dockerfiles/bridgehistoryapi-fetcher.Dockerfile
-        push: true
-        tags: |
-          scrolltech/bridgehistoryapi-fetcher:${{github.ref_name}}
-          scrolltech/bridgehistoryapi-fetcher:latest
-        # cache-from: type=gha,scope=${{ github.workflow }}
-        # cache-to: type=gha,scope=${{ github.workflow }}
+      - name: Checkout code
+        uses: actions/checkout@v2
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2
+      - name: Login to Docker Hub
+        uses: docker/login-action@v2
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+      - name: Build and push bridgehistoryapi-fetcher docker
+        uses: docker/build-push-action@v2
+        with:
+          context: .
+          file: ./build/dockerfiles/bridgehistoryapi-fetcher.Dockerfile
+          push: true
+          tags: |
+            scrolltech/bridgehistoryapi-fetcher:${{github.ref_name}}
+            scrolltech/bridgehistoryapi-fetcher:latest
+          # cache-from: type=gha,scope=${{ github.workflow }}
+          # cache-to: type=gha,scope=${{ github.workflow }}
+
+      # build and push to aws ecr
+      - name: Configure AWS credentials
+        uses: aws-actions/configure-aws-credentials@0e613a0980cbf65ed5b322eb7a1e075d28913a83
+        with:
+          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
+          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+          aws-region: ${{ env.AWS_REGION }}
+      - name: Login to Amazon ECR
+        id: login-ecr
+        uses: aws-actions/amazon-ecr-login@62f4f872db3836360b72999f4b87f1ff13310f3a
+
+      - name: Build, tag, and push image to Amazon ECR
+        id: build-image
+        env:
+          ECR_REGISTRY: ${{ steps.login-ecr.outputs.registry }}
+          ECR_REPOSITORY: bridgehistoryapi-fetcher
+          IMAGE_TAG: ${{github.ref_name}}
+        run: |
+          # Build a docker container and push it to ECR
+          # docker build -t $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG .
+          docker tag scrolltech/$ECR_REPOSITORY:$IMAGE_TAG $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG
+          docker push $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG
+
   bridgehistoryapi-api:
     runs-on: ubuntu-latest
     steps:
-    - name: Checkout code
-      uses: actions/checkout@v2
-    - name: Set up Docker Buildx
-      uses: docker/setup-buildx-action@v2
-    - name: Login to Docker Hub
-      uses: docker/login-action@v2
-      with:
-        username: ${{ secrets.DOCKERHUB_USERNAME }}
-        password: ${{ secrets.DOCKERHUB_TOKEN }}
-    - name: Build and push bridgehistoryapi-api docker
-      uses: docker/build-push-action@v2
-      with:
-        context: .
-        file: ./build/dockerfiles/bridgehistoryapi-api.Dockerfile
-        push: true
-        tags: |
-          scrolltech/bridgehistoryapi-api:${{github.ref_name}}
-          scrolltech/bridgehistoryapi-api:latest
-        # cache-from: type=gha,scope=${{ github.workflow }}
-        # cache-to: type=gha,scope=${{ github.workflow }}
+      - name: Checkout code
+        uses: actions/checkout@v2
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2
+      - name: Login to Docker Hub
+        uses: docker/login-action@v2
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+      - name: Build and push bridgehistoryapi-api docker
+        uses: docker/build-push-action@v2
+        with:
+          context: .
+          file: ./build/dockerfiles/bridgehistoryapi-api.Dockerfile
+          push: true
+          tags: |
+            scrolltech/bridgehistoryapi-api:${{github.ref_name}}
+            scrolltech/bridgehistoryapi-api:latest
+          # cache-from: type=gha,scope=${{ github.workflow }}
+          # cache-to: type=gha,scope=${{ github.workflow }}
+
+      # build and push to aws ecr
+      - name: Configure AWS credentials
+        uses: aws-actions/configure-aws-credentials@0e613a0980cbf65ed5b322eb7a1e075d28913a83
+        with:
+          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
+          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+          aws-region: ${{ env.AWS_REGION }}
+      - name: Login to Amazon ECR
+        id: login-ecr
+        uses: aws-actions/amazon-ecr-login@62f4f872db3836360b72999f4b87f1ff13310f3a
+
+      - name: Build, tag, and push image to Amazon ECR
+        id: build-image
+        env:
+          ECR_REGISTRY: ${{ steps.login-ecr.outputs.registry }}
+          ECR_REPOSITORY: bridgehistoryapi-api
+          IMAGE_TAG: ${{github.ref_name}}
+        run: |
+          # Build a docker container and push it to ECR
+          # docker build -t $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG .
+          docker tag scrolltech/$ECR_REPOSITORY:$IMAGE_TAG $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG
+          docker push $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG
+
   coordinator-api:
     runs-on: ubuntu-latest
     steps:
@@ -144,6 +266,30 @@ jobs:
             scrolltech/coordinator-api:latest
           # cache-from: type=gha,scope=${{ github.workflow }}
           # cache-to: type=gha,scope=${{ github.workflow }}
+
+      # build and push to aws ecr
+      - name: Configure AWS credentials
+        uses: aws-actions/configure-aws-credentials@0e613a0980cbf65ed5b322eb7a1e075d28913a83
+        with:
+          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
+          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+          aws-region: ${{ env.AWS_REGION }}
+      - name: Login to Amazon ECR
+        id: login-ecr
+        uses: aws-actions/amazon-ecr-login@62f4f872db3836360b72999f4b87f1ff13310f3a
+
+      - name: Build, tag, and push image to Amazon ECR
+        id: build-image
+        env:
+          ECR_REGISTRY: ${{ steps.login-ecr.outputs.registry }}
+          ECR_REPOSITORY: coordinator-api
+          IMAGE_TAG: ${{github.ref_name}}
+        run: |
+          # Build a docker container and push it to ECR
+          # docker build -t $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG .
+          docker tag scrolltech/$ECR_REPOSITORY:$IMAGE_TAG $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG
+          docker push $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG
+
   coordinator-cron:
     runs-on: ubuntu-latest
     steps:
@@ -167,3 +313,26 @@ jobs:
             scrolltech/coordinator-cron:latest
           # cache-from: type=gha,scope=${{ github.workflow }}
           # cache-to: type=gha,scope=${{ github.workflow }}
+
+      # build and push to aws ecr
+      - name: Configure AWS credentials
+        uses: aws-actions/configure-aws-credentials@0e613a0980cbf65ed5b322eb7a1e075d28913a83
+        with:
+          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
+          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+          aws-region: ${{ env.AWS_REGION }}
+      - name: Login to Amazon ECR
+        id: login-ecr
+        uses: aws-actions/amazon-ecr-login@62f4f872db3836360b72999f4b87f1ff13310f3a
+
+      - name: Build, tag, and push image to Amazon ECR
+        id: build-image
+        env:
+          ECR_REGISTRY: ${{ steps.login-ecr.outputs.registry }}
+          ECR_REPOSITORY: coordinator-cron
+          IMAGE_TAG: ${{github.ref_name}}
+        run: |
+          # Build a docker container and push it to ECR
+          # docker build -t $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG .
+          docker tag scrolltech/$ECR_REPOSITORY:$IMAGE_TAG $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG
+          docker push $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2022-2023 Scroll
+Copyright (c) 2022-2024 Scroll
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

common/types/db.go

@@ -21,8 +21,8 @@ const (
 	// GasOracleImported represents the gas oracle status is imported
 	GasOracleImported
 
-	// GasOracleFailed represents the gas oracle status is failed
-	GasOracleFailed
+	// GasOracleImportedFailed represents the gas oracle status is imported failed
+	GasOracleImportedFailed
 )
 
 func (s GasOracleStatus) String() string {
@@ -35,10 +35,10 @@ func (s GasOracleStatus) String() string {
 		return "GasOracleImporting"
 	case GasOracleImported:
 		return "GasOracleImported"
-	case GasOracleFailed:
-		return "GasOracleFailed"
+	case GasOracleImportedFailed:
+		return "GasOracleImportedFailed"
 	default:
-		return fmt.Sprintf("Undefined (%d)", int32(s))
+		return fmt.Sprintf("Undefined GasOracleStatus (%d)", int32(s))
 	}
 }
 
@@ -159,7 +159,7 @@ func (ps ProvingStatus) String() string {
 	case ProvingTaskFailed:
 		return "failed"
 	default:
-		return fmt.Sprintf("Undefined (%d)", int32(ps))
+		return fmt.Sprintf("Undefined ProvingStatus (%d)", int32(ps))
 	}
 }
 
@@ -184,7 +184,7 @@ func (s ChunkProofsStatus) String() string {
 	case ChunkProofsStatusReady:
 		return "ChunkProofsStatusReady"
 	default:
-		return fmt.Sprintf("Undefined (%d)", int32(s))
+		return fmt.Sprintf("Undefined ChunkProofsStatus (%d)", int32(s))
 	}
 }
 
@@ -227,6 +227,69 @@ func (s RollupStatus) String() string {
 	case RollupFinalizeFailed:
 		return "RollupFinalizeFailed"
 	default:
-		return fmt.Sprintf("Undefined (%d)", int32(s))
+		return fmt.Sprintf("Undefined RollupStatus (%d)", int32(s))
+	}
+}
+
+// SenderType defines the various types of senders sending the transactions.
+type SenderType int
+
+const (
+	// SenderTypeUnknown indicates an unknown sender type.
+	SenderTypeUnknown SenderType = iota
+	// SenderTypeCommitBatch indicates the sender is responsible for committing batches.
+	SenderTypeCommitBatch
+	// SenderTypeFinalizeBatch indicates the sender is responsible for finalizing batches.
+	SenderTypeFinalizeBatch
+	// SenderTypeL1GasOracle indicates a sender from L2 responsible for updating L1 gas prices.
+	SenderTypeL1GasOracle
+	// SenderTypeL2GasOracle indicates a sender from L1 responsible for updating L2 gas prices.
+	SenderTypeL2GasOracle
+)
+
+// String returns a string representation of the SenderType.
+func (t SenderType) String() string {
+	switch t {
+	case SenderTypeCommitBatch:
+		return "SenderTypeCommitBatch"
+	case SenderTypeFinalizeBatch:
+		return "SenderTypeFinalizeBatch"
+	case SenderTypeL1GasOracle:
+		return "SenderTypeL1GasOracle"
+	case SenderTypeL2GasOracle:
+		return "SenderTypeL2GasOracle"
+	default:
+		return fmt.Sprintf("Unknown SenderType (%d)", int32(t))
+	}
+}
+
+// TxStatus represents the current status of a transaction in the transaction lifecycle.
+type TxStatus int
+
+const (
+	// TxStatusUnknown represents an undefined status of the transaction.
+	TxStatusUnknown TxStatus = iota
+	// TxStatusPending indicates that the transaction is yet to be processed.
+	TxStatusPending
+	// TxStatusReplaced indicates that the transaction has been replaced by another one, typically due to a higher gas price.
+	TxStatusReplaced
+	// TxStatusConfirmed indicates that the transaction has been successfully processed and confirmed.
+	TxStatusConfirmed
+	// TxStatusConfirmedFailed indicates that the transaction has failed during processing.
+	TxStatusConfirmedFailed
+)
+
+func (s TxStatus) String() string {
+	switch s {
+	case TxStatusPending:
+		return "TxStatusPending"
+	case TxStatusReplaced:
+		return "TxStatusReplaced"
+	case TxStatusConfirmed:
+		return "TxStatusConfirmed"
+	case TxStatusConfirmedFailed:
+		return "TxStatusConfirmedFailed"
+	default:
+		return fmt.Sprintf("Unknown TxStatus (%d)", int32(s))
 	}
 }

common/types/db_test.go

@@ -75,7 +75,7 @@ func TestProvingStatus(t *testing.T) {
 		{
 			"Undefined",
 			ProvingStatus(999), // Invalid value.
-			"Undefined (999)",
+			"Undefined ProvingStatus (999)",
 		},
 	}
 
@@ -85,3 +85,243 @@ func TestProvingStatus(t *testing.T) {
 		})
 	}
 }
+
+func TestRollupStatus(t *testing.T) {
+	tests := []struct {
+		name string
+		s    RollupStatus
+		want string
+	}{
+		{
+			"RollupUndefined",
+			RollupUndefined,
+			"Undefined RollupStatus (0)",
+		},
+		{
+			"RollupPending",
+			RollupPending,
+			"RollupPending",
+		},
+		{
+			"RollupCommitting",
+			RollupCommitting,
+			"RollupCommitting",
+		},
+		{
+			"RollupCommitted",
+			RollupCommitted,
+			"RollupCommitted",
+		},
+		{
+			"RollupFinalizing",
+			RollupFinalizing,
+			"RollupFinalizing",
+		},
+		{
+			"RollupFinalized",
+			RollupFinalized,
+			"RollupFinalized",
+		},
+		{
+			"RollupCommitFailed",
+			RollupCommitFailed,
+			"RollupCommitFailed",
+		},
+		{
+			"RollupFinalizeFailed",
+			RollupFinalizeFailed,
+			"RollupFinalizeFailed",
+		},
+		{
+			"Invalid Value",
+			RollupStatus(999),
+			"Undefined RollupStatus (999)",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			assert.Equal(t, tt.want, tt.s.String())
+		})
+	}
+}
+
+func TestSenderType(t *testing.T) {
+	tests := []struct {
+		name string
+		t    SenderType
+		want string
+	}{
+		{
+			"SenderTypeUnknown",
+			SenderTypeUnknown,
+			"Unknown SenderType (0)",
+		},
+		{
+			"SenderTypeCommitBatch",
+			SenderTypeCommitBatch,
+			"SenderTypeCommitBatch",
+		},
+		{
+			"SenderTypeFinalizeBatch",
+			SenderTypeFinalizeBatch,
+			"SenderTypeFinalizeBatch",
+		},
+		{
+			"SenderTypeL1GasOracle",
+			SenderTypeL1GasOracle,
+			"SenderTypeL1GasOracle",
+		},
+		{
+			"SenderTypeL2GasOracle",
+			SenderTypeL2GasOracle,
+			"SenderTypeL2GasOracle",
+		},
+		{
+			"Invalid Value",
+			SenderType(999),
+			"Unknown SenderType (999)",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			assert.Equal(t, tt.want, tt.t.String())
+		})
+	}
+}
+
+func TestTxStatus(t *testing.T) {
+	tests := []struct {
+		name string
+		s    TxStatus
+		want string
+	}{
+		{
+			"TxStatusUnknown",
+			TxStatusUnknown,
+			"Unknown TxStatus (0)",
+		},
+		{
+			"TxStatusPending",
+			TxStatusPending,
+			"TxStatusPending",
+		},
+		{
+			"TxStatusReplaced",
+			TxStatusReplaced,
+			"TxStatusReplaced",
+		},
+		{
+			"TxStatusConfirmed",
+			TxStatusConfirmed,
+			"TxStatusConfirmed",
+		},
+		{
+			"TxStatusConfirmedFailed",
+			TxStatusConfirmedFailed,
+			"TxStatusConfirmedFailed",
+		},
+		{
+			"Invalid Value",
+			TxStatus(999),
+			"Unknown TxStatus (999)",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			assert.Equal(t, tt.want, tt.s.String())
+		})
+	}
+}
+
+func TestGasOracleStatus(t *testing.T) {
+	tests := []struct {
+		name string
+		s    GasOracleStatus
+		want string
+	}{
+		{
+			"GasOracleUndefined",
+			GasOracleUndefined,
+			"GasOracleUndefined",
+		},
+		{
+			"GasOraclePending",
+			GasOraclePending,
+			"GasOraclePending",
+		},
+		{
+			"GasOracleImporting",
+			GasOracleImporting,
+			"GasOracleImporting",
+		},
+		{
+			"GasOracleImported",
+			GasOracleImported,
+			"GasOracleImported",
+		},
+		{
+			"GasOracleImportedFailed",
+			GasOracleImportedFailed,
+			"GasOracleImportedFailed",
+		},
+		{
+			"Invalid Value",
+			GasOracleStatus(999),
+			"Undefined GasOracleStatus (999)",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			assert.Equal(t, tt.want, tt.s.String())
+		})
+	}
+}
+
+func TestProverTaskFailureType(t *testing.T) {
+	tests := []struct {
+		name string
+		r    ProverTaskFailureType
+		want string
+	}{
+		{
+			"ProverTaskFailureTypeUndefined",
+			ProverTaskFailureTypeUndefined,
+			"prover task failure undefined",
+		},
+		{
+			"ProverTaskFailureTypeTimeout",
+			ProverTaskFailureTypeTimeout,
+			"prover task failure timeout",
+		},
+		{
+			"ProverTaskFailureTypeSubmitStatusNotOk",
+			ProverTaskFailureTypeSubmitStatusNotOk,
+			"prover task failure validated submit proof status not ok",
+		},
+		{
+			"ProverTaskFailureTypeVerifiedFailed",
+			ProverTaskFailureTypeVerifiedFailed,
+			"prover task failure verified failed",
+		},
+		{
+			"ProverTaskFailureTypeServerError",
+			ProverTaskFailureTypeServerError,
+			"prover task failure server exception",
+		},
+		{
+			"Invalid Value",
+			ProverTaskFailureType(999),
+			"illegal prover task failure type (999)",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			assert.Equal(t, tt.want, tt.r.String())
+		})
+	}
+}

common/version/version.go

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

database/migrate/migrate_test.go

@@ -63,7 +63,7 @@ func testResetDB(t *testing.T) {
 	cur, err := Current(pgDB.DB)
 	assert.NoError(t, err)
 	// total number of tables.
-	assert.Equal(t, 14, int(cur))
+	assert.Equal(t, 15, int(cur))
 }
 
 func testMigrate(t *testing.T) {

database/migrate/migrations/00015_pending_transaction.sql

@@ -0,0 +1,46 @@
+-- +goose Up
+-- +goose StatementBegin
+
+CREATE TABLE pending_transaction
+(
+    id                  SERIAL       PRIMARY KEY,
+
+-- context info
+    context_id          VARCHAR      NOT NULL, -- batch hash in commit/finalize tx, block hash in update gas oracle tx
+    hash                VARCHAR      NOT NULL,
+    status              SMALLINT     NOT NULL,
+    rlp_encoding        BYTEA        NOT NULL,
+
+-- debug info
+    chain_id            BIGINT       NOT NULL,
+    type                SMALLINT     NOT NULL,
+    gas_tip_cap         BIGINT       NOT NULL,
+    gas_fee_cap         BIGINT       NOT NULL, -- based on geth's implementation, it's gas price in legacy tx.
+    gas_limit           BIGINT       NOT NULL,
+    nonce               BIGINT       NOT NULL,
+    submit_block_number BIGINT       NOT NULL,
+
+-- sender info
+    sender_name         VARCHAR      NOT NULL,
+    sender_service      VARCHAR      NOT NULL,
+    sender_address      VARCHAR      NOT NULL,
+    sender_type         SMALLINT     NOT NULL,
+
+    created_at          TIMESTAMP(0) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at          TIMESTAMP(0) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    deleted_at          TIMESTAMP(0) DEFAULT NULL
+);
+
+CREATE UNIQUE INDEX unique_idx_pending_transaction_on_hash ON pending_transaction(hash);
+CREATE INDEX idx_pending_transaction_on_sender_type_status_nonce_gas_fee_cap ON pending_transaction (sender_type, status, nonce, gas_fee_cap);
+CREATE INDEX idx_pending_transaction_on_sender_address_nonce ON pending_transaction(sender_address, nonce);
+
+COMMENT ON COLUMN pending_transaction.sender_type IS 'unknown, commit batch, finalize batch, L1 gas oracle, L2 gas oracle';
+COMMENT ON COLUMN pending_transaction.status IS 'unknown, pending, replaced, confirmed, confirmed failed';
+
+-- +goose StatementEnd
+
+-- +goose Down
+-- +goose StatementBegin
+DROP TABLE IF EXISTS pending_transaction;
+-- +goose StatementEnd

go.work.sum

@@ -488,13 +488,7 @@ github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5y
 github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
 github.com/golang/protobuf v1.3.4/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
-github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
-github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
-github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
-github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
-github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
 github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8=
-github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
 github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
 github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
 github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
@@ -564,7 +558,6 @@ github.com/hashicorp/go-retryablehttp v0.7.4 h1:ZQgVdpTdAL7WpMIwLzCfbalOcSUdkDZn
 github.com/hashicorp/go-retryablehttp v0.7.4/go.mod h1:Jy/gPYAdjqffZ/yFGCFV2doI5wjtH1ewM9u8iYVjtX8=
 github.com/hashicorp/go-uuid v1.0.2/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
 github.com/hashicorp/go-version v1.2.0 h1:3vNe/fWF5CBgRIguda1meWhsZHy3m8gCJ5wx+dIzX/E=
-github.com/hashicorp/golang-lru v0.5.5-0.20210104140557-80c98217689d/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4=
 github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4=
 github.com/holiman/big v0.0.0-20221017200358-a027dc42d04e h1:pIYdhNkDh+YENVNi3gto8n9hAmRxKxoar0iE6BLucjw=
 github.com/holiman/big v0.0.0-20221017200358-a027dc42d04e/go.mod h1:j9cQbcqHQujT0oKJ38PylVfqohClLr3CvDC+Qcg+lhU=
@@ -857,6 +850,7 @@ github.com/onsi/ginkgo/v2 v2.8.1 h1:xFTEVwOFa1D/Ty24Ws1npBWkDYEV9BqZrsDxVrVkrrU=
 github.com/onsi/ginkgo/v2 v2.8.1/go.mod h1:N1/NbDngAFcSLdyZ+/aYTYGSlq9qMCS/cNKGJjy+csc=
 github.com/onsi/gomega v1.7.1 h1:K0jcRCwNQM3vFGh1ppMtDh/+7ApJrjldlX8fA0jDTLQ=
 github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY=
+github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo=
 github.com/opencontainers/runc v1.1.3 h1:vIXrkId+0/J2Ymu2m7VjGvbSlAId9XNRPhn2p4b+d8w=
 github.com/opencontainers/runc v1.1.3/go.mod h1:1J5XiS+vdZ3wCyZybsuxXZWGrgSr8fFJHLXuG2PsnNg=
 github.com/opencontainers/runc v1.1.7/go.mod h1:CbUumNnWCuTGFukNXahoo/RFBZvDAgRh/smNYNOhA50=
@@ -980,6 +974,12 @@ github.com/sirupsen/logrus v1.8.1/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic
 github.com/sirupsen/logrus v1.9.0 h1:trlNQbNUG3OdDrDil03MCb1H2o9nJ1x4/5LYw7byDE0=
 github.com/sirupsen/logrus v1.9.0/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
 github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
+github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
+github.com/smartystreets/assertions v1.13.1 h1:Ef7KhSmjZcK6AVf9YbJdvPYG9avaF0ZxudX+ThRdWfU=
+github.com/smartystreets/assertions v1.13.1/go.mod h1:cXr/IwVfSo/RbCSPhoAPv73p3hlSdrBH/b3SdnW/LMY=
+github.com/smartystreets/goconvey v1.6.4/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA=
+github.com/smartystreets/goconvey v1.8.0 h1:Oi49ha/2MURE0WexF052Z0m+BNSGirfjg5RL+JXWq3w=
+github.com/smartystreets/goconvey v1.8.0/go.mod h1:EdX8jtrTIj26jmjCOVNMVSIYAtgexqXKHOXW2Dx9JLg=
 github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72 h1:qLC7fQah7D6K1B0ujays3HV9gkFtllcxhzImRR7ArPQ=
 github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
 github.com/spf13/afero v1.1.2 h1:m8/z1t7/fwjysjQRYbP0RD+bUIF/8tJwPdEZsI83ACI=
@@ -1141,6 +1141,7 @@ golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73r
 golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20181220203305-927f97764cc3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190327091125-710a502c58a2/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190628185345-da137c7871d7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
@@ -1154,9 +1155,11 @@ golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/
 golang.org/x/net v0.0.0-20200501053045-e0ff5e5a1de5/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
 golang.org/x/net v0.0.0-20200506145744-7e3656a0809f/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
 golang.org/x/net v0.0.0-20200513185701-a91f0712d120/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
 golang.org/x/net v0.0.0-20200520182314-0ba52f642ac2/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
 golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
 golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
+golang.org/x/net v0.0.0-20200813134508-3edf25e44fcc/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
 golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
 golang.org/x/net v0.0.0-20201010224723-4f7140c49acb/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
 golang.org/x/net v0.0.0-20210119194325-5f4716e94777/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
@@ -1195,9 +1198,12 @@ golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5h
 golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190626221950-04f50cda93cb/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190813064441-fde4db37ae7a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191001151750-bb3f8db39f24/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191008105621-543471e840be/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200106162015-b016eb3dc98e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200113162924-86b910548bc1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -1211,10 +1217,12 @@ golang.org/x/sys v0.0.0-20200331124033-c3d80250170d/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20200501052902-10377860bb8e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200511232937-7e40ca221e25/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200515095857-1151b9dac4a9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200519105757-fe76b779f299/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200523222454-059865788121/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200615200032-f1bc736245b1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200625212154-ddb9806d33ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200803210538-64077c9b5642/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200814200057-3d37ad5750ed/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200826173525-f9321e4c35a6/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201101102859-da207088b7d1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -1273,6 +1281,7 @@ golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGm
 golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
 golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
 golang.org/x/tools v0.0.0-20190327201419-c70d86f8b7cf/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190328211700-ab21143f2384/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
 golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
 golang.org/x/tools v0.0.0-20191125144606-a911d9008d1f/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20191130070609-6e064ea0cf2d/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=

rollup/cmd/event_watcher/app/app.go

@@ -56,7 +56,7 @@ func action(ctx *cli.Context) error {
 	defer func() {
 		cancel()
 		if err = database.CloseDB(db); err != nil {
-			log.Error("can not close ormFactory", "error", err)
+			log.Crit("failed to close db connection", "error", err)
 		}
 	}()
 
@@ -64,14 +64,12 @@ func action(ctx *cli.Context) error {
 	observability.Server(ctx, db)
 	l1client, err := ethclient.Dial(cfg.L1Config.Endpoint)
 	if err != nil {
-		log.Error("failed to connect l1 geth", "config file", cfgFile, "error", err)
-		return err
+		log.Crit("failed to connect l1 geth", "config file", cfgFile, "error", err)
 	}
 
 	l2client, err := ethclient.Dial(cfg.L2Config.Endpoint)
 	if err != nil {
-		log.Error("failed to connect l2 geth", "config file", cfgFile, "error", err)
-		return err
+		log.Crit("failed to connect l2 geth", "config file", cfgFile, "error", err)
 	}
 
 	l1watcher := watcher.NewL1WatcherClient(ctx.Context, l1client, cfg.L1Config.StartHeight, cfg.L1Config.Confirmations,

rollup/cmd/gas_oracle/app/app.go

@@ -59,7 +59,7 @@ func action(ctx *cli.Context) error {
 	defer func() {
 		cancel()
 		if err = database.CloseDB(db); err != nil {
-			log.Error("can not close ormFactory", "error", err)
+			log.Crit("failed to close db connection", "error", err)
 		}
 	}()
 
@@ -68,28 +68,24 @@ func action(ctx *cli.Context) error {
 
 	l1client, err := ethclient.Dial(cfg.L1Config.Endpoint)
 	if err != nil {
-		log.Error("failed to connect l1 geth", "config file", cfgFile, "error", err)
-		return err
+		log.Crit("failed to connect l1 geth", "config file", cfgFile, "error", err)
 	}
 
 	// Init l2geth connection
 	l2client, err := ethclient.Dial(cfg.L2Config.Endpoint)
 	if err != nil {
-		log.Error("failed to connect l2 geth", "config file", cfgFile, "error", err)
-		return err
+		log.Crit("failed to connect l2 geth", "config file", cfgFile, "error", err)
 	}
 
 	l1watcher := watcher.NewL1WatcherClient(ctx.Context, l1client, cfg.L1Config.StartHeight, cfg.L1Config.Confirmations, cfg.L1Config.L1MessageQueueAddress, cfg.L1Config.ScrollChainContractAddress, db, registry)
 
 	l1relayer, err := relayer.NewLayer1Relayer(ctx.Context, db, cfg.L1Config.RelayerConfig, registry)
 	if err != nil {
-		log.Error("failed to create new l1 relayer", "config file", cfgFile, "error", err)
-		return err
+		log.Crit("failed to create new l1 relayer", "config file", cfgFile, "error", err)
 	}
 	l2relayer, err := relayer.NewLayer2Relayer(ctx.Context, l2client, db, cfg.L2Config.RelayerConfig, false /* initGenesis */, registry)
 	if err != nil {
-		log.Error("failed to create new l2 relayer", "config file", cfgFile, "error", err)
-		return err
+		log.Crit("failed to create new l2 relayer", "config file", cfgFile, "error", err)
 	}
 	// Start l1 watcher process
 	go utils.LoopWithContext(subCtx, 10*time.Second, func(ctx context.Context) {
@@ -103,6 +99,7 @@ func action(ctx *cli.Context) error {
 
 		if loopErr = l1watcher.FetchBlockHeader(number - 1); loopErr != nil {
 			log.Error("Failed to fetch L1 block header", "lastest", number-1, "err", loopErr)
+			return
 		}
 	})
 

rollup/cmd/rollup_relayer/app/app.go

@@ -59,7 +59,7 @@ func action(ctx *cli.Context) error {
 	defer func() {
 		cancel()
 		if err = database.CloseDB(db); err != nil {
-			log.Error("can not close ormFactory", "error", err)
+			log.Crit("failed to close db connection", "error", err)
 		}
 	}()
 
@@ -69,27 +69,23 @@ func action(ctx *cli.Context) error {
 	// Init l2geth connection
 	l2client, err := ethclient.Dial(cfg.L2Config.Endpoint)
 	if err != nil {
-		log.Error("failed to connect l2 geth", "config file", cfgFile, "error", err)
-		return err
+		log.Crit("failed to connect l2 geth", "config file", cfgFile, "error", err)
 	}
 
 	initGenesis := ctx.Bool(utils.ImportGenesisFlag.Name)
 	l2relayer, err := relayer.NewLayer2Relayer(ctx.Context, l2client, db, cfg.L2Config.RelayerConfig, initGenesis, registry)
 	if err != nil {
-		log.Error("failed to create l2 relayer", "config file", cfgFile, "error", err)
-		return err
+		log.Crit("failed to create l2 relayer", "config file", cfgFile, "error", err)
 	}
 
 	chunkProposer := watcher.NewChunkProposer(subCtx, cfg.L2Config.ChunkProposerConfig, db, registry)
 	if err != nil {
-		log.Error("failed to create chunkProposer", "config file", cfgFile, "error", err)
-		return err
+		log.Crit("failed to create chunkProposer", "config file", cfgFile, "error", err)
 	}
 
 	batchProposer := watcher.NewBatchProposer(subCtx, cfg.L2Config.BatchProposerConfig, db, registry)
 	if err != nil {
-		log.Error("failed to create batchProposer", "config file", cfgFile, "error", err)
-		return err
+		log.Crit("failed to create batchProposer", "config file", cfgFile, "error", err)
 	}
 
 	l2watcher := watcher.NewL2WatcherClient(subCtx, l2client, cfg.L2Config.Confirmations, cfg.L2Config.L2MessengerAddress,

rollup/conf/config.json

@@ -9,16 +9,13 @@
       "gas_price_oracle_address": "0x0000000000000000000000000000000000000000",
       "sender_config": {
         "endpoint": "https://rpc.scroll.io",
-        "check_pending_time": 2,
-        "check_balance_time": 100,
         "escalate_blocks": 100,
         "confirmations": "0x1",
         "escalate_multiple_num": 11,
         "escalate_multiple_den": 10,
         "max_gas_price": 10000000000,
         "tx_type": "LegacyTx",
-        "min_balance": 100000000000000000000,
-        "pending_limit": 10
+        "check_pending_time": 3
       },
       "gas_oracle_config": {
         "min_gas_price": 0,
@@ -37,16 +34,13 @@
       "gas_price_oracle_address": "0x0000000000000000000000000000000000000000",
       "sender_config": {
         "endpoint": "https://rpc.ankr.com/eth",
-        "check_pending_time": 10,
-        "check_balance_time": 100,
         "escalate_blocks": 100,
         "confirmations": "0x6",
         "escalate_multiple_num": 11,
         "escalate_multiple_den": 10,
         "max_gas_price": 10000000000,
         "tx_type": "DynamicFeeTx",
-        "min_balance": 100000000000000000000,
-        "pending_limit": 10
+        "check_pending_time": 12
       },
       "gas_oracle_config": {
         "min_gas_price": 0,

rollup/go.mod

@@ -6,7 +6,6 @@ require (
 	github.com/agiledragon/gomonkey/v2 v2.9.0
 	github.com/gin-gonic/gin v1.9.1
 	github.com/go-resty/resty/v2 v2.7.0
-	github.com/orcaman/concurrent-map/v2 v2.0.1
 	github.com/prometheus/client_golang v1.14.0
 	github.com/scroll-tech/go-ethereum v1.10.14-0.20231130005111-38a3a9c9198c
 	github.com/smartystreets/goconvey v1.8.0

rollup/go.sum

@@ -156,8 +156,6 @@ github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1Cpa
 github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY=
 github.com/onsi/gomega v1.10.1 h1:o0+MgICZLuZ7xjH7Vx6zS/zcu93/BEp1VwkIW1mEXCE=
 github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo=
-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/pelletier/go-toml/v2 v2.1.0 h1:FnwAJ4oYMvbT/34k9zzHuZNrhlz48GB3/s6at6/MHO4=
 github.com/pelletier/go-toml/v2 v2.1.0/go.mod h1:tJU2Z3ZkXwnxa4DPO899bsyIoywizdUvyaeZurnPPDc=
 github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=

rollup/internal/config/relayer.go

@@ -4,7 +4,6 @@ import (
 	"crypto/ecdsa"
 	"encoding/json"
 	"fmt"
-	"math/big"
 
 	"github.com/scroll-tech/go-ethereum/common"
 	"github.com/scroll-tech/go-ethereum/crypto"
@@ -29,12 +28,6 @@ type SenderConfig struct {
 	MaxGasPrice uint64 `json:"max_gas_price"`
 	// The transaction type to use: LegacyTx, AccessListTx, DynamicFeeTx
 	TxType string `json:"tx_type"`
-	// The min balance set for check and set balance for sender's accounts.
-	MinBalance *big.Int `json:"min_balance"`
-	// 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"`
 }
 
 // ChainMonitor this config is used to get batch status from chain_monitor API.

rollup/internal/controller/relayer/l1_relayer.go

@@ -2,7 +2,6 @@ package relayer
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"math/big"
 
@@ -44,7 +43,7 @@ type Layer1Relayer struct {
 
 // NewLayer1Relayer will return a new instance of Layer1RelayerClient
 func NewLayer1Relayer(ctx context.Context, db *gorm.DB, cfg *config.RelayerConfig, reg prometheus.Registerer) (*Layer1Relayer, error) {
-	gasOracleSender, err := sender.NewSender(ctx, cfg.SenderConfig, cfg.GasOracleSenderPrivateKey, "l1_relayer", "gas_oracle_sender", reg)
+	gasOracleSender, err := sender.NewSender(ctx, cfg.SenderConfig, cfg.GasOracleSenderPrivateKey, "l1_relayer", "gas_oracle_sender", types.SenderTypeL1GasOracle, db, reg)
 	if err != nil {
 		addr := crypto.PubkeyToAddress(cfg.GasOracleSenderPrivateKey.PublicKey)
 		return nil, fmt.Errorf("new gas oracle sender failed for address %s, err: %v", addr.Hex(), err)
@@ -118,9 +117,7 @@ func (r *Layer1Relayer) ProcessGasPriceOracle() {
 
 			hash, err := r.gasOracleSender.SendTransaction(block.Hash, &r.cfg.GasPriceOracleContractAddress, big.NewInt(0), data, 0)
 			if err != nil {
-				if !errors.Is(err, sender.ErrNoAvailableAccount) && !errors.Is(err, sender.ErrFullPending) {
-					log.Error("Failed to send setL1BaseFee tx to layer2 ", "block.Hash", block.Hash, "block.Height", block.Number, "err", err)
-				}
+				log.Error("Failed to send setL1BaseFee tx to layer2 ", "block.Hash", block.Hash, "block.Height", block.Number, "err", err)
 				return
 			}
 
@@ -136,28 +133,38 @@ func (r *Layer1Relayer) ProcessGasPriceOracle() {
 	}
 }
 
+func (r *Layer1Relayer) handleConfirmation(cfm *sender.Confirmation) {
+	switch cfm.SenderType {
+	case types.SenderTypeL1GasOracle:
+		var status types.GasOracleStatus
+		if cfm.IsSuccessful {
+			status = types.GasOracleImported
+			r.metrics.rollupL1UpdateGasOracleConfirmedTotal.Inc()
+			log.Info("UpdateGasOracleTxType transaction confirmed in layer2", "confirmation", cfm)
+		} else {
+			status = types.GasOracleImportedFailed
+			r.metrics.rollupL1UpdateGasOracleConfirmedFailedTotal.Inc()
+			log.Warn("UpdateGasOracleTxType transaction confirmed but failed in layer2", "confirmation", cfm)
+		}
+
+		err := r.l1BlockOrm.UpdateL1GasOracleStatusAndOracleTxHash(r.ctx, cfm.ContextID, status, cfm.TxHash.String())
+		if err != nil {
+			log.Warn("UpdateL1GasOracleStatusAndOracleTxHash failed", "confirmation", cfm, "err", err)
+		}
+	default:
+		log.Warn("Unknown transaction type", "confirmation", cfm)
+	}
+
+	log.Info("Transaction confirmed in layer2", "confirmation", cfm)
+}
+
 func (r *Layer1Relayer) handleConfirmLoop(ctx context.Context) {
 	for {
 		select {
 		case <-ctx.Done():
 			return
 		case cfm := <-r.gasOracleSender.ConfirmChan():
-			r.metrics.rollupL1GasOraclerConfirmedTotal.Inc()
-			if !cfm.IsSuccessful {
-				// @discuss: maybe make it pending again?
-				err := r.l1BlockOrm.UpdateL1GasOracleStatusAndOracleTxHash(r.ctx, cfm.ID, types.GasOracleFailed, cfm.TxHash.String())
-				if err != nil {
-					log.Warn("UpdateL1GasOracleStatusAndOracleTxHash failed", "err", err)
-				}
-				log.Warn("transaction confirmed but failed in layer2", "confirmation", cfm)
-			} else {
-				// @todo handle db error
-				err := r.l1BlockOrm.UpdateL1GasOracleStatusAndOracleTxHash(r.ctx, cfm.ID, types.GasOracleImported, cfm.TxHash.String())
-				if err != nil {
-					log.Warn("UpdateGasOracleStatusAndOracleTxHash failed", "err", err)
-				}
-				log.Info("transaction confirmed in layer2", "confirmation", cfm)
-			}
+			r.handleConfirmation(cfm)
 		}
 	}
 }

rollup/internal/controller/relayer/l1_relayer_metrics.go

@@ -8,12 +8,10 @@ import (
 )
 
 type l1RelayerMetrics struct {
-	rollupL1RelayedMsgsTotal               prometheus.Counter
-	rollupL1RelayedMsgsFailureTotal        prometheus.Counter
-	rollupL1RelayerGasPriceOraclerRunTotal prometheus.Counter
-	rollupL1RelayerLastGasPrice            prometheus.Gauge
-	rollupL1MsgsRelayedConfirmedTotal      prometheus.Counter
-	rollupL1GasOraclerConfirmedTotal       prometheus.Counter
+	rollupL1RelayerGasPriceOraclerRunTotal      prometheus.Counter
+	rollupL1RelayerLastGasPrice                 prometheus.Gauge
+	rollupL1UpdateGasOracleConfirmedTotal       prometheus.Counter
+	rollupL1UpdateGasOracleConfirmedFailedTotal prometheus.Counter
 }
 
 var (
@@ -24,18 +22,6 @@ var (
 func initL1RelayerMetrics(reg prometheus.Registerer) *l1RelayerMetrics {
 	initL1RelayerMetricOnce.Do(func() {
 		l1RelayerMetric = &l1RelayerMetrics{
-			rollupL1RelayedMsgsTotal: promauto.With(reg).NewCounter(prometheus.CounterOpts{
-				Name: "rollup_layer1_msg_relayed_total",
-				Help: "The total number of the l1 relayed message.",
-			}),
-			rollupL1RelayedMsgsFailureTotal: promauto.With(reg).NewCounter(prometheus.CounterOpts{
-				Name: "rollup_layer1_msg_relayed_failure_total",
-				Help: "The total number of the l1 relayed failure message.",
-			}),
-			rollupL1MsgsRelayedConfirmedTotal: promauto.With(reg).NewCounter(prometheus.CounterOpts{
-				Name: "rollup_layer1_relayed_confirmed_total",
-				Help: "The total number of layer1 relayed confirmed",
-			}),
 			rollupL1RelayerGasPriceOraclerRunTotal: promauto.With(reg).NewCounter(prometheus.CounterOpts{
 				Name: "rollup_layer1_gas_price_oracler_total",
 				Help: "The total number of layer1 gas price oracler run total",
@@ -44,9 +30,13 @@ func initL1RelayerMetrics(reg prometheus.Registerer) *l1RelayerMetrics {
 				Name: "rollup_layer1_gas_price_latest_gas_price",
 				Help: "The latest gas price of rollup relayer l1",
 			}),
-			rollupL1GasOraclerConfirmedTotal: promauto.With(reg).NewCounter(prometheus.CounterOpts{
-				Name: "rollup_layer1_gas_oracler_confirmed_total",
-				Help: "The total number of layer1 relayed confirmed",
+			rollupL1UpdateGasOracleConfirmedTotal: promauto.With(reg).NewCounter(prometheus.CounterOpts{
+				Name: "rollup_layer1_update_gas_oracle_confirmed_total",
+				Help: "The total number of updating layer1 gas oracle confirmed",
+			}),
+			rollupL1UpdateGasOracleConfirmedFailedTotal: promauto.With(reg).NewCounter(prometheus.CounterOpts{
+				Name: "rollup_layer1_update_gas_oracle_confirmed_failed_total",
+				Help: "The total number of updating layer1 gas oracle confirmed failed",
 			}),
 		}
 	})

rollup/internal/controller/relayer/l1_relayer_test.go

@@ -61,12 +61,14 @@ func testL1RelayerGasOracleConfirm(t *testing.T) {
 
 	// Simulate message confirmations.
 	l1Relayer.gasOracleSender.SendConfirmation(&sender.Confirmation{
-		ID:           "gas-oracle-1",
+		ContextID:    "gas-oracle-1",
 		IsSuccessful: true,
+		SenderType:   types.SenderTypeL1GasOracle,
 	})
 	l1Relayer.gasOracleSender.SendConfirmation(&sender.Confirmation{
-		ID:           "gas-oracle-2",
+		ContextID:    "gas-oracle-2",
 		IsSuccessful: false,
+		SenderType:   types.SenderTypeL1GasOracle,
 	})
 
 	// Check the database for the updated status using TryTimes.
@@ -74,7 +76,7 @@ func testL1RelayerGasOracleConfirm(t *testing.T) {
 		msg1, err1 := l1BlockOrm.GetL1Blocks(ctx, map[string]interface{}{"hash": "gas-oracle-1"})
 		msg2, err2 := l1BlockOrm.GetL1Blocks(ctx, map[string]interface{}{"hash": "gas-oracle-2"})
 		return err1 == nil && len(msg1) == 1 && types.GasOracleStatus(msg1[0].GasOracleStatus) == types.GasOracleImported &&
-			err2 == nil && len(msg2) == 1 && types.GasOracleStatus(msg2[0].GasOracleStatus) == types.GasOracleFailed
+			err2 == nil && len(msg2) == 1 && types.GasOracleStatus(msg2[0].GasOracleStatus) == types.GasOracleImportedFailed
 	})
 	assert.True(t, ok)
 }

rollup/internal/controller/relayer/l2_relayer.go

@@ -2,11 +2,9 @@ package relayer
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"math/big"
 	"sort"
-	"sync"
 	"time"
 
 	"github.com/go-resty/resty/v2"
@@ -60,31 +58,23 @@ type Layer2Relayer struct {
 	// Used to get batch status from chain_monitor api.
 	chainMonitorClient *resty.Client
 
-	// A list of processing batches commitment.
-	// key(string): confirmation ID, value(string): batch hash.
-	processingCommitment sync.Map
-
-	// A list of processing batch finalization.
-	// key(string): confirmation ID, value(string): batch hash.
-	processingFinalization sync.Map
-
 	metrics *l2RelayerMetrics
 }
 
 // NewLayer2Relayer will return a new instance of Layer2RelayerClient
 func NewLayer2Relayer(ctx context.Context, l2Client *ethclient.Client, db *gorm.DB, cfg *config.RelayerConfig, initGenesis bool, reg prometheus.Registerer) (*Layer2Relayer, error) {
-	commitSender, err := sender.NewSender(ctx, cfg.SenderConfig, cfg.CommitSenderPrivateKey, "l2_relayer", "commit_sender", reg)
+	commitSender, err := sender.NewSender(ctx, cfg.SenderConfig, cfg.CommitSenderPrivateKey, "l2_relayer", "commit_sender", types.SenderTypeCommitBatch, db, reg)
 	if err != nil {
 		addr := crypto.PubkeyToAddress(cfg.CommitSenderPrivateKey.PublicKey)
 		return nil, fmt.Errorf("new commit sender failed for address %s, err: %w", addr.Hex(), err)
 	}
-	finalizeSender, err := sender.NewSender(ctx, cfg.SenderConfig, cfg.FinalizeSenderPrivateKey, "l2_relayer", "finalize_sender", reg)
+	finalizeSender, err := sender.NewSender(ctx, cfg.SenderConfig, cfg.FinalizeSenderPrivateKey, "l2_relayer", "finalize_sender", types.SenderTypeFinalizeBatch, db, reg)
 	if err != nil {
 		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, "l2_relayer", "gas_oracle_sender", reg)
+	gasOracleSender, err := sender.NewSender(ctx, cfg.SenderConfig, cfg.GasOracleSenderPrivateKey, "l2_relayer", "gas_oracle_sender", types.SenderTypeL2GasOracle, db, reg)
 	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)
@@ -125,9 +115,7 @@ func NewLayer2Relayer(ctx context.Context, l2Client *ethclient.Client, db *gorm.
 		minGasPrice:  minGasPrice,
 		gasPriceDiff: gasPriceDiff,
 
-		cfg:                    cfg,
-		processingCommitment:   sync.Map{},
-		processingFinalization: sync.Map{},
+		cfg: cfg,
 	}
 
 	// chain_monitor client
@@ -253,8 +241,8 @@ func (r *Layer2Relayer) commitGenesisBatch(batchHash string, batchHeader []byte,
 
 		// handle confirmation
 		case confirmation := <-r.commitSender.ConfirmChan():
-			if confirmation.ID != batchHash {
-				return fmt.Errorf("unexpected import genesis confirmation id, expected: %v, got: %v", batchHash, confirmation.ID)
+			if confirmation.ContextID != batchHash {
+				return fmt.Errorf("unexpected import genesis confirmation id, expected: %v, got: %v", batchHash, confirmation.ContextID)
 			}
 			if !confirmation.IsSuccessful {
 				return fmt.Errorf("import genesis batch tx failed")
@@ -293,9 +281,7 @@ func (r *Layer2Relayer) ProcessGasPriceOracle() {
 
 			hash, err := r.gasOracleSender.SendTransaction(batch.Hash, &r.cfg.GasPriceOracleContractAddress, big.NewInt(0), data, 0)
 			if err != nil {
-				if !errors.Is(err, sender.ErrNoAvailableAccount) && !errors.Is(err, sender.ErrFullPending) {
-					log.Error("Failed to send setL2BaseFee tx to layer2 ", "batch.Hash", batch.Hash, "err", err)
-				}
+				log.Error("Failed to send setL2BaseFee tx to layer2 ", "batch.Hash", batch.Hash, "err", err)
 				return
 			}
 
@@ -382,14 +368,13 @@ func (r *Layer2Relayer) ProcessPendingBatches() {
 		}
 
 		// send transaction
-		txID := batch.Hash + "-commit"
 		fallbackGasLimit := uint64(float64(batch.TotalL1CommitGas) * r.cfg.L1CommitGasLimitMultiplier)
 		if types.RollupStatus(batch.RollupStatus) == types.RollupCommitFailed {
 			// use eth_estimateGas if this batch has been committed failed.
 			fallbackGasLimit = 0
 			log.Warn("Batch commit previously failed, using eth_estimateGas for the re-submission", "hash", batch.Hash)
 		}
-		txHash, err := r.commitSender.SendTransaction(txID, &r.cfg.RollupContractAddress, big.NewInt(0), calldata, fallbackGasLimit)
+		txHash, err := r.commitSender.SendTransaction(batch.Hash, &r.cfg.RollupContractAddress, big.NewInt(0), calldata, fallbackGasLimit)
 		if err != nil {
 			log.Error(
 				"Failed to send commitBatch tx to layer1",
@@ -415,7 +400,6 @@ func (r *Layer2Relayer) ProcessPendingBatches() {
 			return
 		}
 		r.metrics.rollupL2RelayerProcessPendingBatchSuccessTotal.Inc()
-		r.processingCommitment.Store(txID, batch.Hash)
 		log.Info("Sent the commitBatch tx to layer1", "batch index", batch.Index, "batch hash", batch.Hash, "tx hash", txHash.Hex())
 	}
 }
@@ -554,34 +538,27 @@ func (r *Layer2Relayer) finalizeBatch(batch *orm.Batch, withProof bool) error {
 		}
 	}
 
-	txID := batch.Hash + "-finalize"
 	// add suffix `-finalize` to avoid duplication with commit tx in unit tests
-	txHash, err := r.finalizeSender.SendTransaction(txID, &r.cfg.RollupContractAddress, big.NewInt(0), txCalldata, 0)
+	txHash, err := r.finalizeSender.SendTransaction(batch.Hash, &r.cfg.RollupContractAddress, big.NewInt(0), txCalldata, 0)
 	finalizeTxHash := &txHash
 	if err != nil {
-		if !errors.Is(err, sender.ErrNoAvailableAccount) && !errors.Is(err, sender.ErrFullPending) {
-			// This can happen normally if we try to finalize 2 or more
-			// batches around the same time. The 2nd tx might fail since
-			// the client does not see the 1st tx's updates at this point.
-			// TODO: add more fine-grained error handling
-			log.Error(
-				"finalizeBatch in layer1 failed",
-				"with proof", withProof,
-				"index", batch.Index,
-				"hash", batch.Hash,
-				"RollupContractAddress", r.cfg.RollupContractAddress,
-				"err", err,
-			)
-			log.Debug(
-				"finalizeBatch in layer1 failed",
-				"with proof", withProof,
-				"index", batch.Index,
-				"hash", batch.Hash,
-				"RollupContractAddress", r.cfg.RollupContractAddress,
-				"calldata", common.Bytes2Hex(txCalldata),
-				"err", err,
-			)
-		}
+		log.Error(
+			"finalizeBatch in layer1 failed",
+			"with proof", withProof,
+			"index", batch.Index,
+			"hash", batch.Hash,
+			"RollupContractAddress", r.cfg.RollupContractAddress,
+			"err", err,
+		)
+		log.Debug(
+			"finalizeBatch in layer1 failed",
+			"with proof", withProof,
+			"index", batch.Index,
+			"hash", batch.Hash,
+			"RollupContractAddress", r.cfg.RollupContractAddress,
+			"calldata", common.Bytes2Hex(txCalldata),
+			"err", err,
+		)
 		return err
 	}
 	log.Info("finalizeBatch in layer1", "with proof", withProof, "index", batch.Index, "batch hash", batch.Hash, "tx hash", batch.Hash)
@@ -591,7 +568,6 @@ func (r *Layer2Relayer) finalizeBatch(batch *orm.Batch, withProof bool) error {
 		log.Error("UpdateFinalizeTxHashAndRollupStatus failed", "index", batch.Index, "batch hash", batch.Hash, "tx hash", finalizeTxHash.String(), "err", err)
 		return err
 	}
-	r.processingFinalization.Store(txID, batch.Hash)
 	r.metrics.rollupL2RelayerProcessCommittedBatchesFinalizedSuccessTotal.Inc()
 	return nil
 }
@@ -642,53 +618,59 @@ func (r *Layer2Relayer) getBatchStatusByIndex(batch *orm.Batch) (bool, error) {
 	return response.Data, nil
 }
 
-func (r *Layer2Relayer) handleConfirmation(confirmation *sender.Confirmation) {
-	transactionType := "Unknown"
-	// check whether it is CommitBatches transaction
-	if batchHash, ok := r.processingCommitment.Load(confirmation.ID); ok {
-		transactionType = "BatchesCommitment"
+func (r *Layer2Relayer) handleConfirmation(cfm *sender.Confirmation) {
+	switch cfm.SenderType {
+	case types.SenderTypeCommitBatch:
 		var status types.RollupStatus
-		if confirmation.IsSuccessful {
+		if cfm.IsSuccessful {
 			status = types.RollupCommitted
+			r.metrics.rollupL2BatchesCommittedConfirmedTotal.Inc()
 		} else {
 			status = types.RollupCommitFailed
 			r.metrics.rollupL2BatchesCommittedConfirmedFailedTotal.Inc()
-			log.Warn("commitBatch transaction confirmed but failed in layer1", "confirmation", confirmation)
+			log.Warn("CommitBatchTxType transaction confirmed but failed in layer1", "confirmation", cfm)
 		}
-		// @todo handle db error
-		err := r.batchOrm.UpdateCommitTxHashAndRollupStatus(r.ctx, batchHash.(string), confirmation.TxHash.String(), status)
-		if err != nil {
-			log.Warn("UpdateCommitTxHashAndRollupStatus failed",
-				"batch hash", batchHash.(string),
-				"tx hash", confirmation.TxHash.String(), "err", err)
-		}
-		r.metrics.rollupL2BatchesCommittedConfirmedTotal.Inc()
-		r.processingCommitment.Delete(confirmation.ID)
-	}
 
-	// check whether it is proof finalization transaction
-	if batchHash, ok := r.processingFinalization.Load(confirmation.ID); ok {
-		transactionType = "ProofFinalization"
+		err := r.batchOrm.UpdateCommitTxHashAndRollupStatus(r.ctx, cfm.ContextID, cfm.TxHash.String(), status)
+		if err != nil {
+			log.Warn("UpdateCommitTxHashAndRollupStatus failed", "confirmation", cfm, "err", err)
+		}
+	case types.SenderTypeFinalizeBatch:
 		var status types.RollupStatus
-		if confirmation.IsSuccessful {
+		if cfm.IsSuccessful {
 			status = types.RollupFinalized
+			r.metrics.rollupL2BatchesFinalizedConfirmedTotal.Inc()
 		} else {
 			status = types.RollupFinalizeFailed
 			r.metrics.rollupL2BatchesFinalizedConfirmedFailedTotal.Inc()
-			log.Warn("finalizeBatchWithProof transaction confirmed but failed in layer1", "confirmation", confirmation)
+			log.Warn("FinalizeBatchTxType transaction confirmed but failed in layer1", "confirmation", cfm)
 		}
 
-		// @todo handle db error
-		err := r.batchOrm.UpdateFinalizeTxHashAndRollupStatus(r.ctx, batchHash.(string), confirmation.TxHash.String(), status)
+		err := r.batchOrm.UpdateFinalizeTxHashAndRollupStatus(r.ctx, cfm.ContextID, cfm.TxHash.String(), status)
 		if err != nil {
-			log.Warn("UpdateFinalizeTxHashAndRollupStatus failed",
-				"batch hash", batchHash.(string),
-				"tx hash", confirmation.TxHash.String(), "err", err)
+			log.Warn("UpdateFinalizeTxHashAndRollupStatus failed", "confirmation", cfm, "err", err)
 		}
-		r.metrics.rollupL2BatchesFinalizedConfirmedTotal.Inc()
-		r.processingFinalization.Delete(confirmation.ID)
+	case types.SenderTypeL2GasOracle:
+		batchHash := cfm.ContextID
+		var status types.GasOracleStatus
+		if cfm.IsSuccessful {
+			status = types.GasOracleImported
+			r.metrics.rollupL2UpdateGasOracleConfirmedTotal.Inc()
+		} else {
+			status = types.GasOracleImportedFailed
+			r.metrics.rollupL2UpdateGasOracleConfirmedFailedTotal.Inc()
+			log.Warn("UpdateGasOracleTxType transaction confirmed but failed in layer1", "confirmation", cfm)
+		}
+
+		err := r.batchOrm.UpdateL2GasOracleStatusAndOracleTxHash(r.ctx, batchHash, status, cfm.TxHash.String())
+		if err != nil {
+			log.Warn("UpdateL2GasOracleStatusAndOracleTxHash failed", "confirmation", cfm, "err", err)
+		}
+	default:
+		log.Warn("Unknown transaction type", "confirmation", cfm)
 	}
-	log.Info("transaction confirmed in layer1", "type", transactionType, "confirmation", confirmation)
+
+	log.Info("Transaction confirmed in layer1", "confirmation", cfm)
 }
 
 func (r *Layer2Relayer) handleConfirmLoop(ctx context.Context) {
@@ -696,27 +678,12 @@ func (r *Layer2Relayer) handleConfirmLoop(ctx context.Context) {
 		select {
 		case <-ctx.Done():
 			return
-		case confirmation := <-r.commitSender.ConfirmChan():
-			r.handleConfirmation(confirmation)
-		case confirmation := <-r.finalizeSender.ConfirmChan():
-			r.handleConfirmation(confirmation)
+		case cfm := <-r.commitSender.ConfirmChan():
+			r.handleConfirmation(cfm)
+		case cfm := <-r.finalizeSender.ConfirmChan():
+			r.handleConfirmation(cfm)
 		case cfm := <-r.gasOracleSender.ConfirmChan():
-			r.metrics.rollupL2BatchesGasOraclerConfirmedTotal.Inc()
-			if !cfm.IsSuccessful {
-				// @discuss: maybe make it pending again?
-				err := r.batchOrm.UpdateL2GasOracleStatusAndOracleTxHash(r.ctx, cfm.ID, types.GasOracleFailed, cfm.TxHash.String())
-				if err != nil {
-					log.Warn("UpdateL2GasOracleStatusAndOracleTxHash failed", "err", err)
-				}
-				log.Warn("transaction confirmed but failed in layer1", "confirmation", cfm)
-			} else {
-				// @todo handle db error
-				err := r.batchOrm.UpdateL2GasOracleStatusAndOracleTxHash(r.ctx, cfm.ID, types.GasOracleImported, cfm.TxHash.String())
-				if err != nil {
-					log.Warn("UpdateL2GasOracleStatusAndOracleTxHash failed", "err", err)
-				}
-				log.Info("transaction confirmed in layer1", "confirmation", cfm)
-			}
+			r.handleConfirmation(cfm)
 		}
 	}
 }

rollup/internal/controller/relayer/l2_relayer_metrics.go

@@ -19,7 +19,8 @@ type l2RelayerMetrics struct {
 	rollupL2BatchesCommittedConfirmedFailedTotal                prometheus.Counter
 	rollupL2BatchesFinalizedConfirmedTotal                      prometheus.Counter
 	rollupL2BatchesFinalizedConfirmedFailedTotal                prometheus.Counter
-	rollupL2BatchesGasOraclerConfirmedTotal                     prometheus.Counter
+	rollupL2UpdateGasOracleConfirmedTotal                       prometheus.Counter
+	rollupL2UpdateGasOracleConfirmedFailedTotal                 prometheus.Counter
 	rollupL2ChainMonitorLatestFailedCall                        prometheus.Counter
 	rollupL2ChainMonitorLatestFailedBatchStatus                 prometheus.Counter
 }
@@ -76,9 +77,13 @@ func initL2RelayerMetrics(reg prometheus.Registerer) *l2RelayerMetrics {
 				Name: "rollup_layer2_process_finalized_batches_confirmed_failed_total",
 				Help: "The total number of layer2 process finalized batches confirmed failed total",
 			}),
-			rollupL2BatchesGasOraclerConfirmedTotal: promauto.With(reg).NewCounter(prometheus.CounterOpts{
-				Name: "rollup_layer2_process_gras_oracler_confirmed_total",
-				Help: "The total number of layer2 process finalized batches confirmed total",
+			rollupL2UpdateGasOracleConfirmedTotal: promauto.With(reg).NewCounter(prometheus.CounterOpts{
+				Name: "rollup_layer2_update_layer1_gas_oracle_confirmed_total",
+				Help: "The total number of updating layer2 gas oracle confirmed",
+			}),
+			rollupL2UpdateGasOracleConfirmedFailedTotal: promauto.With(reg).NewCounter(prometheus.CounterOpts{
+				Name: "rollup_layer2_update_layer1_gas_oracle_confirmed_failed_total",
+				Help: "The total number of updating layer2 gas oracle confirmed failed",
 			}),
 			rollupL2ChainMonitorLatestFailedCall: promauto.With(reg).NewCounter(prometheus.CounterOpts{
 				Name: "rollup_layer2_chain_monitor_latest_failed_batch_call",

rollup/internal/controller/relayer/l2_relayer_test.go

@@ -164,11 +164,9 @@ func testL2RelayerCommitConfirm(t *testing.T) {
 	assert.NoError(t, err)
 
 	// Simulate message confirmations.
-	processingKeys := []string{"committed-1", "committed-2"}
 	isSuccessful := []bool{true, false}
-
 	batchOrm := orm.NewBatch(db)
-	batchHashes := make([]string, len(processingKeys))
+	batchHashes := make([]string, len(isSuccessful))
 	for i := range batchHashes {
 		batchMeta := &types.BatchMeta{
 			StartChunkIndex: 0,
@@ -181,12 +179,12 @@ func testL2RelayerCommitConfirm(t *testing.T) {
 		batchHashes[i] = batch.Hash
 	}
 
-	for i, key := range processingKeys {
-		l2Relayer.processingCommitment.Store(key, batchHashes[i])
+	for i, batchHash := range batchHashes {
 		l2Relayer.commitSender.SendConfirmation(&sender.Confirmation{
-			ID:           key,
+			ContextID:    batchHash,
 			IsSuccessful: isSuccessful[i],
 			TxHash:       common.HexToHash("0x123456789abcdef"),
+			SenderType:   types.SenderTypeCommitBatch,
 		})
 	}
 
@@ -220,11 +218,9 @@ func testL2RelayerFinalizeConfirm(t *testing.T) {
 	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))
+	batchHashes := make([]string, len(isSuccessful))
 	for i := range batchHashes {
 		batchMeta := &types.BatchMeta{
 			StartChunkIndex: 0,
@@ -237,12 +233,12 @@ func testL2RelayerFinalizeConfirm(t *testing.T) {
 		batchHashes[i] = batch.Hash
 	}
 
-	for i, key := range processingKeys {
-		l2Relayer.processingFinalization.Store(key, batchHashes[i])
+	for i, batchHash := range batchHashes {
 		l2Relayer.finalizeSender.SendConfirmation(&sender.Confirmation{
-			ID:           key,
+			ContextID:    batchHash,
 			IsSuccessful: isSuccessful[i],
 			TxHash:       common.HexToHash("0x123456789abcdef"),
+			SenderType:   types.SenderTypeFinalizeBatch,
 		})
 	}
 
@@ -307,13 +303,14 @@ func testL2RelayerGasOracleConfirm(t *testing.T) {
 
 	for _, confirmation := range confirmations {
 		l2Relayer.gasOracleSender.SendConfirmation(&sender.Confirmation{
-			ID:           confirmation.batchHash,
+			ContextID:    confirmation.batchHash,
 			IsSuccessful: confirmation.isSuccessful,
+			SenderType:   types.SenderTypeL2GasOracle,
 		})
 	}
 	// Check the database for the updated status using TryTimes.
 	ok := utils.TryTimes(5, func() bool {
-		expectedStatuses := []types.GasOracleStatus{types.GasOracleImported, types.GasOracleFailed}
+		expectedStatuses := []types.GasOracleStatus{types.GasOracleImported, types.GasOracleImportedFailed}
 		for i, confirmation := range confirmations {
 			gasOracle, err := batchOrm.GetBatches(context.Background(), map[string]interface{}{"hash": confirmation.batchHash}, nil, 0)
 			if err != nil || len(gasOracle) != 1 || types.GasOracleStatus(gasOracle[0].OracleStatus) != expectedStatuses[i] {
@@ -378,13 +375,13 @@ func testLayer2RelayerProcessGasPriceOracle(t *testing.T) {
 
 	convey.Convey("Failed to send setL2BaseFee tx to layer2", t, func() {
 		targetErr := errors.New("failed to send setL2BaseFee tx to layer2 error")
-		patchGuard.ApplyMethodFunc(relayer.gasOracleSender, "SendTransaction", func(ID string, target *common.Address, value *big.Int, data []byte, fallbackGasLimit uint64) (hash common.Hash, err error) {
+		patchGuard.ApplyMethodFunc(relayer.gasOracleSender, "SendTransaction", func(ContextID string, target *common.Address, value *big.Int, data []byte, fallbackGasLimit uint64) (hash common.Hash, err error) {
 			return common.Hash{}, targetErr
 		})
 		relayer.ProcessGasPriceOracle()
 	})
 
-	patchGuard.ApplyMethodFunc(relayer.gasOracleSender, "SendTransaction", func(ID string, target *common.Address, value *big.Int, data []byte, fallbackGasLimit uint64) (hash common.Hash, err error) {
+	patchGuard.ApplyMethodFunc(relayer.gasOracleSender, "SendTransaction", func(ContextID string, target *common.Address, value *big.Int, data []byte, fallbackGasLimit uint64) (hash common.Hash, err error) {
 		return common.HexToHash("0x56789abcdef1234"), nil
 	})
 

rollup/internal/controller/sender/estimategas.go

@@ -3,7 +3,6 @@ package sender
 import (
 	"fmt"
 	"math/big"
-	"sync/atomic"
 
 	"github.com/scroll-tech/go-ethereum"
 	"github.com/scroll-tech/go-ethereum/common"
@@ -11,16 +10,16 @@ import (
 	"github.com/scroll-tech/go-ethereum/log"
 )
 
-func (s *Sender) estimateLegacyGas(contract *common.Address, value *big.Int, data []byte, fallbackGasLimit uint64) (*FeeData, error) {
+func (s *Sender) estimateLegacyGas(to *common.Address, value *big.Int, data []byte, fallbackGasLimit uint64) (*FeeData, error) {
 	gasPrice, err := s.client.SuggestGasPrice(s.ctx)
 	if err != nil {
 		log.Error("estimateLegacyGas SuggestGasPrice failure", "error", err)
 		return nil, err
 	}
-	gasLimit, _, err := s.estimateGasLimit(contract, data, gasPrice, nil, nil, value, false)
+	gasLimit, _, err := s.estimateGasLimit(to, data, gasPrice, nil, nil, value, false)
 	if err != nil {
-		log.Error("estimateLegacyGas estimateGasLimit failure", "gas price", gasPrice, "from", s.auth.From.Hex(),
-			"nonce", s.auth.Nonce.Uint64(), "contract address", contract.Hex(), "fallback gas limit", fallbackGasLimit, "error", err)
+		log.Error("estimateLegacyGas estimateGasLimit failure", "gas price", gasPrice, "from", s.auth.From.String(),
+			"nonce", s.auth.Nonce.Uint64(), "to address", to.String(), "fallback gas limit", fallbackGasLimit, "error", err)
 		if fallbackGasLimit == 0 {
 			return nil, err
 		}
@@ -34,25 +33,18 @@ func (s *Sender) estimateLegacyGas(contract *common.Address, value *big.Int, dat
 	}, nil
 }
 
-func (s *Sender) estimateDynamicGas(contract *common.Address, value *big.Int, data []byte, fallbackGasLimit uint64) (*FeeData, error) {
+func (s *Sender) estimateDynamicGas(to *common.Address, value *big.Int, data []byte, fallbackGasLimit uint64, baseFee uint64) (*FeeData, error) {
 	gasTipCap, err := s.client.SuggestGasTipCap(s.ctx)
 	if err != nil {
 		log.Error("estimateDynamicGas SuggestGasTipCap failure", "error", err)
 		return nil, err
 	}
 
-	baseFee := big.NewInt(0)
-	if feeGas := atomic.LoadUint64(&s.baseFeePerGas); feeGas != 0 {
-		baseFee.SetUint64(feeGas)
-	}
-	gasFeeCap := new(big.Int).Add(
-		gasTipCap,
-		new(big.Int).Mul(baseFee, big.NewInt(2)),
-	)
-	gasLimit, accessList, err := s.estimateGasLimit(contract, data, nil, gasTipCap, gasFeeCap, value, true)
+	gasFeeCap := new(big.Int).Add(gasTipCap, new(big.Int).Mul(new(big.Int).SetUint64(baseFee), big.NewInt(2)))
+	gasLimit, accessList, err := s.estimateGasLimit(to, data, nil, gasTipCap, gasFeeCap, value, true)
 	if err != nil {
 		log.Error("estimateDynamicGas estimateGasLimit failure",
-			"from", s.auth.From.Hex(), "nonce", s.auth.Nonce.Uint64(), "contract address", contract.Hex(),
+			"from", s.auth.From.String(), "nonce", s.auth.Nonce.Uint64(), "to address", to.String(),
 			"fallback gas limit", fallbackGasLimit, "error", err)
 		if fallbackGasLimit == 0 {
 			return nil, err
@@ -72,10 +64,10 @@ func (s *Sender) estimateDynamicGas(contract *common.Address, value *big.Int, da
 	return feeData, nil
 }
 
-func (s *Sender) estimateGasLimit(contract *common.Address, data []byte, gasPrice, gasTipCap, gasFeeCap, value *big.Int, useAccessList bool) (uint64, *types.AccessList, error) {
+func (s *Sender) estimateGasLimit(to *common.Address, data []byte, gasPrice, gasTipCap, gasFeeCap, value *big.Int, useAccessList bool) (uint64, *types.AccessList, error) {
 	msg := ethereum.CallMsg{
 		From:      s.auth.From,
-		To:        contract,
+		To:        to,
 		GasPrice:  gasPrice,
 		GasTipCap: gasTipCap,
 		GasFeeCap: gasFeeCap,

rollup/internal/controller/sender/metrics.go

@@ -1,95 +0,0 @@
-package sender
-
-import (
-	"sync"
-
-	"github.com/prometheus/client_golang/prometheus"
-	"github.com/prometheus/client_golang/prometheus/promauto"
-)
-
-type senderMetrics struct {
-	senderCheckBalancerTotal                *prometheus.CounterVec
-	senderCheckPendingTransactionTotal      *prometheus.CounterVec
-	sendTransactionTotal                    *prometheus.CounterVec
-	sendTransactionFailureFullTx            *prometheus.GaugeVec
-	sendTransactionFailureRepeatTransaction *prometheus.CounterVec
-	sendTransactionFailureGetFee            *prometheus.CounterVec
-	sendTransactionFailureSendTx            *prometheus.CounterVec
-	resubmitTransactionTotal                *prometheus.CounterVec
-	currentPendingTxsNum                    *prometheus.GaugeVec
-	currentGasFeeCap                        *prometheus.GaugeVec
-	currentGasTipCap                        *prometheus.GaugeVec
-	currentGasPrice                         *prometheus.GaugeVec
-	currentGasLimit                         *prometheus.GaugeVec
-	currentNonce                            *prometheus.GaugeVec
-}
-
-var (
-	initSenderMetricOnce sync.Once
-	sm                   *senderMetrics
-)
-
-func initSenderMetrics(reg prometheus.Registerer) *senderMetrics {
-	initSenderMetricOnce.Do(func() {
-		sm = &senderMetrics{
-			sendTransactionTotal: promauto.With(reg).NewCounterVec(prometheus.CounterOpts{
-				Name: "rollup_sender_send_transaction_total",
-				Help: "The total number of sending transaction.",
-			}, []string{"service", "name"}),
-			sendTransactionFailureFullTx: promauto.With(reg).NewGaugeVec(prometheus.GaugeOpts{
-				Name: "rollup_sender_send_transaction_full_tx_failure_total",
-				Help: "The total number of sending transaction failure for full size tx.",
-			}, []string{"service", "name"}),
-			sendTransactionFailureRepeatTransaction: promauto.With(reg).NewCounterVec(prometheus.CounterOpts{
-				Name: "rollup_sender_send_transaction_repeat_transaction_failure_total",
-				Help: "The total number of sending transaction failure for repeat transaction.",
-			}, []string{"service", "name"}),
-			sendTransactionFailureGetFee: promauto.With(reg).NewCounterVec(prometheus.CounterOpts{
-				Name: "rollup_sender_send_transaction_get_fee_failure_total",
-				Help: "The total number of sending transaction failure for getting fee.",
-			}, []string{"service", "name"}),
-			sendTransactionFailureSendTx: promauto.With(reg).NewCounterVec(prometheus.CounterOpts{
-				Name: "rollup_sender_send_transaction_send_tx_failure_total",
-				Help: "The total number of sending transaction failure for sending tx.",
-			}, []string{"service", "name"}),
-			resubmitTransactionTotal: promauto.With(reg).NewCounterVec(prometheus.CounterOpts{
-				Name: "rollup_sender_send_transaction_resubmit_send_transaction_total",
-				Help: "The total number of resubmit transaction.",
-			}, []string{"service", "name"}),
-			currentPendingTxsNum: promauto.With(reg).NewGaugeVec(prometheus.GaugeOpts{
-				Name: "rollup_sender_pending_tx_count",
-				Help: "The pending tx count in the sender.",
-			}, []string{"service", "name"}),
-			currentGasFeeCap: promauto.With(reg).NewGaugeVec(prometheus.GaugeOpts{
-				Name: "rollup_sender_gas_fee_cap",
-				Help: "The gas fee of current transaction.",
-			}, []string{"service", "name"}),
-			currentGasTipCap: promauto.With(reg).NewGaugeVec(prometheus.GaugeOpts{
-				Name: "rollup_sender_gas_tip_cap",
-				Help: "The gas tip of current transaction.",
-			}, []string{"service", "name"}),
-			currentGasPrice: promauto.With(reg).NewGaugeVec(prometheus.GaugeOpts{
-				Name: "rollup_sender_gas_price_cap",
-				Help: "The gas price of current transaction.",
-			}, []string{"service", "name"}),
-			currentGasLimit: promauto.With(reg).NewGaugeVec(prometheus.GaugeOpts{
-				Name: "rollup_sender_gas_limit",
-				Help: "The gas limit of current transaction.",
-			}, []string{"service", "name"}),
-			currentNonce: promauto.With(reg).NewGaugeVec(prometheus.GaugeOpts{
-				Name: "rollup_sender_nonce",
-				Help: "The nonce of current transaction.",
-			}, []string{"service", "name"}),
-			senderCheckPendingTransactionTotal: promauto.With(reg).NewCounterVec(prometheus.CounterOpts{
-				Name: "rollup_sender_check_pending_transaction_total",
-				Help: "The total number of check pending transaction.",
-			}, []string{"service", "name"}),
-			senderCheckBalancerTotal: promauto.With(reg).NewCounterVec(prometheus.CounterOpts{
-				Name: "rollup_sender_check_balancer_total",
-				Help: "The total number of check balancer.",
-			}, []string{"service", "name"}),
-		}
-	})
-
-	return sm
-}

rollup/internal/controller/sender/sender.go

@@ -1,26 +1,30 @@
 package sender
 
 import (
+	"bytes"
 	"context"
 	"crypto/ecdsa"
 	"errors"
 	"fmt"
 	"math/big"
 	"strings"
-	"sync/atomic"
 	"time"
 
-	cmapV2 "github.com/orcaman/concurrent-map/v2"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/scroll-tech/go-ethereum/accounts/abi/bind"
 	"github.com/scroll-tech/go-ethereum/common"
-	"github.com/scroll-tech/go-ethereum/core/types"
+	gethTypes "github.com/scroll-tech/go-ethereum/core/types"
 	"github.com/scroll-tech/go-ethereum/ethclient"
 	"github.com/scroll-tech/go-ethereum/ethclient/gethclient"
 	"github.com/scroll-tech/go-ethereum/log"
+	"github.com/scroll-tech/go-ethereum/rlp"
 	"github.com/scroll-tech/go-ethereum/rpc"
+	"gorm.io/gorm"
+
+	"scroll-tech/common/types"
 
 	"scroll-tech/rollup/internal/config"
+	"scroll-tech/rollup/internal/orm"
 	"scroll-tech/rollup/internal/utils"
 )
 
@@ -35,18 +39,12 @@ const (
 	LegacyTxType = "LegacyTx"
 )
 
-var (
-	// ErrNoAvailableAccount indicates no available account error in the account pool.
-	ErrNoAvailableAccount = errors.New("sender has no available account to send transaction")
-	// ErrFullPending sender's pending pool is full.
-	ErrFullPending = errors.New("sender's pending pool is full")
-)
-
 // Confirmation struct used to indicate transaction confirmation details
 type Confirmation struct {
-	ID           string
+	ContextID    string
 	IsSuccessful bool
 	TxHash       common.Hash
+	SenderType   types.SenderType
 }
 
 // FeeData fee struct used to estimate gas price
@@ -55,20 +53,11 @@ type FeeData struct {
 	gasTipCap *big.Int
 	gasPrice  *big.Int
 
-	accessList types.AccessList
+	accessList gethTypes.AccessList
 
 	gasLimit uint64
 }
 
-// PendingTransaction submitted but pending transactions
-type PendingTransaction struct {
-	submitAt uint64
-	id       string
-	feeData  *FeeData
-	signer   *bind.TransactOpts
-	tx       *types.Transaction
-}
-
 // Sender Transaction sender to send transaction to l1/l2 geth
 type Sender struct {
 	config     *config.SenderConfig
@@ -78,23 +67,25 @@ type Sender struct {
 	ctx        context.Context
 	service    string
 	name       string
+	senderType types.SenderType
 
-	auth       *bind.TransactOpts
-	minBalance *big.Int
+	auth *bind.TransactOpts
 
-	blockNumber   uint64                                            // Current block number on chain.
-	baseFeePerGas uint64                                            // Current base fee per gas on chain
-	pendingTxs    cmapV2.ConcurrentMap[string, *PendingTransaction] // Mapping from nonce to pending transaction
-	confirmCh     chan *Confirmation
+	db                    *gorm.DB
+	pendingTransactionOrm *orm.PendingTransaction
 
-	stopCh chan struct{}
+	confirmCh chan *Confirmation
+	stopCh    chan struct{}
 
 	metrics *senderMetrics
 }
 
 // NewSender returns a new instance of transaction sender
-// txConfirmationCh is used to notify confirmed transaction
-func NewSender(ctx context.Context, config *config.SenderConfig, priv *ecdsa.PrivateKey, service, name string, reg prometheus.Registerer) (*Sender, error) {
+func NewSender(ctx context.Context, config *config.SenderConfig, priv *ecdsa.PrivateKey, service, name string, senderType types.SenderType, db *gorm.DB, reg prometheus.Registerer) (*Sender, error) {
+	if config.EscalateMultipleNum <= config.EscalateMultipleDen {
+		return nil, fmt.Errorf("invalid params, EscalateMultipleNum; %v, EscalateMultipleDen: %v", config.EscalateMultipleNum, config.EscalateMultipleDen)
+	}
+
 	rpcClient, err := rpc.Dial(config.Endpoint)
 	if err != nil {
 		return nil, fmt.Errorf("failed to dial eth client, err: %w", err)
@@ -118,36 +109,20 @@ func NewSender(ctx context.Context, config *config.SenderConfig, priv *ecdsa.Pri
 	}
 	auth.Nonce = big.NewInt(int64(nonce))
 
-	// get header by number
-	header, err := client.HeaderByNumber(ctx, nil)
-	if err != nil {
-		return nil, fmt.Errorf("failed to get header by number, err: %w", err)
-	}
-
-	var baseFeePerGas uint64
-	if config.TxType == DynamicFeeTxType {
-		if header.BaseFee != nil {
-			baseFeePerGas = header.BaseFee.Uint64()
-		} else {
-			return nil, errors.New("dynamic fee tx type not supported: header.BaseFee is nil")
-		}
-	}
-
 	sender := &Sender{
-		ctx:           ctx,
-		config:        config,
-		gethClient:    gethclient.New(rpcClient),
-		client:        client,
-		chainID:       chainID,
-		auth:          auth,
-		minBalance:    config.MinBalance,
-		confirmCh:     make(chan *Confirmation, 128),
-		blockNumber:   header.Number.Uint64(),
-		baseFeePerGas: baseFeePerGas,
-		pendingTxs:    cmapV2.New[*PendingTransaction](),
-		stopCh:        make(chan struct{}),
-		name:          name,
-		service:       service,
+		ctx:                   ctx,
+		config:                config,
+		gethClient:            gethclient.New(rpcClient),
+		client:                client,
+		chainID:               chainID,
+		auth:                  auth,
+		db:                    db,
+		pendingTransactionOrm: orm.NewPendingTransaction(db),
+		confirmCh:             make(chan *Confirmation, 128),
+		stopCh:                make(chan struct{}),
+		name:                  name,
+		service:               service,
+		senderType:            senderType,
 	}
 	sender.metrics = initSenderMetrics(reg)
 
@@ -156,21 +131,6 @@ func NewSender(ctx context.Context, config *config.SenderConfig, priv *ecdsa.Pri
 	return sender, nil
 }
 
-// PendingCount returns the current number of pending txs.
-func (s *Sender) PendingCount() int {
-	return s.pendingTxs.Count()
-}
-
-// PendingLimit returns the maximum number of pending txs the sender can handle.
-func (s *Sender) PendingLimit() int {
-	return s.config.PendingLimit
-}
-
-// IsFull returns true if the sender's pending tx pool is full.
-func (s *Sender) IsFull() bool {
-	return s.pendingTxs.Count() >= s.config.PendingLimit
-}
-
 // GetChainID returns the chain ID associated with the sender.
 func (s *Sender) GetChainID() *big.Int {
 	return s.chainID
@@ -179,7 +139,7 @@ func (s *Sender) GetChainID() *big.Int {
 // Stop stop the sender module.
 func (s *Sender) Stop() {
 	close(s.stopCh)
-	log.Info("Transaction sender stopped")
+	log.Info("sender stopped", "name", s.name, "service", s.service, "address", s.auth.From.String())
 }
 
 // ConfirmChan channel used to communicate with transaction sender
@@ -193,40 +153,29 @@ func (s *Sender) SendConfirmation(cfm *Confirmation) {
 	s.confirmCh <- cfm
 }
 
-func (s *Sender) getFeeData(target *common.Address, value *big.Int, data []byte, fallbackGasLimit uint64) (*FeeData, error) {
+func (s *Sender) getFeeData(target *common.Address, value *big.Int, data []byte, fallbackGasLimit uint64, baseFee uint64) (*FeeData, error) {
 	if s.config.TxType == DynamicFeeTxType {
-		return s.estimateDynamicGas(target, value, data, fallbackGasLimit)
+		return s.estimateDynamicGas(target, value, data, fallbackGasLimit, baseFee)
 	}
 	return s.estimateLegacyGas(target, value, data, fallbackGasLimit)
 }
 
 // SendTransaction send a signed L2tL1 transaction.
-func (s *Sender) SendTransaction(ID string, target *common.Address, value *big.Int, data []byte, fallbackGasLimit uint64) (common.Hash, error) {
+func (s *Sender) SendTransaction(contextID string, target *common.Address, value *big.Int, data []byte, fallbackGasLimit uint64) (common.Hash, error) {
 	s.metrics.sendTransactionTotal.WithLabelValues(s.service, s.name).Inc()
-	if s.IsFull() {
-		s.metrics.sendTransactionFailureFullTx.WithLabelValues(s.service, s.name).Set(1)
-		return common.Hash{}, ErrFullPending
-	}
-
-	s.metrics.sendTransactionFailureFullTx.WithLabelValues(s.service, s.name).Set(0)
-	if ok := s.pendingTxs.SetIfAbsent(ID, nil); !ok {
-		s.metrics.sendTransactionFailureRepeatTransaction.WithLabelValues(s.service, s.name).Inc()
-		return common.Hash{}, fmt.Errorf("repeat transaction ID: %s", ID)
-	}
-
 	var (
 		feeData *FeeData
-		tx      *types.Transaction
+		tx      *gethTypes.Transaction
 		err     error
 	)
 
-	defer func() {
-		if err != nil {
-			s.pendingTxs.Remove(ID) // release the ID on failure
-		}
-	}()
+	blockNumber, baseFee, err := s.getBlockNumberAndBaseFee(s.ctx)
+	if err != nil {
+		log.Error("failed to get block number and base fee", "error", err)
+		return common.Hash{}, fmt.Errorf("failed to get block number and base fee, err: %w", err)
+	}
 
-	if feeData, err = s.getFeeData(target, value, data, fallbackGasLimit); err != nil {
+	if feeData, err = s.getFeeData(target, value, data, fallbackGasLimit, baseFee); err != nil {
 		s.metrics.sendTransactionFailureGetFee.WithLabelValues(s.service, s.name).Inc()
 		log.Error("failed to get fee data", "from", s.auth.From.String(), "nonce", s.auth.Nonce.Uint64(), "fallback gas limit", fallbackGasLimit, "err", err)
 		return common.Hash{}, fmt.Errorf("failed to get fee data, err: %w", err)
@@ -238,22 +187,17 @@ func (s *Sender) SendTransaction(ID string, target *common.Address, value *big.I
 		return common.Hash{}, fmt.Errorf("failed to create and send transaction, err: %w", err)
 	}
 
-	// add pending transaction
-	pending := &PendingTransaction{
-		tx:       tx,
-		id:       ID,
-		signer:   s.auth,
-		submitAt: atomic.LoadUint64(&s.blockNumber),
-		feeData:  feeData,
+	if err = s.pendingTransactionOrm.InsertPendingTransaction(s.ctx, contextID, s.getSenderMeta(), tx, blockNumber); err != nil {
+		log.Error("failed to insert transaction", "from", s.auth.From.String(), "nonce", s.auth.Nonce.Uint64(), "err", err)
+		return common.Hash{}, fmt.Errorf("failed to insert transaction, err: %w", err)
 	}
-	s.pendingTxs.Set(ID, pending)
 	return tx.Hash(), nil
 }
 
-func (s *Sender) createAndSendTx(feeData *FeeData, target *common.Address, value *big.Int, data []byte, overrideNonce *uint64) (*types.Transaction, error) {
+func (s *Sender) createAndSendTx(feeData *FeeData, target *common.Address, value *big.Int, data []byte, overrideNonce *uint64) (*gethTypes.Transaction, error) {
 	var (
 		nonce  = s.auth.Nonce.Uint64()
-		txData types.TxData
+		txData gethTypes.TxData
 	)
 
 	// this is a resubmit call, override the nonce
@@ -261,11 +205,10 @@ func (s *Sender) createAndSendTx(feeData *FeeData, target *common.Address, value
 		nonce = *overrideNonce
 	}
 
-	// lock here to avoit blocking when call `SuggestGasPrice`
 	switch s.config.TxType {
 	case LegacyTxType:
 		// for ganache mock node
-		txData = &types.LegacyTx{
+		txData = &gethTypes.LegacyTx{
 			Nonce:    nonce,
 			GasPrice: feeData.gasPrice,
 			Gas:      feeData.gasLimit,
@@ -277,7 +220,7 @@ func (s *Sender) createAndSendTx(feeData *FeeData, target *common.Address, value
 			S:        new(big.Int),
 		}
 	case AccessListTxType:
-		txData = &types.AccessListTx{
+		txData = &gethTypes.AccessListTx{
 			ChainID:    s.chainID,
 			Nonce:      nonce,
 			GasPrice:   feeData.gasPrice,
@@ -291,7 +234,7 @@ func (s *Sender) createAndSendTx(feeData *FeeData, target *common.Address, value
 			S:          new(big.Int),
 		}
 	default:
-		txData = &types.DynamicFeeTx{
+		txData = &gethTypes.DynamicFeeTx{
 			Nonce:      nonce,
 			To:         target,
 			Data:       common.CopyBytes(data),
@@ -308,11 +251,12 @@ func (s *Sender) createAndSendTx(feeData *FeeData, target *common.Address, value
 	}
 
 	// sign and send
-	tx, err := s.auth.Signer(s.auth.From, types.NewTx(txData))
+	tx, err := s.auth.Signer(s.auth.From, gethTypes.NewTx(txData))
 	if err != nil {
 		log.Error("failed to sign tx", "address", s.auth.From.String(), "err", err)
 		return nil, err
 	}
+
 	if err = s.client.SendTransaction(s.ctx, tx); err != nil {
 		log.Error("failed to send tx", "tx hash", tx.Hash().String(), "from", s.auth.From.String(), "nonce", tx.Nonce(), "err", err)
 		// Check if contain nonce, and reset nonce
@@ -344,7 +288,7 @@ func (s *Sender) createAndSendTx(feeData *FeeData, target *common.Address, value
 	return tx, nil
 }
 
-// reSetNonce reset nonce if send signed tx failed.
+// 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 {
@@ -354,7 +298,7 @@ func (s *Sender) resetNonce(ctx context.Context) {
 	s.auth.Nonce = big.NewInt(int64(nonce))
 }
 
-func (s *Sender) resubmitTransaction(feeData *FeeData, auth *bind.TransactOpts, tx *types.Transaction) (*types.Transaction, error) {
+func (s *Sender) resubmitTransaction(auth *bind.TransactOpts, tx *gethTypes.Transaction, baseFee uint64) (*gethTypes.Transaction, error) {
 	escalateMultipleNum := new(big.Int).SetUint64(s.config.EscalateMultipleNum)
 	escalateMultipleDen := new(big.Int).SetUint64(s.config.EscalateMultipleDen)
 	maxGasPrice := new(big.Int).SetUint64(s.config.MaxGasPrice)
@@ -366,14 +310,13 @@ func (s *Sender) resubmitTransaction(feeData *FeeData, auth *bind.TransactOpts,
 		"nonce":   tx.Nonce(),
 	}
 
+	var feeData FeeData
+	feeData.gasLimit = tx.Gas()
 	switch s.config.TxType {
 	case LegacyTxType, AccessListTxType: // `LegacyTxType`is for ganache mock node
-		originalGasPrice := feeData.gasPrice
-		gasPrice := escalateMultipleNum.Mul(escalateMultipleNum, big.NewInt(feeData.gasPrice.Int64()))
+		originalGasPrice := tx.GasPrice()
+		gasPrice := new(big.Int).Mul(escalateMultipleNum, originalGasPrice)
 		gasPrice = gasPrice.Div(gasPrice, escalateMultipleDen)
-		if gasPrice.Cmp(feeData.gasPrice) < 0 {
-			gasPrice = feeData.gasPrice
-		}
 		if gasPrice.Cmp(maxGasPrice) > 0 {
 			gasPrice = maxGasPrice
 		}
@@ -387,27 +330,16 @@ func (s *Sender) resubmitTransaction(feeData *FeeData, auth *bind.TransactOpts,
 		txInfo["original_gas_price"] = originalGasPrice.Uint64()
 		txInfo["adjusted_gas_price"] = gasPrice.Uint64()
 	default:
-		originalGasTipCap := big.NewInt(feeData.gasTipCap.Int64())
-		originalGasFeeCap := big.NewInt(feeData.gasFeeCap.Int64())
+		originalGasTipCap := tx.GasTipCap()
+		originalGasFeeCap := tx.GasFeeCap()
 
-		gasTipCap := big.NewInt(feeData.gasTipCap.Int64())
-		gasTipCap = gasTipCap.Mul(gasTipCap, escalateMultipleNum)
+		gasTipCap := new(big.Int).Mul(originalGasTipCap, escalateMultipleNum)
 		gasTipCap = gasTipCap.Div(gasTipCap, escalateMultipleDen)
-		gasFeeCap := big.NewInt(feeData.gasFeeCap.Int64())
-		gasFeeCap = gasFeeCap.Mul(gasFeeCap, escalateMultipleNum)
+		gasFeeCap := new(big.Int).Mul(originalGasFeeCap, escalateMultipleNum)
 		gasFeeCap = gasFeeCap.Div(gasFeeCap, escalateMultipleDen)
-		if gasFeeCap.Cmp(feeData.gasFeeCap) < 0 {
-			gasFeeCap = feeData.gasFeeCap
-		}
-		if gasTipCap.Cmp(feeData.gasTipCap) < 0 {
-			gasTipCap = feeData.gasTipCap
-		}
 
 		// adjust for rising basefee
-		adjBaseFee := big.NewInt(0)
-		if feeGas := atomic.LoadUint64(&s.baseFeePerGas); feeGas != 0 {
-			adjBaseFee.SetUint64(feeGas)
-		}
+		adjBaseFee := new(big.Int).SetUint64(baseFee)
 		adjBaseFee = adjBaseFee.Mul(adjBaseFee, escalateMultipleNum)
 		adjBaseFee = adjBaseFee.Div(adjBaseFee, escalateMultipleDen)
 		currentGasFeeCap := new(big.Int).Add(gasTipCap, adjBaseFee)
@@ -420,6 +352,11 @@ func (s *Sender) resubmitTransaction(feeData *FeeData, auth *bind.TransactOpts,
 			gasFeeCap = maxGasPrice
 		}
 
+		// gasTipCap <= gasFeeCap
+		if gasTipCap.Cmp(gasFeeCap) > 0 {
+			gasTipCap = gasFeeCap
+		}
+
 		if originalGasTipCap.Cmp(gasTipCap) == 0 {
 			log.Warn("gas tip cap bump corner case, add 1 wei", "original", originalGasTipCap.Uint64(), "adjusted", gasTipCap.Uint64())
 			gasTipCap = new(big.Int).Add(gasTipCap, big.NewInt(1))
@@ -438,11 +375,11 @@ func (s *Sender) resubmitTransaction(feeData *FeeData, auth *bind.TransactOpts,
 		txInfo["adjusted_gas_fee_cap"] = gasFeeCap.Uint64()
 	}
 
-	log.Info("Transaction gas adjustment details", txInfo)
+	log.Info("Transaction gas adjustment details", "txInfo", txInfo)
 
 	nonce := tx.Nonce()
 	s.metrics.resubmitTransactionTotal.WithLabelValues(s.service, s.name).Inc()
-	tx, err := s.createAndSendTx(feeData, tx.To(), tx.Value(), tx.Data(), &nonce)
+	tx, err := s.createAndSendTx(&feeData, tx.To(), tx.Value(), tx.Data(), &nonce)
 	if err != nil {
 		log.Error("failed to create and send tx (resubmit case)", "from", s.auth.From.String(), "nonce", nonce, "err", err)
 		return nil, err
@@ -452,137 +389,116 @@ func (s *Sender) resubmitTransaction(feeData *FeeData, auth *bind.TransactOpts,
 
 // checkPendingTransaction checks the confirmation status of pending transactions against the latest confirmed block number.
 // If a transaction hasn't been confirmed after a certain number of blocks, it will be resubmitted with an increased gas price.
-func (s *Sender) checkPendingTransaction(header *types.Header, confirmed uint64) {
-	number := header.Number.Uint64()
-	atomic.StoreUint64(&s.blockNumber, number)
+func (s *Sender) checkPendingTransaction() {
+	s.metrics.senderCheckPendingTransactionTotal.WithLabelValues(s.service, s.name).Inc()
 
-	if s.config.TxType == DynamicFeeTxType {
-		if header.BaseFee != nil {
-			atomic.StoreUint64(&s.baseFeePerGas, header.BaseFee.Uint64())
-		} else {
-			log.Error("DynamicFeeTxType not supported, header.BaseFee nil")
-		}
+	blockNumber, baseFee, err := s.getBlockNumberAndBaseFee(s.ctx)
+	if err != nil {
+		log.Error("failed to get block number and base fee", "error", err)
+		return
 	}
 
-	for item := range s.pendingTxs.IterBuffered() {
-		key, pending := item.Key, item.Val
-		// ignore empty id, since we use empty id to occupy pending task
-		if pending == nil {
+	transactionsToCheck, err := s.pendingTransactionOrm.GetPendingOrReplacedTransactionsBySenderType(s.ctx, s.senderType, 100)
+	if err != nil {
+		log.Error("failed to load pending transactions", "sender meta", s.getSenderMeta(), "err", err)
+		return
+	}
+
+	confirmed, err := utils.GetLatestConfirmedBlockNumber(s.ctx, s.client, s.config.Confirmations)
+	if err != nil {
+		log.Error("failed to get latest confirmed block number", "confirmations", s.config.Confirmations, "err", err)
+		return
+	}
+
+	for _, txnToCheck := range transactionsToCheck {
+		tx := new(gethTypes.Transaction)
+		if err := tx.DecodeRLP(rlp.NewStream(bytes.NewReader(txnToCheck.RLPEncoding), 0)); err != nil {
+			log.Error("failed to decode RLP", "context ID", txnToCheck.ContextID, "sender meta", s.getSenderMeta(), "err", err)
 			continue
 		}
 
-		receipt, err := s.client.TransactionReceipt(s.ctx, pending.tx.Hash())
-		if (err == nil) && (receipt != nil) {
+		receipt, err := s.client.TransactionReceipt(s.ctx, tx.Hash())
+		if (err == nil) && (receipt != nil) { // tx confirmed.
 			if receipt.BlockNumber.Uint64() <= confirmed {
-				s.pendingTxs.Remove(key)
+				err := s.db.Transaction(func(dbTX *gorm.DB) error {
+					// Update the status of the transaction to TxStatusConfirmed.
+					if err := s.pendingTransactionOrm.UpdatePendingTransactionStatusByTxHash(s.ctx, tx.Hash(), types.TxStatusConfirmed, dbTX); err != nil {
+						log.Error("failed to update transaction status by tx hash", "hash", tx.Hash().String(), "sender meta", s.getSenderMeta(), "from", s.auth.From.String(), "nonce", tx.Nonce(), "err", err)
+						return err
+					}
+					// Update other transactions with the same nonce and sender address as failed.
+					if err := s.pendingTransactionOrm.UpdateOtherTransactionsAsFailedByNonce(s.ctx, txnToCheck.SenderAddress, tx.Nonce(), tx.Hash(), dbTX); err != nil {
+						log.Error("failed to update other transactions as failed by nonce", "senderAddress", txnToCheck.SenderAddress, "nonce", tx.Nonce(), "excludedTxHash", tx.Hash(), "err", err)
+						return err
+					}
+					return nil
+				})
+				if err != nil {
+					log.Error("db transaction failed", "err", err)
+				}
+
 				// send confirm message
 				s.confirmCh <- &Confirmation{
-					ID:           pending.id,
-					IsSuccessful: receipt.Status == types.ReceiptStatusSuccessful,
-					TxHash:       pending.tx.Hash(),
+					ContextID:    txnToCheck.ContextID,
+					IsSuccessful: receipt.Status == gethTypes.ReceiptStatusSuccessful,
+					TxHash:       tx.Hash(),
+					SenderType:   s.senderType,
 				}
 			}
-		} else if s.config.EscalateBlocks+pending.submitAt < number {
-			log.Info("resubmit transaction",
-				"hash", pending.tx.Hash().String(),
-				"from", pending.signer.From.String(),
-				"nonce", pending.tx.Nonce(),
-				"submit block number", pending.submitAt,
-				"current block number", number,
-				"configured escalateBlocks", s.config.EscalateBlocks)
+		} else if txnToCheck.Status == types.TxStatusPending && // Only try resubmitting a new transaction based on gas price of the last transaction (status pending) with same ContextID.
+			s.config.EscalateBlocks+txnToCheck.SubmitBlockNumber <= blockNumber {
+			// It's possible that the pending transaction was marked as failed earlier in this loop (e.g., if one of its replacements has already been confirmed).
+			// Therefore, we fetch the current transaction status again for accuracy before proceeding.
+			status, err := s.pendingTransactionOrm.GetTxStatusByTxHash(s.ctx, tx.Hash())
+			if err != nil {
+				log.Error("failed to get transaction status by tx hash", "hash", tx.Hash().String(), "err", err)
+				return
+			}
+			if status == types.TxStatusConfirmedFailed {
+				log.Warn("transaction already marked as failed, skipping resubmission", "hash", tx.Hash().String())
+				return
+			}
 
-			if tx, err := s.resubmitTransaction(pending.feeData, pending.signer, pending.tx); err != nil {
-				// If account pool is empty, it will try again in next loop.
-				if !errors.Is(err, ErrNoAvailableAccount) {
-					log.Error("failed to resubmit transaction, reset submitAt", "tx hash", pending.tx.Hash().String(), "err", err)
-				}
-				// This means one of the old transactions is confirmed
-				// One scenario is
-				//   1. Initially, we replace the tx three times and submit it to local node.
-				//      Currently, we keep the last tx hash in the memory.
-				//   2. Other node packed the 2-nd tx or 3-rd tx, and the local node has received the block now.
-				//   3. When we resubmit the 4-th tx, we got a nonce error.
-				//   4. We need to check the status of 3-rd tx stored in our memory
-				//     4.1 If the 3-rd tx is packed, we got a receipt and 3-nd is marked as confirmed.
-				//     4.2 If the 2-nd tx is packed, we got nothing from `TransactionReceipt` call. Since we
-				//         cannot do  anything about, we just log some information. In this case, the caller
-				//         of `sender.SendTransaction` should write extra code to handle the situation.
-				// Another scenario is private key leaking and someone send a transaction with the same nonce.
-				// We need to stop the program and manually handle the situation.
-				if strings.Contains(err.Error(), "nonce") {
-					// This key can be deleted
-					s.pendingTxs.Remove(key)
-					// Try get receipt by the latest replaced tx hash
-					receipt, err := s.client.TransactionReceipt(s.ctx, pending.tx.Hash())
-					if (err == nil) && (receipt != nil) {
-						// send confirm message
-						s.confirmCh <- &Confirmation{
-							ID:           pending.id,
-							IsSuccessful: receipt.Status == types.ReceiptStatusSuccessful,
-							TxHash:       pending.tx.Hash(),
-						}
-					} else {
-						// The receipt can be nil since the confirmed transaction may not be the latest one.
-						// We just ignore it, the caller of the sender pool should handle this situation.
-						log.Warn("Pending transaction is confirmed by one of the replaced transactions", "key", key, "signer", pending.signer.From, "nonce", pending.tx.Nonce())
-					}
-				}
+			log.Info("resubmit transaction",
+				"hash", tx.Hash().String(),
+				"from", s.auth.From.String(),
+				"nonce", tx.Nonce(),
+				"submitBlockNumber", txnToCheck.SubmitBlockNumber,
+				"currentBlockNumber", blockNumber,
+				"escalateBlocks", s.config.EscalateBlocks)
+
+			if newTx, err := s.resubmitTransaction(s.auth, tx, baseFee); err != nil {
+				s.metrics.resubmitTransactionFailedTotal.WithLabelValues(s.service, s.name).Inc()
+				log.Error("failed to resubmit transaction", "context ID", txnToCheck.ContextID, "sender meta", s.getSenderMeta(), "from", s.auth.From.String(), "nonce", newTx.Nonce(), "err", err)
 			} else {
-				// flush submitAt
-				pending.tx = tx
-				pending.submitAt = number
+				err := s.db.Transaction(func(dbTX *gorm.DB) error {
+					// Update the status of the original transaction as replaced, while still checking its confirmation status.
+					if err := s.pendingTransactionOrm.UpdatePendingTransactionStatusByTxHash(s.ctx, tx.Hash(), types.TxStatusReplaced, dbTX); err != nil {
+						return fmt.Errorf("failed to update status of transaction with hash %s to TxStatusReplaced, err: %w", tx.Hash().String(), err)
+					}
+					// Record the new transaction that has replaced the original one.
+					if err := s.pendingTransactionOrm.InsertPendingTransaction(s.ctx, txnToCheck.ContextID, s.getSenderMeta(), newTx, txnToCheck.SubmitBlockNumber, dbTX); err != nil {
+						return fmt.Errorf("failed to insert new pending transaction with context ID: %s, nonce: %d, hash: %v, err: %w", txnToCheck.ContextID, newTx.Nonce(), newTx.Hash().String(), err)
+					}
+					return nil
+				})
+				if err != nil {
+					log.Error("db transaction failed", "err", err)
+				}
 			}
 		}
 	}
 }
 
-// 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, address: %s",
-			bls.String(), s.minBalance.String(), s.auth.From.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)
 	defer checkTick.Stop()
 
-	checkBalanceTicker := time.NewTicker(time.Duration(s.config.CheckBalanceTime) * time.Second)
-	defer checkBalanceTicker.Stop()
-
 	for {
 		select {
 		case <-checkTick.C:
-			s.metrics.senderCheckPendingTransactionTotal.WithLabelValues(s.service, s.name).Inc()
-			header, err := s.client.HeaderByNumber(s.ctx, nil)
-			if err != nil {
-				log.Error("failed to get latest head", "err", err)
-				continue
-			}
-
-			confirmed, err := utils.GetLatestConfirmedBlockNumber(s.ctx, s.client, s.config.Confirmations)
-			if err != nil {
-				log.Error("failed to get latest confirmed block number", "err", err)
-				continue
-			}
-
-			s.checkPendingTransaction(header, confirmed)
-		case <-checkBalanceTicker.C:
-			s.metrics.senderCheckBalancerTotal.WithLabelValues(s.service, s.name).Inc()
-			// Check and set balance.
-			if err := s.checkBalance(ctx); err != nil {
-				log.Error("check balance error", "err", err)
-			}
+			s.checkPendingTransaction()
 		case <-ctx.Done():
 			return
 		case <-s.stopCh:
@@ -590,3 +506,29 @@ func (s *Sender) loop(ctx context.Context) {
 		}
 	}
 }
+
+func (s *Sender) getSenderMeta() *orm.SenderMeta {
+	return &orm.SenderMeta{
+		Name:    s.name,
+		Service: s.service,
+		Address: s.auth.From,
+		Type:    s.senderType,
+	}
+}
+
+func (s *Sender) getBlockNumberAndBaseFee(ctx context.Context) (uint64, uint64, error) {
+	header, err := s.client.HeaderByNumber(ctx, nil)
+	if err != nil {
+		return 0, 0, fmt.Errorf("failed to get header by number, err: %w", err)
+	}
+
+	var baseFeePerGas uint64
+	if s.config.TxType == DynamicFeeTxType {
+		if header.BaseFee != nil {
+			baseFeePerGas = header.BaseFee.Uint64()
+		} else {
+			return 0, 0, errors.New("dynamic fee tx type not supported: header.BaseFee is nil")
+		}
+	}
+	return header.Number.Uint64(), baseFeePerGas, nil
+}

rollup/internal/controller/sender/sender_metrics.go

@@ -0,0 +1,75 @@
+package sender
+
+import (
+	"sync"
+
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promauto"
+)
+
+type senderMetrics struct {
+	senderCheckPendingTransactionTotal *prometheus.CounterVec
+	sendTransactionTotal               *prometheus.CounterVec
+	sendTransactionFailureGetFee       *prometheus.CounterVec
+	sendTransactionFailureSendTx       *prometheus.CounterVec
+	resubmitTransactionTotal           *prometheus.CounterVec
+	resubmitTransactionFailedTotal     *prometheus.CounterVec
+	currentGasFeeCap                   *prometheus.GaugeVec
+	currentGasTipCap                   *prometheus.GaugeVec
+	currentGasPrice                    *prometheus.GaugeVec
+	currentGasLimit                    *prometheus.GaugeVec
+}
+
+var (
+	initSenderMetricOnce sync.Once
+	sm                   *senderMetrics
+)
+
+func initSenderMetrics(reg prometheus.Registerer) *senderMetrics {
+	initSenderMetricOnce.Do(func() {
+		sm = &senderMetrics{
+			sendTransactionTotal: promauto.With(reg).NewCounterVec(prometheus.CounterOpts{
+				Name: "rollup_sender_send_transaction_total",
+				Help: "The total number of sending transactions.",
+			}, []string{"service", "name"}),
+			sendTransactionFailureGetFee: promauto.With(reg).NewCounterVec(prometheus.CounterOpts{
+				Name: "rollup_sender_send_transaction_get_fee_failure_total",
+				Help: "The total number of sending transactions failure for getting fee.",
+			}, []string{"service", "name"}),
+			sendTransactionFailureSendTx: promauto.With(reg).NewCounterVec(prometheus.CounterOpts{
+				Name: "rollup_sender_send_transaction_send_tx_failure_total",
+				Help: "The total number of sending transactions failure for sending tx.",
+			}, []string{"service", "name"}),
+			resubmitTransactionTotal: promauto.With(reg).NewCounterVec(prometheus.CounterOpts{
+				Name: "rollup_sender_send_transaction_resubmit_send_transaction_total",
+				Help: "The total number of resubmit transactions.",
+			}, []string{"service", "name"}),
+			resubmitTransactionFailedTotal: promauto.With(reg).NewCounterVec(prometheus.CounterOpts{
+				Name: "rollup_sender_send_transaction_resubmit_send_transaction_failed_total",
+				Help: "The total number of failed resubmit transactions.",
+			}, []string{"service", "name"}),
+			currentGasFeeCap: promauto.With(reg).NewGaugeVec(prometheus.GaugeOpts{
+				Name: "rollup_sender_gas_fee_cap",
+				Help: "The gas fee cap of current transaction.",
+			}, []string{"service", "name"}),
+			currentGasTipCap: promauto.With(reg).NewGaugeVec(prometheus.GaugeOpts{
+				Name: "rollup_sender_gas_tip_cap",
+				Help: "The gas tip cap of current transaction.",
+			}, []string{"service", "name"}),
+			currentGasPrice: promauto.With(reg).NewGaugeVec(prometheus.GaugeOpts{
+				Name: "rollup_sender_gas_price_cap",
+				Help: "The gas price of current transaction.",
+			}, []string{"service", "name"}),
+			currentGasLimit: promauto.With(reg).NewGaugeVec(prometheus.GaugeOpts{
+				Name: "rollup_sender_gas_limit",
+				Help: "The gas limit of current transaction.",
+			}, []string{"service", "name"}),
+			senderCheckPendingTransactionTotal: promauto.With(reg).NewCounterVec(prometheus.CounterOpts{
+				Name: "rollup_sender_check_pending_transaction_total",
+				Help: "The total number of check pending transaction.",
+			}, []string{"service", "name"}),
+		}
+	})
+
+	return sm
+}

rollup/internal/controller/sender/sender_test.go

@@ -4,37 +4,41 @@ import (
 	"context"
 	"crypto/ecdsa"
 	"errors"
+	"fmt"
 	"math/big"
 	"os"
-	"strconv"
 	"testing"
 
 	"github.com/agiledragon/gomonkey/v2"
 	"github.com/scroll-tech/go-ethereum/accounts/abi/bind"
 	"github.com/scroll-tech/go-ethereum/common"
-	"github.com/scroll-tech/go-ethereum/core/types"
+	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"
 	"github.com/scroll-tech/go-ethereum/rpc"
 	"github.com/stretchr/testify/assert"
+	"gorm.io/gorm"
 
+	"scroll-tech/common/database"
 	"scroll-tech/common/docker"
+	"scroll-tech/common/types"
+	"scroll-tech/database/migrate"
 
 	bridgeAbi "scroll-tech/rollup/abi"
-	"scroll-tech/rollup/mock_bridge"
-
 	"scroll-tech/rollup/internal/config"
+	"scroll-tech/rollup/mock_bridge"
 )
 
 const TXBatch = 50
 
 var (
-	privateKey         *ecdsa.PrivateKey
-	cfg                *config.Config
-	base               *docker.App
-	txTypes            = []string{"LegacyTx", "AccessListTx", "DynamicFeeTx"}
-	scrollChainAddress common.Address
+	privateKey             *ecdsa.PrivateKey
+	cfg                    *config.Config
+	base                   *docker.App
+	txTypes                = []string{"LegacyTx", "AccessListTx", "DynamicFeeTx"}
+	db                     *gorm.DB
+	mockL1ContractsAddress common.Address
 )
 
 func TestMain(m *testing.M) {
@@ -53,14 +57,26 @@ func setupEnv(t *testing.T) {
 	var err error
 	cfg, err = config.NewConfig("../../../conf/config.json")
 	assert.NoError(t, err)
-	base.RunL1Geth(t)
 	priv, err := crypto.HexToECDSA("1212121212121212121212121212121212121212121212121212121212121212")
 	assert.NoError(t, err)
-	// Load default private key.
 	privateKey = priv
 
+	base.RunL1Geth(t)
 	cfg.L1Config.RelayerConfig.SenderConfig.Endpoint = base.L1gethImg.Endpoint()
-	cfg.L1Config.RelayerConfig.SenderConfig.CheckBalanceTime = 1
+
+	base.RunDBImage(t)
+	db, err = database.InitDB(
+		&database.Config{
+			DSN:        base.DBConfig.DSN,
+			DriverName: base.DBConfig.DriverName,
+			MaxOpenNum: base.DBConfig.MaxOpenNum,
+			MaxIdleNum: base.DBConfig.MaxIdleNum,
+		},
+	)
+	assert.NoError(t, err)
+	sqlDB, err := db.DB()
+	assert.NoError(t, err)
+	assert.NoError(t, migrate.ResetDB(sqlDB))
 
 	auth, err := bind.NewKeyedTransactorWithChainID(privateKey, base.L1gethImg.ChainID())
 	assert.NoError(t, err)
@@ -71,7 +87,7 @@ func setupEnv(t *testing.T) {
 	_, tx, _, err := mock_bridge.DeployMockBridgeL1(auth, l1Client)
 	assert.NoError(t, err)
 
-	scrollChainAddress, err = bind.WaitDeployed(context.Background(), l1Client, tx)
+	mockL1ContractsAddress, err = bind.WaitDeployed(context.Background(), l1Client, tx)
 	assert.NoError(t, err)
 }
 
@@ -80,22 +96,28 @@ func TestSender(t *testing.T) {
 	setupEnv(t)
 
 	t.Run("test new sender", testNewSender)
-	t.Run("test pending limit", testPendLimit)
 	t.Run("test fallback gas limit", testFallbackGasLimit)
+	t.Run("test send and retrieve transaction", testSendAndRetrieveTransaction)
 	t.Run("test access list transaction gas limit", testAccessListTransactionGasLimit)
 	t.Run("test resubmit zero gas price transaction", testResubmitZeroGasPriceTransaction)
 	t.Run("test resubmit non-zero gas price transaction", testResubmitNonZeroGasPriceTransaction)
 	t.Run("test resubmit under priced transaction", testResubmitUnderpricedTransaction)
 	t.Run("test resubmit transaction with rising base fee", testResubmitTransactionWithRisingBaseFee)
-	t.Run("test check pending transaction", testCheckPendingTransaction)
+	t.Run("test check pending transaction tx confirmed", testCheckPendingTransactionTxConfirmed)
+	t.Run("test check pending transaction resubmit tx confirmed", testCheckPendingTransactionResubmitTxConfirmed)
+	t.Run("test check pending transaction replaced tx confirmed", testCheckPendingTransactionReplacedTxConfirmed)
 }
 
 func testNewSender(t *testing.T) {
 	for _, txType := range txTypes {
+		sqlDB, err := db.DB()
+		assert.NoError(t, err)
+		assert.NoError(t, migrate.ResetDB(sqlDB))
+
 		// exit by Stop()
 		cfgCopy1 := *cfg.L1Config.RelayerConfig.SenderConfig
 		cfgCopy1.TxType = txType
-		newSender1, err := NewSender(context.Background(), &cfgCopy1, privateKey, "test", "test", nil)
+		newSender1, err := NewSender(context.Background(), &cfgCopy1, privateKey, "test", "test", types.SenderTypeUnknown, db, nil)
 		assert.NoError(t, err)
 		newSender1.Stop()
 
@@ -103,43 +125,57 @@ func testNewSender(t *testing.T) {
 		cfgCopy2 := *cfg.L1Config.RelayerConfig.SenderConfig
 		cfgCopy2.TxType = txType
 		subCtx, cancel := context.WithCancel(context.Background())
-		_, err = NewSender(subCtx, &cfgCopy2, privateKey, "test", "test", nil)
+		_, err = NewSender(subCtx, &cfgCopy2, privateKey, "test", "test", types.SenderTypeUnknown, db, nil)
 		assert.NoError(t, err)
 		cancel()
 	}
 }
 
-func testPendLimit(t *testing.T) {
-	for _, txType := range txTypes {
+func testSendAndRetrieveTransaction(t *testing.T) {
+	for i, txType := range txTypes {
+		sqlDB, err := db.DB()
+		assert.NoError(t, err)
+		assert.NoError(t, migrate.ResetDB(sqlDB))
+
 		cfgCopy := *cfg.L1Config.RelayerConfig.SenderConfig
 		cfgCopy.TxType = txType
-		cfgCopy.Confirmations = rpc.LatestBlockNumber
-		cfgCopy.PendingLimit = 2
-		newSender, err := NewSender(context.Background(), &cfgCopy, privateKey, "test", "test", nil)
+		s, err := NewSender(context.Background(), &cfgCopy, privateKey, "test", "test", types.SenderTypeUnknown, db, nil)
 		assert.NoError(t, err)
 
-		for i := 0; i < 2*newSender.PendingLimit(); i++ {
-			_, err = newSender.SendTransaction(strconv.Itoa(i), &common.Address{}, big.NewInt(1), nil, 0)
-			assert.True(t, err == nil || (err != nil && err.Error() == "sender's pending pool is full"))
-		}
-		assert.True(t, newSender.PendingCount() <= newSender.PendingLimit())
-		newSender.Stop()
+		hash, err := s.SendTransaction("0", &common.Address{}, big.NewInt(0), nil, 0)
+		assert.NoError(t, err)
+		txs, err := s.pendingTransactionOrm.GetPendingOrReplacedTransactionsBySenderType(context.Background(), s.senderType, 1)
+		assert.NoError(t, err)
+		assert.Len(t, txs, 1)
+		assert.Equal(t, "0", txs[0].ContextID)
+		assert.Equal(t, hash.String(), txs[0].Hash)
+		assert.Equal(t, uint8(i), txs[0].Type)
+		assert.Equal(t, types.TxStatusPending, txs[0].Status)
+		assert.Equal(t, "0x1C5A77d9FA7eF466951B2F01F724BCa3A5820b63", txs[0].SenderAddress)
+		assert.Equal(t, types.SenderTypeUnknown, txs[0].SenderType)
+		assert.Equal(t, "test", txs[0].SenderService)
+		assert.Equal(t, "test", txs[0].SenderName)
+		s.Stop()
 	}
 }
 
 func testFallbackGasLimit(t *testing.T) {
 	for _, txType := range txTypes {
+		sqlDB, err := db.DB()
+		assert.NoError(t, err)
+		assert.NoError(t, migrate.ResetDB(sqlDB))
+
 		cfgCopy := *cfg.L1Config.RelayerConfig.SenderConfig
 		cfgCopy.TxType = txType
 		cfgCopy.Confirmations = rpc.LatestBlockNumber
-		s, err := NewSender(context.Background(), &cfgCopy, privateKey, "test", "test", nil)
+		s, err := NewSender(context.Background(), &cfgCopy, privateKey, "test", "test", types.SenderTypeUnknown, db, nil)
 		assert.NoError(t, err)
 
 		client, err := ethclient.Dial(cfgCopy.Endpoint)
 		assert.NoError(t, err)
 
 		// FallbackGasLimit = 0
-		txHash0, err := s.SendTransaction("0", &common.Address{}, big.NewInt(1), nil, 0)
+		txHash0, err := s.SendTransaction("0", &common.Address{}, big.NewInt(0), nil, 0)
 		assert.NoError(t, err)
 		tx0, _, err := client.TransactionByHash(context.Background(), txHash0)
 		assert.NoError(t, err)
@@ -147,12 +183,12 @@ func testFallbackGasLimit(t *testing.T) {
 
 		// FallbackGasLimit = 100000
 		patchGuard := gomonkey.ApplyPrivateMethod(s, "estimateGasLimit",
-			func(contract *common.Address, input []byte, gasPrice, gasTipCap, gasFeeCap, value *big.Int) (uint64, *types.AccessList, error) {
+			func(contract *common.Address, data []byte, gasPrice, gasTipCap, gasFeeCap, value *big.Int) (uint64, *gethTypes.AccessList, error) {
 				return 0, nil, errors.New("estimateGasLimit error")
 			},
 		)
 
-		txHash1, err := s.SendTransaction("1", &common.Address{}, big.NewInt(1), nil, 100000)
+		txHash1, err := s.SendTransaction("1", &common.Address{}, big.NewInt(0), nil, 100000)
 		assert.NoError(t, err)
 		tx1, _, err := client.TransactionByHash(context.Background(), txHash1)
 		assert.NoError(t, err)
@@ -165,9 +201,13 @@ func testFallbackGasLimit(t *testing.T) {
 
 func testResubmitZeroGasPriceTransaction(t *testing.T) {
 	for _, txType := range txTypes {
+		sqlDB, err := db.DB()
+		assert.NoError(t, err)
+		assert.NoError(t, migrate.ResetDB(sqlDB))
+
 		cfgCopy := *cfg.L1Config.RelayerConfig.SenderConfig
 		cfgCopy.TxType = txType
-		s, err := NewSender(context.Background(), &cfgCopy, privateKey, "test", "test", nil)
+		s, err := NewSender(context.Background(), &cfgCopy, privateKey, "test", "test", types.SenderTypeUnknown, db, nil)
 		assert.NoError(t, err)
 		feeData := &FeeData{
 			gasPrice:  big.NewInt(0),
@@ -179,7 +219,7 @@ func testResubmitZeroGasPriceTransaction(t *testing.T) {
 		assert.NoError(t, err)
 		assert.NotNil(t, tx)
 		// Increase at least 1 wei in gas price, gas tip cap and gas fee cap.
-		_, err = s.resubmitTransaction(feeData, s.auth, tx)
+		_, err = s.resubmitTransaction(s.auth, tx, 0)
 		assert.NoError(t, err)
 		s.Stop()
 	}
@@ -187,9 +227,13 @@ func testResubmitZeroGasPriceTransaction(t *testing.T) {
 
 func testAccessListTransactionGasLimit(t *testing.T) {
 	for _, txType := range txTypes {
+		sqlDB, err := db.DB()
+		assert.NoError(t, err)
+		assert.NoError(t, migrate.ResetDB(sqlDB))
+
 		cfgCopy := *cfg.L1Config.RelayerConfig.SenderConfig
 		cfgCopy.TxType = txType
-		s, err := NewSender(context.Background(), &cfgCopy, privateKey, "test", "test", nil)
+		s, err := NewSender(context.Background(), &cfgCopy, privateKey, "test", "test", types.SenderTypeUnknown, db, nil)
 		assert.NoError(t, err)
 
 		l2GasOracleABI, err := bridgeAbi.L2GasPriceOracleMetaData.GetAbi()
@@ -198,12 +242,12 @@ func testAccessListTransactionGasLimit(t *testing.T) {
 		data, err := l2GasOracleABI.Pack("setL2BaseFee", big.NewInt(2333))
 		assert.NoError(t, err)
 
-		gasLimit, accessList, err := s.estimateGasLimit(&scrollChainAddress, data, big.NewInt(100000000000), big.NewInt(100000000000), big.NewInt(100000000000), big.NewInt(0), true)
+		gasLimit, accessList, err := s.estimateGasLimit(&mockL1ContractsAddress, data, big.NewInt(100000000000), big.NewInt(100000000000), big.NewInt(100000000000), big.NewInt(0), true)
 		assert.NoError(t, err)
 		assert.Equal(t, uint64(43472), gasLimit)
 		assert.NotNil(t, accessList)
 
-		gasLimit, accessList, err = s.estimateGasLimit(&scrollChainAddress, data, big.NewInt(100000000000), big.NewInt(100000000000), big.NewInt(100000000000), big.NewInt(0), false)
+		gasLimit, accessList, err = s.estimateGasLimit(&mockL1ContractsAddress, data, big.NewInt(100000000000), big.NewInt(100000000000), big.NewInt(100000000000), big.NewInt(0), false)
 		assert.NoError(t, err)
 		assert.Equal(t, uint64(43949), gasLimit)
 		assert.Nil(t, accessList)
@@ -214,12 +258,16 @@ func testAccessListTransactionGasLimit(t *testing.T) {
 
 func testResubmitNonZeroGasPriceTransaction(t *testing.T) {
 	for _, txType := range txTypes {
+		sqlDB, err := db.DB()
+		assert.NoError(t, err)
+		assert.NoError(t, migrate.ResetDB(sqlDB))
+
 		cfgCopy := *cfg.L1Config.RelayerConfig.SenderConfig
 		// Bump gas price, gas tip cap and gas fee cap just touch the minimum threshold of 10% (default config of geth).
 		cfgCopy.EscalateMultipleNum = 110
 		cfgCopy.EscalateMultipleDen = 100
 		cfgCopy.TxType = txType
-		s, err := NewSender(context.Background(), &cfgCopy, privateKey, "test", "test", nil)
+		s, err := NewSender(context.Background(), &cfgCopy, privateKey, "test", "test", types.SenderTypeUnknown, db, nil)
 		assert.NoError(t, err)
 		feeData := &FeeData{
 			gasPrice:  big.NewInt(100000),
@@ -230,7 +278,7 @@ func testResubmitNonZeroGasPriceTransaction(t *testing.T) {
 		tx, err := s.createAndSendTx(feeData, &common.Address{}, big.NewInt(0), nil, nil)
 		assert.NoError(t, err)
 		assert.NotNil(t, tx)
-		_, err = s.resubmitTransaction(feeData, s.auth, tx)
+		_, err = s.resubmitTransaction(s.auth, tx, 0)
 		assert.NoError(t, err)
 		s.Stop()
 	}
@@ -238,12 +286,16 @@ func testResubmitNonZeroGasPriceTransaction(t *testing.T) {
 
 func testResubmitUnderpricedTransaction(t *testing.T) {
 	for _, txType := range txTypes {
+		sqlDB, err := db.DB()
+		assert.NoError(t, err)
+		assert.NoError(t, migrate.ResetDB(sqlDB))
+
 		cfgCopy := *cfg.L1Config.RelayerConfig.SenderConfig
 		// Bump gas price, gas tip cap and gas fee cap less than 10% (default config of geth).
 		cfgCopy.EscalateMultipleNum = 109
 		cfgCopy.EscalateMultipleDen = 100
 		cfgCopy.TxType = txType
-		s, err := NewSender(context.Background(), &cfgCopy, privateKey, "test", "test", nil)
+		s, err := NewSender(context.Background(), &cfgCopy, privateKey, "test", "test", types.SenderTypeUnknown, db, nil)
 		assert.NoError(t, err)
 		feeData := &FeeData{
 			gasPrice:  big.NewInt(100000),
@@ -254,27 +306,29 @@ func testResubmitUnderpricedTransaction(t *testing.T) {
 		tx, err := s.createAndSendTx(feeData, &common.Address{}, big.NewInt(0), nil, nil)
 		assert.NoError(t, err)
 		assert.NotNil(t, tx)
-		_, err = s.resubmitTransaction(feeData, s.auth, tx)
+		_, err = s.resubmitTransaction(s.auth, tx, 0)
 		assert.Error(t, err, "replacement transaction underpriced")
 		s.Stop()
 	}
 }
 
 func testResubmitTransactionWithRisingBaseFee(t *testing.T) {
-	txType := "DynamicFeeTx"
+	sqlDB, err := db.DB()
+	assert.NoError(t, err)
+	assert.NoError(t, migrate.ResetDB(sqlDB))
 
+	txType := "DynamicFeeTx"
 	cfgCopy := *cfg.L1Config.RelayerConfig.SenderConfig
 	cfgCopy.TxType = txType
-	s, err := NewSender(context.Background(), &cfgCopy, privateKey, "test", "test", nil)
-	assert.NoError(t, err)
-	tx := types.NewTransaction(s.auth.Nonce.Uint64(), common.Address{}, big.NewInt(0), 0, big.NewInt(0), nil)
-	s.baseFeePerGas = 1000
-	feeData, err := s.getFeeData(&common.Address{}, big.NewInt(0), nil, 0)
+
+	s, err := NewSender(context.Background(), &cfgCopy, privateKey, "test", "test", types.SenderTypeUnknown, db, nil)
 	assert.NoError(t, err)
+	tx := gethTypes.NewTransaction(s.auth.Nonce.Uint64(), common.Address{}, big.NewInt(0), 21000, big.NewInt(0), nil)
+	baseFeePerGas := uint64(1000)
 	// bump the basefee by 10x
-	s.baseFeePerGas *= 10
+	baseFeePerGas *= 10
 	// resubmit and check that the gas fee has been adjusted accordingly
-	newTx, err := s.resubmitTransaction(feeData, s.auth, tx)
+	newTx, err := s.resubmitTransaction(s.auth, tx, baseFeePerGas)
 	assert.NoError(t, err)
 
 	escalateMultipleNum := new(big.Int).SetUint64(s.config.EscalateMultipleNum)
@@ -282,104 +336,171 @@ func testResubmitTransactionWithRisingBaseFee(t *testing.T) {
 	maxGasPrice := new(big.Int).SetUint64(s.config.MaxGasPrice)
 
 	adjBaseFee := new(big.Int)
-	adjBaseFee.SetUint64(s.baseFeePerGas)
+	adjBaseFee.SetUint64(baseFeePerGas)
 	adjBaseFee = adjBaseFee.Mul(adjBaseFee, escalateMultipleNum)
 	adjBaseFee = adjBaseFee.Div(adjBaseFee, escalateMultipleDen)
 
-	expectedGasFeeCap := new(big.Int).Add(feeData.gasTipCap, adjBaseFee)
+	expectedGasFeeCap := new(big.Int).Add(tx.GasTipCap(), adjBaseFee)
 	if expectedGasFeeCap.Cmp(maxGasPrice) > 0 {
 		expectedGasFeeCap = maxGasPrice
 	}
 
 	assert.Equal(t, expectedGasFeeCap.Int64(), newTx.GasFeeCap().Int64())
-
 	s.Stop()
 }
 
-func testCheckPendingTransaction(t *testing.T) {
+func testCheckPendingTransactionTxConfirmed(t *testing.T) {
 	for _, txType := range txTypes {
+		sqlDB, err := db.DB()
+		assert.NoError(t, err)
+		assert.NoError(t, migrate.ResetDB(sqlDB))
+
 		cfgCopy := *cfg.L1Config.RelayerConfig.SenderConfig
 		cfgCopy.TxType = txType
-		s, err := NewSender(context.Background(), &cfgCopy, privateKey, "test", "test", nil)
+		s, err := NewSender(context.Background(), &cfgCopy, privateKey, "test", "test", types.SenderTypeCommitBatch, db, nil)
 		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)}
-		tx := types.NewTransaction(s.auth.Nonce.Uint64(), common.Address{}, big.NewInt(0), 0, big.NewInt(0), nil)
+		_, err = s.SendTransaction("test", &common.Address{}, big.NewInt(0), nil, 0)
+		assert.NoError(t, err)
 
-		testCases := []struct {
-			name          string
-			receipt       *types.Receipt
-			receiptErr    error
-			resubmitErr   error
-			expectedCount int
-			expectedFound bool
-		}{
-			{
-				name:          "Normal case, transaction receipt exists and successful",
-				receipt:       receipt,
-				receiptErr:    nil,
-				resubmitErr:   nil,
-				expectedCount: 0,
-				expectedFound: false,
-			},
-			{
-				name:          "Resubmit case, resubmitTransaction error (not nonce) case",
-				receipt:       receipt,
-				receiptErr:    errors.New("receipt error"),
-				resubmitErr:   errors.New("resubmit error"),
-				expectedCount: 1,
-				expectedFound: true,
-			},
-			{
-				name:          "Resubmit case, resubmitTransaction success case",
-				receipt:       receipt,
-				receiptErr:    errors.New("receipt error"),
-				resubmitErr:   nil,
-				expectedCount: 1,
-				expectedFound: true,
-			},
-		}
+		txs, err := s.pendingTransactionOrm.GetPendingOrReplacedTransactionsBySenderType(context.Background(), s.senderType, 1)
+		assert.NoError(t, err)
+		assert.Len(t, txs, 1)
+		assert.Equal(t, types.TxStatusPending, txs[0].Status)
+		assert.Equal(t, types.SenderTypeCommitBatch, txs[0].SenderType)
 
-		for _, tc := range testCases {
-			t.Run(tc.name, func(t *testing.T) {
-				var c *ethclient.Client
-				patchGuard := gomonkey.ApplyMethodFunc(c, "TransactionReceipt", func(ctx context.Context, txHash common.Hash) (*types.Receipt, error) {
-					return tc.receipt, tc.receiptErr
-				})
-				patchGuard.ApplyPrivateMethod(s, "resubmitTransaction",
-					func(feeData *FeeData, auth *bind.TransactOpts, tx *types.Transaction) (*types.Transaction, error) {
-						return tx, tc.resubmitErr
-					},
-				)
+		patchGuard := gomonkey.ApplyMethodFunc(s.client, "TransactionReceipt", func(_ context.Context, hash common.Hash) (*gethTypes.Receipt, error) {
+			return &gethTypes.Receipt{TxHash: hash, BlockNumber: big.NewInt(0), Status: gethTypes.ReceiptStatusSuccessful}, nil
+		})
 
-				pendingTx := &PendingTransaction{id: "abc", tx: tx, signer: s.auth, submitAt: header.Number.Uint64() - s.config.EscalateBlocks - 1}
-				s.pendingTxs.Set(pendingTx.id, pendingTx)
-				s.checkPendingTransaction(header, confirmed)
+		s.checkPendingTransaction()
+		assert.NoError(t, err)
 
-				if tc.receiptErr == nil {
-					expectedConfirmation := &Confirmation{
-						ID:           pendingTx.id,
-						IsSuccessful: tc.receipt.Status == types.ReceiptStatusSuccessful,
-						TxHash:       pendingTx.tx.Hash(),
-					}
-					actualConfirmation := <-s.confirmCh
-					assert.Equal(t, expectedConfirmation, actualConfirmation)
-				}
+		txs, err = s.pendingTransactionOrm.GetPendingOrReplacedTransactionsBySenderType(context.Background(), s.senderType, 1)
+		assert.NoError(t, err)
+		assert.Len(t, txs, 0)
 
-				if tc.expectedFound && tc.resubmitErr == nil {
-					actualPendingTx, found := s.pendingTxs.Get(pendingTx.id)
-					assert.Equal(t, true, found)
-					assert.Equal(t, header.Number.Uint64(), actualPendingTx.submitAt)
-				}
-
-				_, found := s.pendingTxs.Get(pendingTx.id)
-				assert.Equal(t, tc.expectedFound, found)
-				assert.Equal(t, tc.expectedCount, s.pendingTxs.Count())
-				patchGuard.Reset()
-			})
-		}
 		s.Stop()
+		patchGuard.Reset()
+	}
+}
+
+func testCheckPendingTransactionResubmitTxConfirmed(t *testing.T) {
+	for _, txType := range txTypes {
+		sqlDB, err := db.DB()
+		assert.NoError(t, err)
+		assert.NoError(t, migrate.ResetDB(sqlDB))
+
+		cfgCopy := *cfg.L1Config.RelayerConfig.SenderConfig
+		cfgCopy.TxType = txType
+		cfgCopy.EscalateBlocks = 0
+		s, err := NewSender(context.Background(), &cfgCopy, privateKey, "test", "test", types.SenderTypeFinalizeBatch, db, nil)
+		assert.NoError(t, err)
+
+		originTxHash, err := s.SendTransaction("test", &common.Address{}, big.NewInt(0), nil, 0)
+		assert.NoError(t, err)
+
+		txs, err := s.pendingTransactionOrm.GetPendingOrReplacedTransactionsBySenderType(context.Background(), s.senderType, 1)
+		assert.NoError(t, err)
+		assert.Len(t, txs, 1)
+		assert.Equal(t, types.TxStatusPending, txs[0].Status)
+		assert.Equal(t, types.SenderTypeFinalizeBatch, txs[0].SenderType)
+
+		patchGuard := gomonkey.ApplyMethodFunc(s.client, "TransactionReceipt", func(_ context.Context, hash common.Hash) (*gethTypes.Receipt, error) {
+			if hash == originTxHash {
+				return nil, fmt.Errorf("simulated transaction receipt error")
+			}
+			return &gethTypes.Receipt{TxHash: hash, BlockNumber: big.NewInt(0), Status: gethTypes.ReceiptStatusSuccessful}, nil
+		})
+
+		// Attempt to resubmit the transaction.
+		s.checkPendingTransaction()
+		assert.NoError(t, err)
+
+		status, err := s.pendingTransactionOrm.GetTxStatusByTxHash(context.Background(), originTxHash)
+		assert.NoError(t, err)
+		assert.Equal(t, types.TxStatusReplaced, status)
+
+		txs, err = s.pendingTransactionOrm.GetPendingOrReplacedTransactionsBySenderType(context.Background(), s.senderType, 2)
+		assert.NoError(t, err)
+		assert.Len(t, txs, 2)
+		assert.Equal(t, types.TxStatusReplaced, txs[0].Status)
+		assert.Equal(t, types.TxStatusPending, txs[1].Status)
+
+		// Check the pending transactions again after attempting to resubmit.
+		s.checkPendingTransaction()
+		assert.NoError(t, err)
+
+		txs, err = s.pendingTransactionOrm.GetPendingOrReplacedTransactionsBySenderType(context.Background(), s.senderType, 1)
+		assert.NoError(t, err)
+		assert.Len(t, txs, 0)
+
+		s.Stop()
+		patchGuard.Reset()
+	}
+}
+
+func testCheckPendingTransactionReplacedTxConfirmed(t *testing.T) {
+	for _, txType := range txTypes {
+		sqlDB, err := db.DB()
+		assert.NoError(t, err)
+		assert.NoError(t, migrate.ResetDB(sqlDB))
+
+		cfgCopy := *cfg.L1Config.RelayerConfig.SenderConfig
+		cfgCopy.TxType = txType
+		cfgCopy.EscalateBlocks = 0
+		s, err := NewSender(context.Background(), &cfgCopy, privateKey, "test", "test", types.SenderTypeL1GasOracle, db, nil)
+		assert.NoError(t, err)
+
+		txHash, err := s.SendTransaction("test", &common.Address{}, big.NewInt(0), nil, 0)
+		assert.NoError(t, err)
+
+		txs, err := s.pendingTransactionOrm.GetPendingOrReplacedTransactionsBySenderType(context.Background(), s.senderType, 1)
+		assert.NoError(t, err)
+		assert.Len(t, txs, 1)
+		assert.Equal(t, types.TxStatusPending, txs[0].Status)
+		assert.Equal(t, types.SenderTypeL1GasOracle, txs[0].SenderType)
+
+		patchGuard := gomonkey.ApplyMethodFunc(s.client, "TransactionReceipt", func(_ context.Context, hash common.Hash) (*gethTypes.Receipt, error) {
+			var status types.TxStatus
+			status, err = s.pendingTransactionOrm.GetTxStatusByTxHash(context.Background(), hash)
+			if err != nil {
+				return nil, fmt.Errorf("failed to get transaction status, hash: %s, err: %w", hash.String(), err)
+			}
+			// If the transaction status is 'replaced', return a successful receipt.
+			if status == types.TxStatusReplaced {
+				return &gethTypes.Receipt{
+					TxHash:      hash,
+					BlockNumber: big.NewInt(0),
+					Status:      gethTypes.ReceiptStatusSuccessful,
+				}, nil
+			}
+			return nil, fmt.Errorf("simulated transaction receipt error")
+		})
+
+		// Attempt to resubmit the transaction.
+		s.checkPendingTransaction()
+		assert.NoError(t, err)
+
+		status, err := s.pendingTransactionOrm.GetTxStatusByTxHash(context.Background(), txHash)
+		assert.NoError(t, err)
+		assert.Equal(t, types.TxStatusReplaced, status)
+
+		txs, err = s.pendingTransactionOrm.GetPendingOrReplacedTransactionsBySenderType(context.Background(), s.senderType, 2)
+		assert.NoError(t, err)
+		assert.Len(t, txs, 2)
+		assert.Equal(t, types.TxStatusReplaced, txs[0].Status)
+		assert.Equal(t, types.TxStatusPending, txs[1].Status)
+
+		// Check the pending transactions again after attempting to resubmit.
+		s.checkPendingTransaction()
+		assert.NoError(t, err)
+
+		txs, err = s.pendingTransactionOrm.GetPendingOrReplacedTransactionsBySenderType(context.Background(), s.senderType, 1)
+		assert.NoError(t, err)
+		assert.Len(t, txs, 0)
+
+		s.Stop()
+		patchGuard.Reset()
 	}
 }

rollup/internal/controller/watcher/l2_watcher_test.go

@@ -22,6 +22,7 @@ import (
 	"github.com/stretchr/testify/assert"
 
 	"scroll-tech/common/database"
+	"scroll-tech/common/types"
 	cutils "scroll-tech/common/utils"
 
 	bridgeAbi "scroll-tech/rollup/abi"
@@ -51,7 +52,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.GasOracleSenderPrivateKey, "test", "test", nil)
+	newSender, err := sender.NewSender(context.Background(), l1cfg.RelayerConfig.SenderConfig, l1cfg.RelayerConfig.GasOracleSenderPrivateKey, "test", "test", types.SenderTypeUnknown, db, nil)
 	assert.NoError(t, err)
 
 	// Create several transactions and commit to block

rollup/internal/orm/orm_test.go

@@ -3,27 +3,29 @@ package orm
 import (
 	"context"
 	"encoding/json"
+	"math/big"
 	"os"
 	"testing"
 
 	"github.com/scroll-tech/go-ethereum/common"
+	gethTypes "github.com/scroll-tech/go-ethereum/core/types"
 	"github.com/stretchr/testify/assert"
 	"gorm.io/gorm"
 
 	"scroll-tech/common/database"
 	"scroll-tech/common/docker"
 	"scroll-tech/common/types"
-
 	"scroll-tech/database/migrate"
 )
 
 var (
 	base *docker.App
 
-	db         *gorm.DB
-	l2BlockOrm *L2Block
-	chunkOrm   *Chunk
-	batchOrm   *Batch
+	db                    *gorm.DB
+	l2BlockOrm            *L2Block
+	chunkOrm              *Chunk
+	batchOrm              *Batch
+	pendingTransactionOrm *PendingTransaction
 
 	wrappedBlock1 *types.WrappedBlock
 	wrappedBlock2 *types.WrappedBlock
@@ -60,6 +62,7 @@ func setupEnv(t *testing.T) {
 	batchOrm = NewBatch(db)
 	chunkOrm = NewChunk(db)
 	l2BlockOrm = NewL2Block(db)
+	pendingTransactionOrm = NewPendingTransaction(db)
 
 	templateBlockTrace, err := os.ReadFile("../../../common/testdata/blockTrace_02.json")
 	assert.NoError(t, err)
@@ -310,3 +313,85 @@ func TestBatchOrm(t *testing.T) {
 	assert.Equal(t, "finalizeTxHash", updatedBatch.FinalizeTxHash)
 	assert.Equal(t, types.RollupFinalizeFailed, types.RollupStatus(updatedBatch.RollupStatus))
 }
+
+func TestTransactionOrm(t *testing.T) {
+	sqlDB, err := db.DB()
+	assert.NoError(t, err)
+	assert.NoError(t, migrate.ResetDB(sqlDB))
+
+	tx0 := gethTypes.NewTx(&gethTypes.DynamicFeeTx{
+		Nonce:      0,
+		To:         &common.Address{},
+		Data:       []byte{},
+		Gas:        21000,
+		AccessList: gethTypes.AccessList{},
+		Value:      big.NewInt(0),
+		ChainID:    big.NewInt(1),
+		GasTipCap:  big.NewInt(0),
+		GasFeeCap:  big.NewInt(1),
+		V:          big.NewInt(0),
+		R:          big.NewInt(0),
+		S:          big.NewInt(0),
+	})
+	tx1 := gethTypes.NewTx(&gethTypes.DynamicFeeTx{
+		Nonce:      0,
+		To:         &common.Address{},
+		Data:       []byte{},
+		Gas:        42000,
+		AccessList: gethTypes.AccessList{},
+		Value:      big.NewInt(0),
+		ChainID:    big.NewInt(1),
+		GasTipCap:  big.NewInt(1),
+		GasFeeCap:  big.NewInt(2),
+		V:          big.NewInt(0),
+		R:          big.NewInt(0),
+		S:          big.NewInt(0),
+	})
+	senderMeta := &SenderMeta{
+		Name:    "testName",
+		Service: "testService",
+		Address: common.HexToAddress("0x1"),
+		Type:    types.SenderTypeCommitBatch,
+	}
+
+	err = pendingTransactionOrm.InsertPendingTransaction(context.Background(), "test", senderMeta, tx0, 0)
+	assert.NoError(t, err)
+
+	err = pendingTransactionOrm.InsertPendingTransaction(context.Background(), "test", senderMeta, tx1, 0)
+	assert.NoError(t, err)
+
+	err = pendingTransactionOrm.UpdatePendingTransactionStatusByTxHash(context.Background(), tx0.Hash(), types.TxStatusReplaced)
+	assert.NoError(t, err)
+
+	txs, err := pendingTransactionOrm.GetPendingOrReplacedTransactionsBySenderType(context.Background(), senderMeta.Type, 2)
+	assert.NoError(t, err)
+	assert.Len(t, txs, 2)
+	assert.Equal(t, tx1.Type(), txs[1].Type)
+	assert.Equal(t, tx1.Nonce(), txs[1].Nonce)
+	assert.Equal(t, tx1.Gas(), txs[1].GasLimit)
+	assert.Equal(t, tx1.GasTipCap().Uint64(), txs[1].GasTipCap)
+	assert.Equal(t, tx1.GasFeeCap().Uint64(), txs[1].GasFeeCap)
+	assert.Equal(t, tx1.ChainId().Uint64(), txs[1].ChainID)
+	assert.Equal(t, senderMeta.Name, txs[1].SenderName)
+	assert.Equal(t, senderMeta.Service, txs[1].SenderService)
+	assert.Equal(t, senderMeta.Address.String(), txs[1].SenderAddress)
+	assert.Equal(t, senderMeta.Type, txs[1].SenderType)
+
+	err = pendingTransactionOrm.UpdatePendingTransactionStatusByTxHash(context.Background(), tx1.Hash(), types.TxStatusConfirmed)
+	assert.NoError(t, err)
+
+	txs, err = pendingTransactionOrm.GetPendingOrReplacedTransactionsBySenderType(context.Background(), senderMeta.Type, 2)
+	assert.NoError(t, err)
+	assert.Len(t, txs, 1)
+
+	err = pendingTransactionOrm.UpdateOtherTransactionsAsFailedByNonce(context.Background(), senderMeta.Address.String(), tx1.Nonce(), tx1.Hash())
+	assert.NoError(t, err)
+
+	txs, err = pendingTransactionOrm.GetPendingOrReplacedTransactionsBySenderType(context.Background(), senderMeta.Type, 2)
+	assert.NoError(t, err)
+	assert.Len(t, txs, 0)
+
+	status, err := pendingTransactionOrm.GetTxStatusByTxHash(context.Background(), tx0.Hash())
+	assert.NoError(t, err)
+	assert.Equal(t, types.TxStatusConfirmedFailed, status)
+}

rollup/internal/orm/pending_transaction.go

@@ -0,0 +1,155 @@
+package orm
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/scroll-tech/go-ethereum/common"
+	gethTypes "github.com/scroll-tech/go-ethereum/core/types"
+	"gorm.io/gorm"
+
+	"scroll-tech/common/types"
+)
+
+// SenderMeta holds the metadata for a transaction sender including the name, service, address and type.
+type SenderMeta struct {
+	Name    string
+	Service string
+	Address common.Address
+	Type    types.SenderType
+}
+
+// PendingTransaction represents the structure of a transaction in the database.
+type PendingTransaction struct {
+	db *gorm.DB `gorm:"column:-"`
+
+	ID                uint             `json:"id" gorm:"id;primaryKey"`
+	ContextID         string           `json:"context_id" gorm:"context_id"`
+	Hash              string           `json:"hash" gorm:"hash"`
+	ChainID           uint64           `json:"chain_id" gorm:"chain_id"`
+	Type              uint8            `json:"type" gorm:"type"`
+	GasTipCap         uint64           `json:"gas_tip_cap" gorm:"gas_tip_cap"`
+	GasFeeCap         uint64           `json:"gas_fee_cap" gorm:"gas_fee_cap"`
+	GasLimit          uint64           `json:"gas_limit" gorm:"gas_limit"`
+	Nonce             uint64           `json:"nonce" gorm:"nonce"`
+	SubmitBlockNumber uint64           `json:"submit_block_number" gorm:"submit_block_number"`
+	Status            types.TxStatus   `json:"status" gorm:"status"`
+	RLPEncoding       []byte           `json:"rlp_encoding" gorm:"rlp_encoding"`
+	SenderName        string           `json:"sender_name" gorm:"sender_name"`
+	SenderService     string           `json:"sender_service" gorm:"sender_service"`
+	SenderAddress     string           `json:"sender_address" gorm:"sender_address"`
+	SenderType        types.SenderType `json:"sender_type" gorm:"sender_type"`
+	CreatedAt         time.Time        `json:"created_at" gorm:"column:created_at"`
+	UpdatedAt         time.Time        `json:"updated_at" gorm:"column:updated_at"`
+	DeletedAt         gorm.DeletedAt   `json:"deleted_at" gorm:"column:deleted_at"`
+}
+
+// TableName returns the table name for the Transaction model.
+func (*PendingTransaction) TableName() string {
+	return "pending_transaction"
+}
+
+// NewPendingTransaction returns a new instance of PendingTransaction.
+func NewPendingTransaction(db *gorm.DB) *PendingTransaction {
+	return &PendingTransaction{db: db}
+}
+
+// GetTxStatusByTxHash retrieves the status of a transaction by its hash.
+func (o *PendingTransaction) GetTxStatusByTxHash(ctx context.Context, hash common.Hash) (types.TxStatus, error) {
+	var status types.TxStatus
+	db := o.db.WithContext(ctx)
+	db = db.Model(&PendingTransaction{})
+	db = db.Select("status")
+	db = db.Where("hash = ?", hash.String())
+	if err := db.Scan(&status).Error; err != nil {
+		return types.TxStatusUnknown, fmt.Errorf("failed to get tx status by hash, hash: %v, err: %w", hash, err)
+	}
+	return status, nil
+}
+
+// GetPendingOrReplacedTransactionsBySenderType retrieves pending or replaced transactions filtered by sender type, ordered by nonce, then gas_fee_cap (gas_price in legacy tx), and limited to a specified count.
+func (o *PendingTransaction) GetPendingOrReplacedTransactionsBySenderType(ctx context.Context, senderType types.SenderType, limit int) ([]PendingTransaction, error) {
+	var transactions []PendingTransaction
+	db := o.db.WithContext(ctx)
+	db = db.Model(&PendingTransaction{})
+	db = db.Where("sender_type = ?", senderType)
+	db = db.Where("status = ? OR status = ?", types.TxStatusPending, types.TxStatusReplaced)
+	db = db.Order("nonce asc")
+	db = db.Order("gas_fee_cap asc")
+	db = db.Limit(limit)
+	if err := db.Find(&transactions).Error; err != nil {
+		return nil, fmt.Errorf("failed to get pending or replaced transactions by sender type, error: %w", err)
+	}
+	return transactions, nil
+}
+
+// InsertPendingTransaction creates a new pending transaction record and stores it in the database.
+func (o *PendingTransaction) InsertPendingTransaction(ctx context.Context, contextID string, senderMeta *SenderMeta, tx *gethTypes.Transaction, submitBlockNumber uint64, dbTX ...*gorm.DB) error {
+	rlp := new(bytes.Buffer)
+	if err := tx.EncodeRLP(rlp); err != nil {
+		return fmt.Errorf("failed to encode rlp, err: %w", err)
+	}
+
+	newTransaction := &PendingTransaction{
+		ContextID:         contextID,
+		Hash:              tx.Hash().String(),
+		Type:              tx.Type(),
+		ChainID:           tx.ChainId().Uint64(),
+		GasFeeCap:         tx.GasFeeCap().Uint64(),
+		GasTipCap:         tx.GasTipCap().Uint64(),
+		GasLimit:          tx.Gas(),
+		Nonce:             tx.Nonce(),
+		SubmitBlockNumber: submitBlockNumber,
+		Status:            types.TxStatusPending,
+		RLPEncoding:       rlp.Bytes(),
+		SenderName:        senderMeta.Name,
+		SenderAddress:     senderMeta.Address.String(),
+		SenderService:     senderMeta.Service,
+		SenderType:        senderMeta.Type,
+	}
+
+	db := o.db
+	if len(dbTX) > 0 && dbTX[0] != nil {
+		db = dbTX[0]
+	}
+	db = db.WithContext(ctx)
+	db = db.Model(&PendingTransaction{})
+	if err := db.Create(newTransaction).Error; err != nil {
+		return fmt.Errorf("failed to InsertTransaction, error: %w", err)
+	}
+	return nil
+}
+
+// UpdatePendingTransactionStatusByTxHash updates the status of a transaction based on the transaction hash.
+func (o *PendingTransaction) UpdatePendingTransactionStatusByTxHash(ctx context.Context, hash common.Hash, status types.TxStatus, dbTX ...*gorm.DB) error {
+	db := o.db
+	if len(dbTX) > 0 && dbTX[0] != nil {
+		db = dbTX[0]
+	}
+	db = db.WithContext(ctx)
+	db = db.Model(&PendingTransaction{})
+	db = db.Where("hash = ?", hash.String())
+	if err := db.Update("status", status).Error; err != nil {
+		return fmt.Errorf("failed to UpdatePendingTransactionStatusByTxHash, txHash: %s, error: %w", hash, err)
+	}
+	return nil
+}
+
+// UpdateOtherTransactionsAsFailedByNonce updates the status of all transactions to TxStatusConfirmedFailed for a specific nonce and sender address, excluding a specified transaction hash.
+func (o *PendingTransaction) UpdateOtherTransactionsAsFailedByNonce(ctx context.Context, senderAddress string, nonce uint64, hash common.Hash, dbTX ...*gorm.DB) error {
+	db := o.db
+	if len(dbTX) > 0 && dbTX[0] != nil {
+		db = dbTX[0]
+	}
+	db = db.WithContext(ctx)
+	db = db.Model(&PendingTransaction{})
+	db = db.Where("sender_address = ?", senderAddress)
+	db = db.Where("nonce = ?", nonce)
+	db = db.Where("hash != ?", hash.String())
+	if err := db.Update("status", types.TxStatusConfirmedFailed).Error; err != nil {
+		return fmt.Errorf("failed to update other transactions as failed by nonce, senderAddress: %s, nonce: %d, txHash: %s, error: %w", senderAddress, nonce, hash, err)
+	}
+	return nil
+}