feat(tx sender): add multiple write clients for more reliable tx submission (#1740)

Co-authored-by: jonastheis <jonastheis@users.noreply.github.com>

.github/pull_request_template.md

@@ -20,7 +20,7 @@ Your PR title must follow [conventional commits](https://www.conventionalcommits
 
 ### Deployment tag versioning
 
-Has `tag` in `common/version.go` been updated?
+Has `tag` in `common/version.go` been updated or have you added `bump-version` label to this PR?
 
 - [ ] No, this PR doesn't involve a new deployment, git tag, docker image tag
 - [ ] Yes

.github/scripts/bump_version_dot_go.mjs

@@ -0,0 +1,37 @@
+import { URL } from "url";
+import { readFileSync, writeFileSync } from "fs";
+
+const versionFilePath = new URL(
+  "../../common/version/version.go",
+  import.meta.url
+).pathname;
+
+const versionFileContent = readFileSync(versionFilePath, { encoding: "utf-8" });
+
+const currentVersion = versionFileContent.match(
+  /var tag = "(?<version>v(?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+))"/
+);
+
+try {
+  parseInt(currentVersion.groups.major);
+  parseInt(currentVersion.groups.minor);
+  parseInt(currentVersion.groups.patch);
+} catch (err) {
+  console.error(new Error("Failed to parse version in version.go file"));
+  throw err;
+}
+
+// prettier-ignore
+const newVersion = `v${currentVersion.groups.major}.${currentVersion.groups.minor}.${parseInt(currentVersion.groups.patch) + 1}`;
+
+console.log(
+  `Bump version from ${currentVersion.groups.version} to ${newVersion}`
+);
+
+writeFileSync(
+  versionFilePath,
+  versionFileContent.replace(
+    `var tag = "${currentVersion.groups.version}"`,
+    `var tag = "${newVersion}"`
+  )
+);

.github/workflows/bridge_history_api.yml

@@ -32,9 +32,9 @@ jobs:
     - name: Install Go
       uses: actions/setup-go@v2
       with:
-        go-version: 1.19.x
+        go-version: 1.21.x
     - name: Checkout code
-      uses: actions/checkout@v2
+      uses: actions/checkout@v4
     - name: Lint
       run: |
         rm -rf $HOME/.cache/golangci-lint
@@ -46,12 +46,11 @@ jobs:
     - name: Install Go
       uses: actions/setup-go@v2
       with:
-        go-version: 1.19.x
+        go-version: 1.21.x
     - name: Checkout code
-      uses: actions/checkout@v2
+      uses: actions/checkout@v4
     - name: Test
       run: |
-        go get ./...
         make test
     - name: Upload coverage reports to Codecov
       uses: codecov/codecov-action@v3
@@ -66,9 +65,9 @@ jobs:
     - name: Install Go
       uses: actions/setup-go@v2
       with:
-        go-version: 1.19.x
+        go-version: 1.21.x
     - name: Checkout code
-      uses: actions/checkout@v2
+      uses: actions/checkout@v4
     - name: Install goimports
       run: go install golang.org/x/tools/cmd/goimports
     - run: goimports -local scroll-tech/bridge-history-api/ -w .

.github/workflows/bump_version.yml

@@ -0,0 +1,63 @@
+name: Bump version
+
+on:
+  pull_request:
+    branches: [ develop ]
+    types:
+      - opened
+      - reopened
+      - synchronize
+      - ready_for_review
+      - labeled
+
+jobs:
+  try-to-bump:
+    if: contains(github.event.pull_request.labels.*.name, 'bump-version')
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ github.head_ref }}
+      - name: check diff
+        id: check_diff
+        run: |
+          set -euo pipefail
+
+          # fetch develop branch so that we can diff against later
+          git fetch origin develop
+
+          echo 'checking verion changes in diff...'
+
+          # check if version changed in version.go
+          # note: the grep will fail if use \d instead of [0-9]
+          git diff HEAD..origin/develop --text --no-ext-diff --unified=0 --no-prefix common/version/version.go | grep -E '^\+var tag = "v[0-9]+\.[0-9]+\.[0-9]+"$' && true
+
+          exit_code=$?
+
+          # auto bump if version is not bumped manually
+          echo '> require auto version bump?'
+
+          if [ $exit_code -eq 0 ]; then
+            echo '> no, already bumped'
+            echo "result=no-bump" >> "$GITHUB_OUTPUT"
+          else
+            echo '> yes'
+            echo "result=bump" >> "$GITHUB_OUTPUT"
+          fi
+      - name: Install Node.js 16
+        if: steps.check_diff.outputs.result == 'bump'
+        uses: actions/setup-node@v3
+        with:
+          node-version: 16
+      - name: bump version in common/version/version.go
+        if: steps.check_diff.outputs.result == 'bump'
+        run: node .github/scripts/bump_version_dot_go.mjs
+
+        # Commits made by this Action do not trigger new Workflow runs
+      - uses: stefanzweifel/git-auto-commit-action@3ea6ae190baf489ba007f7c92608f33ce20ef04a
+        if: steps.check_diff.outputs.result == 'bump'
+        with:
+          skip_fetch: true # already did fetch in check diff
+          file_pattern: "common/version/version.go"
+          commit_message: "chore: auto version bump [bot]"

.github/workflows/common.yml

@@ -9,6 +9,7 @@ on:
       - alpha
     paths:
       - 'common/**'
+      - '!common/version/version.go'
       - '.github/workflows/common.yml'
   pull_request:
     types:
@@ -18,6 +19,7 @@ on:
       - ready_for_review
     paths:
       - 'common/**'
+      - '!common/version/version.go'
       - '.github/workflows/common.yml'
 
 jobs:
@@ -27,24 +29,24 @@ jobs:
     steps:
     - uses: actions-rs/toolchain@v1
       with:
-        toolchain: nightly-2022-12-10
+        toolchain: nightly-2025-02-14
         override: true
         components: rustfmt, clippy
     - name: Install Go
       uses: actions/setup-go@v2
       with:
-        go-version: 1.19.x
+        go-version: 1.21.x
     - name: Checkout code
-      uses: actions/checkout@v2
+      uses: actions/checkout@v4
     - name: Cache cargo
       uses: Swatinem/rust-cache@v2
       with:
-        workspaces: "common/libzkp/impl -> target"
-    - name: Lint
-      working-directory: 'common'
-      run: |
-        rm -rf $HOME/.cache/golangci-lint
-        make lint
+        workspaces: ". -> target"
+    # - name: Lint
+    #   working-directory: 'common'
+    #   run: |
+    #     rm -rf $HOME/.cache/golangci-lint
+    #     make lint
   goimports-lint:
     if: github.event.pull_request.draft == false
     runs-on: ubuntu-latest
@@ -52,9 +54,9 @@ jobs:
     - name: Install Go
       uses: actions/setup-go@v2
       with:
-        go-version: 1.19.x
+        go-version: 1.21.x
     - name: Checkout code
-      uses: actions/checkout@v2
+      uses: actions/checkout@v4
     - name: Install goimports
       run: go install golang.org/x/tools/cmd/goimports
     - name: Run goimports lint
@@ -77,15 +79,15 @@ jobs:
     - name: Install Go
       uses: actions/setup-go@v2
       with:
-        go-version: 1.18.x
+        go-version: 1.21.x
     - name: Checkout code
-      uses: actions/checkout@v2
+      uses: actions/checkout@v4
     - name: Install Solc
       uses: supplypike/setup-bin@v3
       with:
-        uri: 'https://github.com/ethereum/solidity/releases/download/v0.8.16/solc-static-linux'
+        uri: 'https://github.com/ethereum/solidity/releases/download/v0.8.24/solc-static-linux'
         name: 'solc'
-        version: '0.8.16'
+        version: '0.8.24'
     - name: Install Geth Tools
       uses: gacts/install-geth-tools@v1
     - name: Build prerequisites

.github/workflows/contracts.yaml

@@ -1,140 +0,0 @@
-name: Contracts
-
-on:
-  push:
-    branches:
-      - main
-      - staging
-      - develop
-      - alpha
-    paths:
-      - 'contracts/**'
-      - '.github/workflows/contracts.yaml'
-  pull_request:
-    types:
-      - opened
-      - reopened
-      - synchronize
-      - ready_for_review
-    paths:
-      - 'contracts/**'
-      - '.github/workflows/contracts.yaml'
-
-defaults:
-  run:
-    working-directory: 'contracts'
-
-jobs:
-  foundry:
-    if: github.event.pull_request.draft == false
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout sources
-        uses: actions/checkout@v3
-        with:
-          submodules: recursive
-
-      - name: Install Foundry
-        uses: foundry-rs/foundry-toolchain@v1
-        with:
-          version: nightly
-
-      - name: Setup LCOV
-        uses: hrishikesh-kadam/setup-lcov@v1
-
-      - name: Install Node.js 14
-        uses: actions/setup-node@v2
-        with:
-          node-version: '14'
-
-      - name: Get yarn cache directory path
-        id: yarn-cache-dir-path
-        run: echo "::set-output name=dir::$(yarn cache dir)"
-
-      - name: Cache yarn dependencies
-        uses: actions/cache@v2
-        id: yarn-cache # use this to check for `cache-hit` (`steps.yarn-cache.outputs.cache-hit != 'true'`)
-        with:
-          path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
-          key: ${{ runner.os }}-yarn-${{ hashFiles('contracts/yarn.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-yarn-
-
-      - name: Cache node_modules
-        id: npm_cache
-        uses: actions/cache@v2
-        with:
-          path: node_modules
-          key: node_modules-${{ hashFiles('contracts/yarn.lock') }}
-
-      - name: yarn install
-        # if: steps.npm_cache.outputs.cache-hit != 'true'
-        run: yarn install
-
-      - name: Compile with foundry
-        run: forge build
-
-      - name: Run foundry tests
-        run: forge test -vvv
-
-      - name: Run foundry coverage
-        run : forge coverage --report lcov
-
-      - name : Prune coverage
-        run : lcov --remove ./lcov.info -o ./lcov.info.pruned 'src/mocks/*' 'src/test/*' 'scripts/*' 'node_modules/*' 'lib/*'
-
-      - name: Report code coverage
-        uses: zgosalvez/github-actions-report-lcov@v3
-        with:
-          coverage-files: contracts/lcov.info.pruned
-          minimum-coverage: 0
-          artifact-name: code-coverage-report
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          working-directory: contracts
-          update-comment: true
-
-  hardhat:
-    if: github.event.pull_request.draft == false
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout sources
-        uses: actions/checkout@v3
-        with:
-          submodules: recursive
-
-      - name: Install Node.js 14
-        uses: actions/setup-node@v2
-        with:
-          node-version: '14'
-
-      - name: Get yarn cache directory path
-        id: yarn-cache-dir-path
-        run: echo "::set-output name=dir::$(yarn cache dir)"
-
-      - name: Cache yarn dependencies
-        uses: actions/cache@v2
-        id: yarn-cache # use this to check for `cache-hit` (`steps.yarn-cache.outputs.cache-hit != 'true'`)
-        with:
-          path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
-          key: ${{ runner.os }}-yarn-${{ hashFiles('contracts/yarn.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-yarn-
-
-      - name: Cache node_modules
-        id: npm_cache
-        uses: actions/cache@v2
-        with:
-          path: node_modules
-          key: node_modules-${{ hashFiles('contracts/yarn.lock') }}
-
-      - name: yarn install
-        # if: steps.npm_cache.outputs.cache-hit != 'true'
-        run: yarn install
-
-      - name: Compile with hardhat
-        run: npx hardhat compile
-
-      - name: Run hardhat tests
-        run: npx hardhat test

.github/workflows/coordinator.yml

@@ -10,6 +10,7 @@ on:
     paths:
       - 'coordinator/**'
       - 'common/**'
+      - '!common/version/version.go'
       - 'database/**'
       - '.github/workflows/coordinator.yml'
   pull_request:
@@ -21,6 +22,7 @@ on:
     paths:
       - 'coordinator/**'
       - 'common/**'
+      - '!common/version/version.go'
       - 'database/**'
       - '.github/workflows/coordinator.yml'
 
@@ -31,15 +33,15 @@ jobs:
     steps:
     - uses: actions-rs/toolchain@v1
       with:
-        toolchain: nightly-2022-12-10
+        toolchain: nightly-2025-02-14
         override: true
         components: rustfmt, clippy
     - name: Install Go
       uses: actions/setup-go@v2
       with:
-        go-version: 1.19.x
+        go-version: 1.21.x
     - name: Checkout code
-      uses: actions/checkout@v2
+      uses: actions/checkout@v4
     - name: Lint
       working-directory: 'coordinator'
       run: |
@@ -52,9 +54,9 @@ jobs:
     - name: Install Go
       uses: actions/setup-go@v2
       with:
-        go-version: 1.19.x
+        go-version: 1.21.x
     - name: Checkout code
-      uses: actions/checkout@v2
+      uses: actions/checkout@v4
     - name: Install goimports
       run: go install golang.org/x/tools/cmd/goimports
     - name: Run goimports lint
@@ -75,7 +77,7 @@ jobs:
   #   runs-on: ubuntu-latest
   #   steps:
   #   - name: Checkout code
-  #     uses: actions/checkout@v2
+  #     uses: actions/checkout@v4
   #   - name: Set up Docker Buildx
   #     uses: docker/setup-buildx-action@v2
   #   - name: Build and push
@@ -93,15 +95,15 @@ jobs:
     - name: Install Go
       uses: actions/setup-go@v2
       with:
-        go-version: 1.18.x
+        go-version: 1.21.x
     - name: Checkout code
-      uses: actions/checkout@v2
+      uses: actions/checkout@v4
     - name: Install Solc
       uses: supplypike/setup-bin@v3
       with:
-        uri: 'https://github.com/ethereum/solidity/releases/download/v0.8.16/solc-static-linux'
+        uri: 'https://github.com/ethereum/solidity/releases/download/v0.8.24/solc-static-linux'
         name: 'solc'
-        version: '0.8.16'
+        version: '0.8.24'
     - name: Install Geth Tools
       uses: gacts/install-geth-tools@v1
     - name: Build prerequisites
@@ -110,7 +112,7 @@ jobs:
     - name: Test coordinator packages
       working-directory: 'coordinator'
       run: |
-        # go test -exec "env LD_LIBRARY_PATH=${PWD}/verifier/lib" -v -race -gcflags="-l" -ldflags="-s=false" -coverpkg="scroll-tech/coordinator" -coverprofile=coverage.txt -covermode=atomic ./...
+        make libzkp
         go test -v -race -gcflags="-l" -ldflags="-s=false" -coverprofile=coverage.txt -covermode=atomic -tags mock_verifier ./...
     - name: Upload coverage reports to Codecov
       uses: codecov/codecov-action@v3

.github/workflows/database.yml

@@ -10,6 +10,7 @@ on:
     paths:
       - 'database/**'
       - 'common/**'
+      - '!common/version/version.go'
       - '.github/workflows/database.yml'
   pull_request:
     types:
@@ -20,6 +21,7 @@ on:
     paths:
       - 'database/**'
       - 'common/**'
+      - '!common/version/version.go'
       - '.github/workflows/database.yml'
 
 jobs:
@@ -30,9 +32,9 @@ jobs:
     - name: Install Go
       uses: actions/setup-go@v2
       with:
-        go-version: 1.19.x
+        go-version: 1.21.x
     - name: Checkout code
-      uses: actions/checkout@v2
+      uses: actions/checkout@v4
     - name: Lint
       working-directory: 'database'
       run: |
@@ -45,9 +47,9 @@ jobs:
     - name: Install Go
       uses: actions/setup-go@v2
       with:
-        go-version: 1.19.x
+        go-version: 1.21.x
     - name: Checkout code
-      uses: actions/checkout@v2
+      uses: actions/checkout@v4
     - name: Install goimports
       run: go install golang.org/x/tools/cmd/goimports
     - name: Run goimports lint
@@ -70,15 +72,15 @@ jobs:
     - name: Install Go
       uses: actions/setup-go@v2
       with:
-        go-version: 1.18.x
+        go-version: 1.21.x
     - name: Checkout code
-      uses: actions/checkout@v2
+      uses: actions/checkout@v4
     - name: Install Solc
       uses: supplypike/setup-bin@v3
       with:
-        uri: 'https://github.com/ethereum/solidity/releases/download/v0.8.16/solc-static-linux'
+        uri: 'https://github.com/ethereum/solidity/releases/download/v0.8.24/solc-static-linux'
         name: 'solc'
-        version: '0.8.16'
+        version: '0.8.24'
     - name: Install Geth Tools
       uses: gacts/install-geth-tools@v1
     - name: Build prerequisites

.github/workflows/docker-coordinator-api-arm64.yml

@@ -0,0 +1,41 @@
+name: Docker-coordinator-api-arm64
+
+on:
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: "tag of this image (suffix -arm64 is added automatically)"
+        required: true
+        type: string
+
+jobs:
+  build-and-push-arm64-image:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        arch:
+          - aarch64
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+      - name: Set up QEMU
+        run: |
+          docker run --rm --privileged multiarch/qemu-user-static --reset -p yes
+          docker buildx create --name multiarch --driver docker-container --use
+      - name: Set up Docker Buildx
+        id: 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 docker image
+        uses: docker/build-push-action@v2
+        with:
+          platforms: linux/arm64
+          context: .
+          file: ./build/dockerfiles/coordinator-api.Dockerfile
+          push: true
+          tags: scrolltech/coordinator-api:${{inputs.tag}}-arm64

.github/workflows/docker.yaml

@@ -1,83 +0,0 @@
-name: Docker
-
-on:
-  push:
-    tags:
-      - v**
-
-jobs:
-  build-and-push:
-    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 event_watcher docker
-      uses: docker/build-push-action@v2
-      with:
-        context: .
-        file: ./build/dockerfiles/event_watcher.Dockerfile
-        push: true
-        tags: scrolltech/event-watcher:${{github.ref_name}}
-        # cache-from: type=gha,scope=${{ github.workflow }}
-        # cache-to: type=gha,scope=${{ github.workflow }}
-    - name: Build and push gas_oracle docker
-      uses: docker/build-push-action@v2
-      with:
-        context: .
-        file: ./build/dockerfiles/gas_oracle.Dockerfile
-        push: true
-        tags: scrolltech/gas-oracle:${{github.ref_name}}
-        # cache-from: type=gha,scope=${{ github.workflow }}
-        # cache-to: type=gha,scope=${{ github.workflow }}
-    - name: Build and push msg_relayer docker
-      uses: docker/build-push-action@v2
-      with:
-        context: .
-        file: ./build/dockerfiles/msg_relayer.Dockerfile
-        push: true
-        tags: scrolltech/msg-relayer:${{github.ref_name}}
-        # cache-from: type=gha,scope=${{ github.workflow }}
-        # cache-to: type=gha,scope=${{ github.workflow }}
-    - name: Build and push rollup_relayer docker
-      uses: docker/build-push-action@v2
-      with:
-        context: .
-        file: ./build/dockerfiles/rollup_relayer.Dockerfile
-        push: true
-        tags: scrolltech/rollup-relayer:${{github.ref_name}}
-        # cache-from: type=gha,scope=${{ github.workflow }}
-        # cache-to: type=gha,scope=${{ github.workflow }}
-    - name: Build and push bridgehistoryapi-cross-msg-fetcher docker
-      uses: docker/build-push-action@v2
-      with:
-        context: .
-        file: ./build/dockerfiles/bridgehistoryapi-cross-msg-fetcher.Dockerfile
-        push: true
-        tags: scrolltech/bridgehistoryapi-cross-msg-fetcher:${{github.ref_name}}
-        # cache-from: type=gha,scope=${{ github.workflow }}
-        # cache-to: type=gha,scope=${{ github.workflow }}
-    - name: Build and push bridgehistoryapi-server docker
-      uses: docker/build-push-action@v2
-      with:
-        context: .
-        file: ./build/dockerfiles/bridgehistoryapi-server.Dockerfile
-        push: true
-        tags: scrolltech/bridgehistoryapi-server:${{github.ref_name}}
-        # cache-from: type=gha,scope=${{ github.workflow }}
-        # cache-to: type=gha,scope=${{ github.workflow }}
-    - name: Build and push coordinator docker
-      uses: docker/build-push-action@v2
-      with:
-        context: .
-        file: ./build/dockerfiles/coordinator.Dockerfile
-        push: true
-        tags: scrolltech/coordinator:${{github.ref_name}}
-        # cache-from: type=gha,scope=${{ github.workflow }}
-        # cache-to: type=gha,scope=${{ github.workflow }}

.github/workflows/docker.yml

@@ -0,0 +1,423 @@
+name: Docker
+
+on:
+  push:
+    tags:
+      - v**
+
+env:
+  AWS_REGION: us-west-2
+
+jobs:
+  gas_oracle:
+    runs-on:
+        group: scroll-reth-runner-group
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@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: Configure AWS credentials
+        uses: aws-actions/configure-aws-credentials@v4
+        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@v2
+      - name: check repo and create it if not exist
+        env:
+          REPOSITORY: gas-oracle
+        run: |
+          aws --region ${{ env.AWS_REGION }} ecr describe-repositories --repository-names ${{ env.REPOSITORY }} && : || aws --region ${{ env.AWS_REGION }} ecr create-repository --repository-name ${{ env.REPOSITORY }}
+      - name: Build and push
+        uses: docker/build-push-action@v3
+        env:
+          ECR_REGISTRY: ${{ steps.login-ecr.outputs.registry }}
+          REPOSITORY: gas-oracle
+          IMAGE_TAG: ${{ github.ref_name }}
+        with:
+          context: .
+          file: ./build/dockerfiles/gas_oracle.Dockerfile
+          platforms: linux/amd64,linux/arm64
+          push: true
+          tags: |
+            scrolltech/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            scrolltech/${{ env.REPOSITORY }}:latest
+            ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:latest
+
+  rollup_relayer:
+    runs-on:
+        group: scroll-reth-runner-group
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@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: Configure AWS credentials
+        uses: aws-actions/configure-aws-credentials@v4
+        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@v2
+      - name: check repo and create it if not exist
+        env:
+          REPOSITORY: rollup-relayer
+        run: |
+          aws --region ${{ env.AWS_REGION }} ecr describe-repositories --repository-names ${{ env.REPOSITORY }} && : || aws --region ${{ env.AWS_REGION }} ecr create-repository --repository-name ${{ env.REPOSITORY }}
+      - name: Build and push
+        uses: docker/build-push-action@v3
+        env:
+          ECR_REGISTRY: ${{ steps.login-ecr.outputs.registry }}
+          REPOSITORY: rollup-relayer
+          IMAGE_TAG: ${{ github.ref_name }}
+        with:
+          context: .
+          file: ./build/dockerfiles/rollup_relayer.Dockerfile
+          platforms: linux/amd64,linux/arm64
+          push: true
+          tags: |
+            scrolltech/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            scrolltech/${{ env.REPOSITORY }}:latest
+            ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:latest
+
+  blob_uploader:
+    runs-on:
+        group: scroll-reth-runner-group
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@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: Configure AWS credentials
+        uses: aws-actions/configure-aws-credentials@v4
+        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@v2
+      - name: check repo and create it if not exist
+        env:
+          REPOSITORY: blob-uploader
+        run: |
+          aws --region ${{ env.AWS_REGION }} ecr describe-repositories --repository-names ${{ env.REPOSITORY }} && : || aws --region ${{ env.AWS_REGION }} ecr create-repository --repository-name ${{ env.REPOSITORY }}
+      - name: Build and push
+        uses: docker/build-push-action@v3
+        env:
+          ECR_REGISTRY: ${{ steps.login-ecr.outputs.registry }}
+          REPOSITORY: blob-uploader
+          IMAGE_TAG: ${{ github.ref_name }}
+        with:
+          context: .
+          file: ./build/dockerfiles/blob_uploader.Dockerfile
+          platforms: linux/amd64,linux/arm64
+          push: true
+          tags: |
+            scrolltech/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            scrolltech/${{ env.REPOSITORY }}:latest
+            ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:latest
+
+  rollup-db-cli:
+    runs-on:
+        group: scroll-reth-runner-group
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@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: Configure AWS credentials
+        uses: aws-actions/configure-aws-credentials@v4
+        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@v2
+      - name: check repo and create it if not exist
+        env:
+          REPOSITORY: rollup-db-cli
+        run: |
+          aws --region ${{ env.AWS_REGION }} ecr describe-repositories --repository-names ${{ env.REPOSITORY }} && : || aws --region ${{ env.AWS_REGION }} ecr create-repository --repository-name ${{ env.REPOSITORY }}
+      - name: Build and push
+        uses: docker/build-push-action@v3
+        env:
+          ECR_REGISTRY: ${{ steps.login-ecr.outputs.registry }}
+          REPOSITORY: rollup-db-cli
+          IMAGE_TAG: ${{ github.ref_name }}
+        with:
+          context: .
+          file: ./build/dockerfiles/db_cli.Dockerfile
+          platforms: linux/amd64,linux/arm64
+          push: true
+          tags: |
+            scrolltech/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            scrolltech/${{ env.REPOSITORY }}:latest
+            ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:latest
+
+  bridgehistoryapi-fetcher:
+    runs-on:
+        group: scroll-reth-runner-group
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@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: Configure AWS credentials
+        uses: aws-actions/configure-aws-credentials@v4
+        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@v2
+      - name: check repo and create it if not exist
+        env:
+          REPOSITORY: bridgehistoryapi-fetcher
+        run: |
+          aws --region ${{ env.AWS_REGION }} ecr describe-repositories --repository-names ${{ env.REPOSITORY }} && : || aws --region ${{ env.AWS_REGION }} ecr create-repository --repository-name ${{ env.REPOSITORY }}
+      - name: Build and push
+        uses: docker/build-push-action@v3
+        env:
+          ECR_REGISTRY: ${{ steps.login-ecr.outputs.registry }}
+          REPOSITORY: bridgehistoryapi-fetcher
+          IMAGE_TAG: ${{ github.ref_name }}
+        with:
+          context: .
+          file: ./build/dockerfiles/bridgehistoryapi-fetcher.Dockerfile
+          platforms: linux/amd64,linux/arm64
+          push: true
+          tags: |
+            scrolltech/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            scrolltech/${{ env.REPOSITORY }}:latest
+            ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:latest
+
+  bridgehistoryapi-api:
+    runs-on:
+        group: scroll-reth-runner-group
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@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: Configure AWS credentials
+        uses: aws-actions/configure-aws-credentials@v4
+        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@v2
+      - name: check repo and create it if not exist
+        env:
+          REPOSITORY: bridgehistoryapi-api
+        run: |
+          aws --region ${{ env.AWS_REGION }} ecr describe-repositories --repository-names ${{ env.REPOSITORY }} && : || aws --region ${{ env.AWS_REGION }} ecr create-repository --repository-name ${{ env.REPOSITORY }}
+      - name: Build and push
+        uses: docker/build-push-action@v3
+        env:
+          ECR_REGISTRY: ${{ steps.login-ecr.outputs.registry }}
+          REPOSITORY: bridgehistoryapi-api
+          IMAGE_TAG: ${{ github.ref_name }}
+        with:
+          context: .
+          file: ./build/dockerfiles/bridgehistoryapi-api.Dockerfile
+          platforms: linux/amd64,linux/arm64
+          push: true
+          tags: |
+            scrolltech/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            scrolltech/${{ env.REPOSITORY }}:latest
+            ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:latest
+
+  bridgehistoryapi-db-cli:
+    runs-on:
+        group: scroll-reth-runner-group
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@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: Configure AWS credentials
+        uses: aws-actions/configure-aws-credentials@v4
+        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@v2
+      - name: check repo and create it if not exist
+        env:
+          REPOSITORY: bridgehistoryapi-db-cli
+        run: |
+          aws --region ${{ env.AWS_REGION }} ecr describe-repositories --repository-names ${{ env.REPOSITORY }} && : || aws --region ${{ env.AWS_REGION }} ecr create-repository --repository-name ${{ env.REPOSITORY }}
+      - name: Build and push
+        uses: docker/build-push-action@v3
+        env:
+          ECR_REGISTRY: ${{ steps.login-ecr.outputs.registry }}
+          REPOSITORY: bridgehistoryapi-db-cli
+          IMAGE_TAG: ${{ github.ref_name }}
+        with:
+          context: .
+          file: ./build/dockerfiles/bridgehistoryapi-db-cli.Dockerfile
+          platforms: linux/amd64,linux/arm64
+          push: true
+          tags: |
+            scrolltech/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            scrolltech/${{ env.REPOSITORY }}:latest
+            ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:latest
+
+  coordinator-api:
+    runs-on:
+        group: scroll-reth-runner-group
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@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: Configure AWS credentials
+        uses: aws-actions/configure-aws-credentials@v4
+        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@v2
+      - name: check repo and create it if not exist
+        env:
+          REPOSITORY: coordinator-api
+        run: |
+          aws --region ${{ env.AWS_REGION }} ecr describe-repositories --repository-names ${{ env.REPOSITORY }} && : || aws --region ${{ env.AWS_REGION }} ecr create-repository --repository-name ${{ env.REPOSITORY }}
+      - name: Build and push
+        uses: docker/build-push-action@v3
+        env:
+          ECR_REGISTRY: ${{ steps.login-ecr.outputs.registry }}
+          REPOSITORY: coordinator-api
+          IMAGE_TAG: ${{ github.ref_name }}
+        with:
+          context: .
+          file: ./build/dockerfiles/coordinator-api.Dockerfile
+          push: true
+          tags: |
+            scrolltech/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            scrolltech/${{ env.REPOSITORY }}:latest
+            ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:latest
+
+  coordinator-cron:
+    runs-on:
+        group: scroll-reth-runner-group
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@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: Configure AWS credentials
+        uses: aws-actions/configure-aws-credentials@v4
+        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@v2
+      - name: check repo and create it if not exist
+        env:
+          REPOSITORY: coordinator-cron
+        run: |
+          aws --region ${{ env.AWS_REGION }} ecr describe-repositories --repository-names ${{ env.REPOSITORY }} && : || aws --region ${{ env.AWS_REGION }} ecr create-repository --repository-name ${{ env.REPOSITORY }}
+      - name: Build and push
+        uses: docker/build-push-action@v3
+        env:
+          ECR_REGISTRY: ${{ steps.login-ecr.outputs.registry }}
+          REPOSITORY: coordinator-cron
+          IMAGE_TAG: ${{ github.ref_name }}
+        with:
+          context: .
+          file: ./build/dockerfiles/coordinator-cron.Dockerfile
+          platforms: linux/amd64,linux/arm64
+          push: true
+          tags: |
+            scrolltech/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            scrolltech/${{ env.REPOSITORY }}:latest
+            ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:latest

.github/workflows/integration.yml

@@ -22,22 +22,23 @@ jobs:
     - name: Install Go
       uses: actions/setup-go@v2
       with:
-        go-version: 1.18.x
+        go-version: 1.21.x
     - name: Checkout code
-      uses: actions/checkout@v2
+      uses: actions/checkout@v4
     - name: Install Solc
       uses: supplypike/setup-bin@v3
       with:
-        uri: 'https://github.com/ethereum/solidity/releases/download/v0.8.16/solc-static-linux'
+        uri: 'https://github.com/ethereum/solidity/releases/download/v0.8.24/solc-static-linux'
         name: 'solc'
-        version: '0.8.16'
+        version: '0.8.24'
     - name: Install Geth Tools
       uses: gacts/install-geth-tools@v1
     - name: Build prerequisites
       run: |
         make dev_docker
-        make -C bridge mock_abi
+        make -C rollup mock_abi
         make -C common/bytecode all
+        make -C coordinator/internal/logic/libzkp build
     - name: Run integration tests
       run: |
         go test -v -tags="mock_prover mock_verifier" -p 1 -coverprofile=coverage.txt scroll-tech/integration-test/...

.github/workflows/intermediate-docker.yml

@@ -4,56 +4,117 @@ on:
   workflow_dispatch:
     inputs:
       GO_VERSION:
-        description: 'Go version'
+        description: "Go version"
         required: true
-        type: string
-        default: '1.19'
+        type: choice
+        options:
+          - "1.20"
+          - "1.20.14"
+          - "1.21"
+          - "1.21.13"
+          - "1.22"
+          - "1.22.12"
+          - "1.23"
+          - "1.23.7"
+        default: "1.21"
       RUST_VERSION:
-        description: 'Rust toolchain version'
+        description: "Rust toolchain version"
         required: true
-        type: string
-        default: 'nightly-2022-12-10'
+        type: choice
+        options:
+          - nightly-2023-12-03
+          - nightly-2022-12-10
+          - 1.86.0
+          - nightly-2025-02-14
+        default: "nightly-2023-12-03"
       PYTHON_VERSION:
-        description: 'Python version'
+        description: "Python version"
         required: false
-        type: string
-        default: '3.10'
+        type: choice
+        options:
+          - "3.10"
+        default: "3.10"
       CUDA_VERSION:
-        description: 'Cuda version'
+        description: "Cuda version"
         required: false
-        type: string
-        default: '11.7.1'
+        type: choice
+        options:
+          - "11.7.1"
+          - "12.2.2"
+        default: "11.7.1"
+      CARGO_CHEF_TAG:
+        description: "Cargo chef version"
+        required: true
+        default: "0.1.41"
+        type: choice
+        options:
+          - 0.1.41
+          - 0.1.71
+      BASE_IMAGE:
+        description: "which intermediate image you want to update"
+        required: true
+        default: "go-alpine-builder"
+        type: choice
+        options:
+          - cuda-go-rust-builder
+          - go-rust-builder
+          - go-alpine-builder
+          - rust-builder
+          - rust-alpine-builder
+          - go-rust-alpine-builder
+          - py-runner
 
 defaults:
   run:
-    working-directory: 'build/dockerfiles/intermediate'
+    working-directory: "build/dockerfiles/intermediate"
 
 jobs:
-  build-and-push:
-    runs-on: ubuntu-latest
+  build-and-publish-intermediate:
+    runs-on:
+        group: scroll-reth-runner-group
     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
-      run: |
-        make all
-      env:
-        GO_VERSION: ${{ inputs.GO_VERSION }}
-        RUST_VERSION: ${{ inputs.RUST_VERSION }}
-        PYTHON_VERSION: ${{ inputs.PYTHON_VERSION }}
-        CUDA_VERSION: ${{ inputs.CUDA_VERSION }}
-    - name: Publish
-      run: |
-        make publish
-      env:
-        GO_VERSION: ${{ inputs.GO_VERSION }}
-        RUST_VERSION: ${{ inputs.RUST_VERSION }}
-        PYTHON_VERSION: ${{ inputs.PYTHON_VERSION }}
-        CUDA_VERSION: ${{ inputs.CUDA_VERSION }}
+      - name: Checkout code
+        uses: actions/checkout@v4
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@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: set tag env
+        run: |
+          if [ ${{github.event.inputs.BASE_IMAGE}} == "cuda-go-rust-builder" ]; then
+            echo "TAG=cuda-${{ github.event.inputs.CUDA_VERSION }}-go-${{ github.event.inputs.GO_VERSION }}-rust-${{ github.event.inputs.RUST_VERSION }}" >> $GITHUB_ENV
+          elif [ ${{github.event.inputs.BASE_IMAGE}} == "go-rust-builder" ]; then
+            echo "TAG=go-${{ github.event.inputs.GO_VERSION }}-rust-${{ github.event.inputs.RUST_VERSION }}" >> $GITHUB_ENV
+          elif [ ${{github.event.inputs.BASE_IMAGE}} == "go-alpine-builder" ]; then
+            echo "TAG=${{ github.event.inputs.GO_VERSION }}" >> $GITHUB_ENV
+          elif [ ${{github.event.inputs.BASE_IMAGE}} == "rust-builder" ]; then
+            echo "TAG=${{ github.event.inputs.RUST_VERSION }}" >> $GITHUB_ENV
+          elif [ ${{github.event.inputs.BASE_IMAGE}} == "rust-alpine-builder" ]; then
+            echo "TAG=${{ github.event.inputs.RUST_VERSION }}" >> $GITHUB_ENV
+          elif [ ${{github.event.inputs.BASE_IMAGE}} == "go-rust-alpine-builder" ]; then
+            echo "TAG=go-${{ github.event.inputs.GO_VERSION }}-rust-${{ github.event.inputs.RUST_VERSION }}" >> $GITHUB_ENV
+          elif [ ${{github.event.inputs.BASE_IMAGE}} == "py-runner" ]; then
+            echo "TAG=${{ github.event.inputs.PYTHON_VERSION }}" >> $GITHUB_ENV
+          else
+            echo "no BASE_IMAGE match"
+          fi
+      - name: Build image
+        id: build
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          push: true
+          file: build/dockerfiles/intermediate/${{ github.event.inputs.BASE_IMAGE }}.Dockerfile
+          platforms: linux/amd64,linux/arm64
+          tags: scrolltech/${{ github.event.inputs.BASE_IMAGE }}:${{ env.TAG }}
+          build-args: |
+            CUDA_VERSION=${{ github.event.inputs.CUDA_VERSION }}
+            GO_VERSION=${{ github.event.inputs.GO_VERSION }}
+            RUST_VERSION=${{ github.event.inputs.RUST_VERSION }}
+            PYTHON_VERSION=${{ github.event.inputs.PYTHON_VERSION }}
+            CARGO_CHEF_TAG=${{ github.event.inputs.CARGO_CHEF_TAG }}

.github/workflows/prover_stats_api.yml

@@ -1,80 +0,0 @@
-name: ProverStatsAPI
-
-on:
-  push:
-    branches:
-      - main
-      - staging
-      - develop
-      - alpha
-    paths:
-      - 'prover-stats-api/**'
-      - '.github/workflows/prover_stats_api.yml'
-  pull_request:
-    types:
-      - opened
-      - reopened
-      - synchronize
-      - ready_for_review
-    paths:
-      - 'prover-stats-api/**'
-      - '.github/workflows/prover_stats_api.yml'
-
-defaults:
-  run:
-    working-directory: 'prover-stats-api'
-
-jobs:
-  check:
-     if: github.event.pull_request.draft == false
-     runs-on: ubuntu-latest
-     steps:
-     - name: Install Go
-       uses: actions/setup-go@v2
-       with:
-         go-version: 1.19.x
-     - name: Checkout code
-       uses: actions/checkout@v2
-     - name: Lint
-       run: |
-         rm -rf $HOME/.cache/golangci-lint
-         make lint
-  test:
-    if: github.event.pull_request.draft == false
-    runs-on: ubuntu-latest
-    steps:
-      - name: Install Go
-        uses: actions/setup-go@v2
-        with:
-          go-version: 1.19.x
-      - name: Checkout code
-        uses: actions/checkout@v2
-      - name: Test
-        run: |
-          make test
-      - name: Upload coverage reports to Codecov
-        uses: codecov/codecov-action@v3
-        env:
-          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
-        with:
-          flags: prover-stats-api
-  goimports-lint:
-    if: github.event.pull_request.draft == false
-    runs-on: ubuntu-latest
-    steps:
-      - name: Install Go
-        uses: actions/setup-go@v2
-        with:
-          go-version: 1.19.x
-      - name: Checkout code
-        uses: actions/checkout@v2
-      - name: Install goimports
-        run: go install golang.org/x/tools/cmd/goimports
-      - run: goimports -local scroll-tech/prover-stats-api/ -w .
-      - run: go mod tidy
-      # If there are any diffs from goimports or go mod tidy, fail.
-      - name: Verify no changes from goimports and go mod tidy
-        run: |
-          if [ -n "$(git status --porcelain)" ]; then
-            exit 1
-          fi

.github/workflows/roller.yml

@@ -1,102 +0,0 @@
-name: Roller
-
-on:
-  push:
-    branches:
-      - main
-      - staging
-      - develop
-      - alpha
-    paths:
-      - 'roller/**'
-      - '.github/workflows/roller.yml'
-  pull_request:
-    types:
-      - opened
-      - reopened
-      - synchronize
-      - ready_for_review
-    paths:
-      - 'roller/**'
-      - '.github/workflows/roller.yml'
-
-defaults:
-  run:
-    working-directory: 'roller'
-
-jobs:
-  test:
-    if: github.event.pull_request.draft == false
-    runs-on: ubuntu-latest
-    steps:
-    - name: Install Go
-      uses: actions/setup-go@v2
-      with:
-        go-version: 1.19.x
-    - name: Checkout code
-      uses: actions/checkout@v2
-    - name: Test
-      run: |
-        go test -tags="mock_prover" -v -coverprofile=coverage.txt ./...
-    - name: Upload coverage reports to Codecov
-      uses: codecov/codecov-action@v3
-      env:
-        CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
-      with:
-        flags: roller
-  compile:
-    if: github.event_name == 'push' # will only be triggered when pushing to main & staging & develop & alpha
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions-rs/toolchain@v1
-      with:
-        toolchain: nightly-2022-12-10
-        override: true
-        components: rustfmt, clippy
-    - name: Install Go
-      uses: actions/setup-go@v2
-      with:
-        go-version: 1.19.x
-    - name: Checkout code
-      uses: actions/checkout@v2
-    - name: Cache cargo
-      uses: Swatinem/rust-cache@v2
-      with:
-        workspaces: "common/libzkp/impl -> target"
-    - name: Test
-      run: |
-        make roller
-  check:
-    if: github.event.pull_request.draft == false
-    runs-on: ubuntu-latest
-    steps:
-    - name: Install Go
-      uses: actions/setup-go@v2
-      with:
-        go-version: 1.19.x
-    - name: Checkout code
-      uses: actions/checkout@v2
-    - name: Lint
-      run: |
-        rm -rf $HOME/.cache/golangci-lint
-        make lint
-  goimports-lint:
-    if: github.event.pull_request.draft == false
-    runs-on: ubuntu-latest
-    steps:
-    - name: Install Go
-      uses: actions/setup-go@v2
-      with:
-        go-version: 1.19.x
-    - name: Checkout code
-      uses: actions/checkout@v2
-    - name: Install goimports
-      run: go install golang.org/x/tools/cmd/goimports
-    - run: goimports -local scroll-tech/roller/ -w .
-    - run: go mod tidy
-    # If there are any diffs from goimports or go mod tidy, fail.
-    - name: Verify no changes from goimports and go mod tidy
-      run: |
-        if [ -n "$(git status --porcelain)" ]; then
-          exit 1
-        fi

.github/workflows/rollup.yml

@@ -1,4 +1,4 @@
-name: Bridge
+name: Rollup
 
 on:
   push:
@@ -8,10 +8,11 @@ on:
       - develop
       - alpha
     paths:
-      - 'bridge/**'
+      - 'rollup/**'
       - 'common/**'
+      - '!common/version/version.go'
       - 'database/**'
-      - '.github/workflows/bridge.yml'
+      - '.github/workflows/rollup.yml'
   pull_request:
     types:
       - opened
@@ -19,10 +20,11 @@ on:
       - synchronize
       - ready_for_review
     paths:
-      - 'bridge/**'
+      - 'rollup/**'
       - 'common/**'
+      - '!common/version/version.go'
       - 'database/**'
-      - '.github/workflows/bridge.yml'
+      - '.github/workflows/rollup.yml'
 
 jobs:
   check:
@@ -32,19 +34,19 @@ jobs:
     - name: Install Go
       uses: actions/setup-go@v2
       with:
-        go-version: 1.19.x
+        go-version: 1.21.x
     - name: Checkout code
-      uses: actions/checkout@v2
+      uses: actions/checkout@v4
     - name: Install Solc
       uses: supplypike/setup-bin@v3
       with:
-        uri: 'https://github.com/ethereum/solidity/releases/download/v0.8.16/solc-static-linux'
+        uri: 'https://github.com/ethereum/solidity/releases/download/v0.8.24/solc-static-linux'
         name: 'solc'
-        version: '0.8.16'
+        version: '0.8.24'
     - name: Install Geth Tools
       uses: gacts/install-geth-tools@v1
     - name: Lint
-      working-directory: 'bridge'
+      working-directory: 'rollup'
       run: |
         rm -rf $HOME/.cache/golangci-lint
         make mock_abi
@@ -56,20 +58,20 @@ jobs:
     - name: Install Go
       uses: actions/setup-go@v2
       with:
-        go-version: 1.19.x
+        go-version: 1.21.x
     - name: Checkout code
-      uses: actions/checkout@v2
+      uses: actions/checkout@v4
     - name: Install goimports
       run: go install golang.org/x/tools/cmd/goimports
     - name: Run goimports lint
-      run: goimports -local scroll-tech/bridge/ -w .
-      working-directory: 'bridge'
+      run: goimports -local scroll-tech/rollup/ -w .
+      working-directory: 'rollup'
     - name: Run go mod tidy
       run: go mod tidy
-      working-directory: 'bridge'
+      working-directory: 'rollup'
     # If there are any diffs from goimports or go mod tidy, fail.
     - name: Verify no changes from goimports and go mod tidy
-      working-directory: 'bridge'
+      working-directory: 'rollup'
       run: |
         if [ -n "$(git status --porcelain)" ]; then
           exit 1
@@ -81,41 +83,41 @@ jobs:
     - name: Install Go
       uses: actions/setup-go@v2
       with:
-        go-version: 1.18.x
+        go-version: 1.21.x
     - name: Checkout code
-      uses: actions/checkout@v2
+      uses: actions/checkout@v4
     - name: Install Solc
       uses: supplypike/setup-bin@v3
       with:
-        uri: 'https://github.com/ethereum/solidity/releases/download/v0.8.16/solc-static-linux'
+        uri: 'https://github.com/ethereum/solidity/releases/download/v0.8.24/solc-static-linux'
         name: 'solc'
-        version: '0.8.16'
+        version: '0.8.24'
     - name: Install Geth Tools
       uses: gacts/install-geth-tools@v1
     - name: Build prerequisites
       run: |
         make dev_docker
-        make -C bridge mock_abi
-    - name: Build bridge binaries
-      working-directory: 'bridge'
+        make -C rollup mock_abi
+    - name: Build rollup binaries
+      working-directory: 'rollup'
       run: |
-        make bridge_bins
-    - name: Test bridge packages
-      working-directory: 'bridge'
+        make rollup_bins
+    - name: Test rollup packages
+      working-directory: 'rollup'
       run: |
-        go test -v -race -gcflags="-l" -ldflags="-s=false" -coverprofile=coverage.txt -covermode=atomic ./...
+        make test
     - name: Upload coverage reports to Codecov
       uses: codecov/codecov-action@v3
       env:
         CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
       with:
-        flags: bridge
+        flags: rollup
   # docker-build:
   #   if: github.event.pull_request.draft == false
   #   runs-on: ubuntu-latest
   #   steps:
   #   - name: Checkout code
-  #     uses: actions/checkout@v2
+  #     uses: actions/checkout@v4
   #   - name: Set up Docker Buildx
   #     uses: docker/setup-buildx-action@v2
   #   - run: make docker

.gitignore

@@ -1,9 +1,27 @@
-.idea
+# Asset files
 assets/params*
 assets/seed
-coverage.txt
+
+# Built binaries
 build/bin
+verifier.test
+core.test
+
+coverage.txt
 *.integration.txt
 
+# Visual Studio Code
+.vscode
+
+# IntelliJ
+.idea
+
+# MacOS
+.DS_Store
+
 # misc
 sftp-config.json
+*~
+
+target
+zkvm-prover/config.json

.gitmodules

@@ -1,15 +1,3 @@
-[submodule "l2geth"]
-	path = l2geth
-	url = git@github.com:scroll-tech/go-ethereum.git
-[submodule "rpc-gateway"]
-	path = rpc-gateway
-	url = git@github.com:scroll-tech/rpc-gateway.git
-[submodule "contracts/lib/ds-test"]
-	path = contracts/lib/ds-test
-	url = https://github.com/dapphub/ds-test
-[submodule "contracts/lib/forge-std"]
-	path = contracts/lib/forge-std
-	url = https://github.com/foundry-rs/forge-std
-[submodule "contracts/lib/solmate"]
-	path = contracts/lib/solmate
-	url = https://github.com/rari-capital/solmate
+[submodule "scroll-contracts"]
+	path = scroll-contracts
+	url = https://github.com/scroll-tech/scroll-contracts.git

CODE_OF_CONDUCT.md

@@ -0,0 +1,128 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, religion, or sexual identity
+and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the
+  overall community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or
+  advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email
+  address, without their explicit permission
+* Other conduct that could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official e-mail address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+contributor@scroll.io.
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series
+of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or
+permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior,  harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within
+the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.0, available at
+https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+
+Community Impact Guidelines were inspired by [Mozilla's code of conduct
+enforcement ladder](https://github.com/mozilla/diversity).
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see the FAQ at
+https://www.contributor-covenant.org/faq. Translations are available at
+https://www.contributor-covenant.org/translations.

CONTRIBUTING.md

@@ -0,0 +1,43 @@
+## Contributing
+
+[fork]: /fork
+[pr]: /compare
+[style]: https://standardjs.com/
+[code-of-conduct]: CODE_OF_CONDUCT.md
+
+Hi there! We're thrilled that you'd like to contribute to this project. Your help is essential for keeping it great.
+
+Please note that this project is released with a [Contributor Code of Conduct][code-of-conduct]. By participating in this project you agree to abide by its terms.
+
+## Contribute to Scroll
+
+Did you know there are many ways of contributing to Scroll? If you are looking to contribute to by adding Scroll to existing Dev Tools or by doing integrations please go to the [Contribute to Scroll](https://github.com/scroll-tech/contribute-to-scroll) repo instead. This repository covers the Scroll infrastructure and smart contracts, if you want to contribute to these areas continue reading this document.
+
+## Issues and PRs
+
+If you have suggestions for how this project could be improved, or want to report a bug, open an issue! We'd love all and any contributions. If you have questions, too, we'd love to hear them.
+
+We'd also love PRs. If you're thinking of a large PR, we advise opening up an issue first to talk about it, though! Look at the links below if you're not sure how to open a PR.
+
+## Submitting a pull request
+
+1. [Fork][fork] and clone the repository.
+2. Create a new branch: `git checkout -b my-branch-name`.
+3. Make your change, add tests, and make sure the tests still pass.
+4. Format your code in scroll home directory: `make lint && make fmt`
+5. Push to your fork and [submit a pull request][pr].
+6. Pat yourself on the back and wait for your pull request to be reviewed and merged.
+
+Here are a few things you can do that will increase the likelihood of your pull request being accepted:
+
+- Write and update tests.
+- Keep your changes as focused as possible. If there are multiple changes you would like to make that are not dependent upon each other, consider submitting them as separate pull requests.
+- Write a [good commit message](http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html).
+
+Work in Progress pull requests are also welcome to get feedback early on, or if there is something that blocked you.
+
+## Resources
+
+- [How to Contribute to Open Source](https://opensource.guide/how-to-contribute/)
+- [Using Pull Requests](https://help.github.com/articles/about-pull-requests/)
+- [GitHub Help](https://help.github.com)

Cargo.toml

@@ -0,0 +1,68 @@
+[workspace]
+members = [
+  "crates/libzkp",
+  "crates/l2geth",
+  "crates/libzkp_c",
+  "crates/prover-bin",
+]
+
+resolver = "2"
+
+[workspace.package]
+authors = ["Scroll developers"]
+edition = "2021"
+homepage = "https://scroll.io"
+readme = "README.md"
+repository = "https://github.com/scroll-tech/scroll"
+version = "4.5.8"
+
+[workspace.dependencies]
+scroll-zkvm-prover = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "ad0efe7" }
+scroll-zkvm-verifier = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "ad0efe7" }
+scroll-zkvm-types = { git = "https://github.com/scroll-tech/zkvm-prover", rev = "ad0efe7" }
+
+sbv-primitives = { git = "https://github.com/scroll-tech/stateless-block-verifier", branch = "chore/openvm-1.3", features = ["scroll"] }
+sbv-utils = { git = "https://github.com/scroll-tech/stateless-block-verifier", branch = "chore/openvm-1.3" }
+
+metrics = "0.23.0"
+metrics-util = "0.17"
+metrics-tracing-context = "0.16.0"
+
+anyhow = "1.0"
+alloy = { version = "1", default-features = false }
+alloy-primitives = { version = "1.2", default-features = false, features = ["tiny-keccak"] }
+# also use this to trigger "serde" feature for primitives
+alloy-serde = { version = "1", default-features = false }
+
+serde = { version = "1", default-features = false, features = ["derive"] }
+serde_json = { version = "1.0" }
+serde_derive = "1.0"
+serde_with = "3.11.0"
+itertools = "0.14"
+tiny-keccak = "2.0"
+tracing = "0.1"
+eyre = "0.6"
+once_cell = "1.20"
+base64 = "0.22"
+
+[patch.crates-io]
+revm = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v78" }
+revm-bytecode = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v78" }
+revm-context = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v78" }
+revm-context-interface = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v78" }
+revm-database = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v78" }
+revm-database-interface = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v78" }
+revm-handler = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v78" }
+revm-inspector = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v78" }
+revm-interpreter = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v78" }
+revm-precompile = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v78" }
+revm-primitives = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v78" }
+revm-state = { git = "https://github.com/scroll-tech/revm", branch = "feat/reth-v78" }
+
+ruint = { git = "https://github.com/scroll-tech/uint.git", branch = "v1.15.0" }
+alloy-primitives = { git = "https://github.com/scroll-tech/alloy-core", branch = "v1.2.0" }
+
+[profile.maxperf]
+inherits = "release"
+lto = "fat"
+codegen-units = 1

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2022 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

Makefile

@@ -1,42 +1,47 @@
-.PHONY: check update dev_docker build_test_docker run_test_docker clean
+.PHONY: fmt dev_docker build_test_docker run_test_docker clean update
+
+L2GETH_TAG=scroll-v5.8.23
 
 help: ## Display this help message
 	@grep -h \
 		-E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | \
 		awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}'
+update: ## Update dependencies
+	go work sync
+	cd $(PWD)/bridge-history-api/ && go get github.com/scroll-tech/go-ethereum@${L2GETH_TAG} && go mod tidy
+	cd $(PWD)/common/ && go get github.com/scroll-tech/go-ethereum@${L2GETH_TAG}&& go mod tidy
+	cd $(PWD)/coordinator/ && go get github.com/scroll-tech/go-ethereum@${L2GETH_TAG} && go mod tidy
+	cd $(PWD)/database/ && go get github.com/scroll-tech/go-ethereum@${L2GETH_TAG} && go mod tidy
+	cd $(PWD)/rollup/ && go get github.com/scroll-tech/go-ethereum@${L2GETH_TAG} && go mod tidy
+	cd $(PWD)/tests/integration-test/ && go get github.com/scroll-tech/go-ethereum@${L2GETH_TAG} && go mod tidy
 
-lint: ## The code's format and security checks.
-	make -C bridge lint
+lint: ## The code's format and security checks
+	make -C rollup lint
 	make -C common lint
 	make -C coordinator lint
 	make -C database lint
-	make -C roller lint
 	make -C bridge-history-api lint
 
-update: ## update dependencies
+fmt: ## Format the code
 	go work sync
-	cd $(PWD)/bridge/ && go get -u github.com/scroll-tech/go-ethereum@scroll-v4.1.0 && go mod tidy
-	cd $(PWD)/bridge-history-api/ && go get -u github.com/ethereum/go-ethereum@latest && go mod tidy
-	cd $(PWD)/common/ && go get -u github.com/scroll-tech/go-ethereum@scroll-v4.1.0 && go mod tidy
-	cd $(PWD)/coordinator/ && go get -u github.com/scroll-tech/go-ethereum@scroll-v4.1.0 && go mod tidy
-	cd $(PWD)/database/ && go get -u github.com/scroll-tech/go-ethereum@scroll-v4.1.0 && go mod tidy
-	cd $(PWD)/roller/ && go get -u github.com/scroll-tech/go-ethereum@scroll-v4.1.0 && go mod tidy
-	goimports -local $(PWD)/bridge/ -w .
-	goimports -local $(PWD)/bridge-history-api/ -w .
-	goimports -local $(PWD)/common/ -w .
-	goimports -local $(PWD)/coordinator/ -w .
-	goimports -local $(PWD)/database/ -w .
-	goimports -local $(PWD)/roller/ -w .
+	cd $(PWD)/bridge-history-api/ && go mod tidy
+	cd $(PWD)/common/ && go mod tidy
+	cd $(PWD)/coordinator/ && go mod tidy
+	cd $(PWD)/database/ && go mod tidy
+	cd $(PWD)/rollup/ && go mod tidy
+	cd $(PWD)/tests/integration-test/ && go mod tidy
 
-dev_docker: ## build docker images for development/testing usages
-	docker build -t scroll_l1geth ./common/docker/l1geth/
-	docker build -t scroll_l2geth ./common/docker/l2geth/
+	goimports -local scroll-tech/bridge-history-api/ -w .
+	goimports -local scroll-tech/common/ -w .
+	goimports -local scroll-tech/coordinator/ -w .
+	goimports -local scroll-tech/database/ -w .
+	goimports -local scroll-tech/rollup/ -w .
+	goimports -local scroll-tech/tests/integration-test/ -w .
 
-build_test_docker: ## build Docker image for local testing on M1/M2 Silicon Mac
-	docker build -t scroll_test_image -f ./build/dockerfiles/local_testing.Dockerfile $$(mktemp -d)
-
-run_test_docker: ## run Docker image for local testing on M1/M2 Silicon Mac
-	docker run -it --rm --name scroll_test_container --network=host -v /var/run/docker.sock:/var/run/docker.sock -v $(PWD):/go/src/app scroll_test_image
+dev_docker: ## Build docker images for development/testing usages
+	docker pull postgres
+	docker build -t scroll_l1geth --platform linux/amd64 ./common/testcontainers/docker/l1geth/
+	docker build -t scroll_l2geth --platform linux/amd64 ./common/testcontainers/docker/l2geth/
 
 clean: ## Empty out the bin folder
 	@rm -rf build/bin

README.md

@@ -1,10 +1,34 @@
 # Scroll Monorepo
 
+[![rollup](https://github.com/scroll-tech/scroll/actions/workflows/rollup.yml/badge.svg)](https://github.com/scroll-tech/scroll/actions/workflows/rollup.yml)
+[![bridge-history](https://github.com/scroll-tech/scroll/actions/workflows/bridge_history_api.yml/badge.svg)](https://github.com/scroll-tech/scroll/actions/workflows/bridge_history_api.yml)
+[![coordinator](https://github.com/scroll-tech/scroll/actions/workflows/coordinator.yml/badge.svg)](https://github.com/scroll-tech/scroll/actions/workflows/coordinator.yml)
+[![prover](https://github.com/scroll-tech/scroll/actions/workflows/prover.yml/badge.svg)](https://github.com/scroll-tech/scroll/actions/workflows/prover.yml)
+[![integration](https://github.com/scroll-tech/scroll/actions/workflows/integration.yml/badge.svg)](https://github.com/scroll-tech/scroll/actions/workflows/integration.yml)
 [![codecov](https://codecov.io/gh/scroll-tech/scroll/branch/develop/graph/badge.svg?token=VJVHNQWGGW)](https://codecov.io/gh/scroll-tech/scroll)
 
+<a href="https://scroll.io">Scroll</a> is a zkRollup Layer 2 dedicated to enhance Ethereum scalability through a bytecode-equivalent [zkEVM](https://github.com/scroll-tech/zkevm-circuits) circuit. This monorepo encompasses essential infrastructure components of the Scroll protocol. It contains the L1 and L2 contracts, the rollup node, the prover client, and the prover coordinator.
+
+## Directory Structure
+
+<pre>
+├── <a href="./bridge-history-api/">bridge-history-api</a>: Bridge history service that collects deposit and withdraw events from both L1 and L2 chains and generates withdrawal proofs
+├── <a href="./common/">common</a>: Common libraries and types
+├── <a href="./coordinator/">coordinator</a>: Prover coordinator service that dispatches proving tasks to provers
+├── <a href="./database">database</a>: Database client and schema definition
+├── <a href="./prover">prover</a>: Prover client that runs proof generation for zkEVM circuit and aggregation circuit
+├── <a href="./rollup">rollup</a>: Rollup-related services
+├── <a href="https://github.com/scroll-tech/scroll-contracts.git">scroll-contracts</a>: solidity code for Scroll L1 bridge and rollup contracts and L2 bridge and pre-deployed contracts.
+└── <a href="./tests">tests</a>: Integration tests
+</pre>
+
+## Contributing
+
+We welcome community contributions to this repository. Before you submit any issues or PRs, please read the [Code of Conduct](CODE_OF_CONDUCT.md) and the [Contribution Guideline](CONTRIBUTING.md).
+
 ## Prerequisites
-+ Go 1.19
-+ Rust (for version, see [rust-toolchain](./common/libzkp/impl/rust-toolchain))
++ Go 1.21
++ Rust (for version, see [rust-toolchain](./rust-toolchain))
 + Hardhat / Foundry
 + Docker
 
@@ -15,54 +39,17 @@ docker pull postgres
 make dev_docker
 ```
 
-## Testing Bridge & Coordinator
-
-### For Non-Apple Silicon (M1/M2) Macs
+## Unit Tests
 
 Run the tests using the following commands:
 
 ```bash
-go test -v -race -covermode=atomic scroll-tech/bridge/...
+go test -v -race -covermode=atomic scroll-tech/rollup/...
 go test -tags="mock_verifier" -v -race -covermode=atomic scroll-tech/coordinator/...
 go test -v -race -covermode=atomic scroll-tech/database/...
 go test -v -race -covermode=atomic scroll-tech/common/...
 ```
 
-### For Apple Silicon (M1/M2) Macs
+## License
 
-To run tests on Apple Silicon Macs, build and execute the Docker image as outlined below:
-
-#### Build a Docker Image for Testing
-
-Use the following command to build a Docker image:
-
-```bash
-make build_test_docker
-```
-
-This command builds a Docker image named `scroll_test_image` using the Dockerfile found at `./build/dockerfiles/local_test.Dockerfile`.
-
-#### Run Docker Image
-
-After the image is built, run a Docker container from it:
-
-```bash
-make run_test_docker
-```
-
-This command runs a Docker container named `scroll_test_container` from the `scroll_test_image` image. The container uses the host network and has access to the Docker socket and the current directory.
-
-Once the Docker container is running, execute the tests using the following commands:
-
-```bash
-go test -v -race -covermode=atomic scroll-tech/bridge/...
-go test -tags="mock_verifier" -v -race -covermode=atomic scroll-tech/coordinator/...
-go test -v -race -covermode=atomic scroll-tech/database/...
-go test -v -race -covermode=atomic scroll-tech/common/...
-```
-
-## Testing Contracts
-
-You can find the unit tests in [`<REPO_DIR>/contracts/src/test/`](/contracts/src/test/), and integration tests in [`<REPO_DIR>/contracts/integration-test/`](/contracts/integration-test/).
-
-For more details on contracts, see [`/contracts`](/contracts).
+Scroll Monorepo is licensed under the [MIT](./LICENSE) license.

bridge-history-api/Makefile

@@ -1,6 +1,7 @@
 .PHONY: lint
 REPO_ROOT_DIR=./..
 IMAGE_VERSION=latest
+PWD=$(shell pwd)
 
 lint: ## Lint the files - used for CI
 	GOBIN=$(PWD)/build/bin go run ../build/lint.go
@@ -11,16 +12,31 @@ test:
 bridgehistoryapi-db-cli:
 	go build -o $(PWD)/build/bin/bridgehistoryapi-db-cli ./cmd/db_cli
 	
-bridgehistoryapi-cross-msg-fetcher:
-	go build -o $(PWD)/build/bin/bridgehistoryapi-cross-msg-fetcher ./cmd/cross_msg_fetcher
+bridgehistoryapi-fetcher:
+	go build -o $(PWD)/build/bin/bridgehistoryapi-fetcher ./cmd/fetcher
 
-bridgehistoryapi-server:
-	go build -o $(PWD)/build/bin/bridgehistoryapi-server ./cmd/backend_server
+bridgehistoryapi-api:
+	go build -o $(PWD)/build/bin/bridgehistoryapi-api ./cmd/api
 
-db-docker:
+reset-env:
+	if docker ps -a -q -f name=bridgehistoryapi-redis | grep -q . ; then \
+		docker stop bridgehistoryapi-redis; \
+		docker rm bridgehistoryapi-redis; \
+	fi
+	docker run --name bridgehistoryapi-redis -d -p 6379:6379 redis:latest
+	if docker ps -a -q -f name=bridgehistoryapi-history-db | grep -q . ; then \
+		docker stop bridgehistoryapi-history-db; \
+		docker rm bridgehistoryapi-history-db; \
+	fi
 	docker run --name bridgehistoryapi-history-db -p 5444:5432 -e POSTGRES_PASSWORD=123456 -e POSTGRES_DB=test -d postgres
+	until docker exec bridgehistoryapi-history-db pg_isready -h localhost -p 5432 -U postgres > /dev/null; do \
+		echo "Waiting for postgres to be ready..."; \
+		sleep 1; \
+	done
+	echo "Postgres is ready."
+	go build -o $(PWD)/build/bin/bridgehistoryapi-db-cli ./cmd/db_cli && $(PWD)/build/bin/bridgehistoryapi-db-cli reset
 
 bridgehistoryapi-docker:
-	DOCKER_BUILDKIT=1 docker build -t scrolltech/bridgehistoryapi-cross-msg-fetcher:${IMAGE_VERSION} ${REPO_ROOT_DIR}/ -f ${REPO_ROOT_DIR}/build/dockerfiles/bridgehistoryapi-cross-msg-fetcher.Dockerfile
-	DOCKER_BUILDKIT=1 docker build -t scrolltech/bridgehistoryapi-server:${IMAGE_VERSION} ${REPO_ROOT_DIR}/ -f ${REPO_ROOT_DIR}/build/dockerfiles/bridgehistoryapi-server.Dockerfile
-	DOCKER_BUILDKIT=1 docker build -t scrolltech/bridgehistoryapi-db-cli:${IMAGE_VERSION} ${REPO_ROOT_DIR}/ -f ${REPO_ROOT_DIR}/build/dockerfiles/bridgehistoryapi-db-cli.Dockerfile
+	DOCKER_BUILDKIT=1 docker build -t scrolltech/bridgehistoryapi-fetcher:${IMAGE_VERSION} ${REPO_ROOT_DIR}/ -f ${REPO_ROOT_DIR}/build/dockerfiles/bridgehistoryapi-fetcher.Dockerfile --platform=linux/amd64
+	DOCKER_BUILDKIT=1 docker build -t scrolltech/bridgehistoryapi-api:${IMAGE_VERSION} ${REPO_ROOT_DIR}/ -f ${REPO_ROOT_DIR}/build/dockerfiles/bridgehistoryapi-api.Dockerfile --platform=linux/amd64
+	DOCKER_BUILDKIT=1 docker build -t scrolltech/bridgehistoryapi-db-cli:${IMAGE_VERSION} ${REPO_ROOT_DIR}/ -f ${REPO_ROOT_DIR}/build/dockerfiles/bridgehistoryapi-db-cli.Dockerfile --platform=linux/amd64

bridge-history-api/README.md

@@ -1 +1,128 @@
 # bridge-history-api
+
+This directory contains the `bridge-history-api` service that provides REST APIs to query txs interact with Scroll official bridge contracts
+
+## Instructions
+The bridge-history-api contains three distinct components
+
+### bridgehistoryapi-db-cli
+
+Provide init, show version, rollback, and check status services of DB
+```
+    cd ./bridge-history-api
+    make bridgehistoryapi-db-cli
+    ./build/bin/bridgehistoryapi-db-cli [command]
+```
+
+### bridgehistoryapi-fetcher
+
+Fetch the transactions from both L1 and L2
+```
+    cd ./bridge-history-api
+    make bridgehistoryapi-fetcher
+    ./build/bin/bridgehistoryapi-fetcher
+```
+
+### bridgehistoryapi-api
+
+provides REST APIs. Please refer to the API details below.
+```
+    cd ./bridge-history-api
+    make bridgehistoryapi-api
+    ./build/bin/bridgehistoryapi-api
+```
+
+## APIs provided by bridgehistoryapi-api
+
+1. `/api/txs`
+```
+// @Summary    	 get all txs under the given address
+// @Accept       plain
+// @Produce      plain
+// @Param        address query string true "wallet address"
+// @Param        page_size query int true "page size"
+// @Param        page query int true "page"
+// @Success      200
+// @Router       /api/txs [get]
+```
+
+2. `/api/l2/withdrawals`
+```
+// @Summary    	 get all L2 withdrawals under given address
+// @Accept       plain
+// @Produce      plain
+// @Param        address query string true "wallet address"
+// @Param        page_size query int true "page size"
+// @Param        page query int true "page"
+// @Success      200
+// @Router       /api/l2/withdrawals [get]
+```
+
+3. `/api/l2/unclaimed/withdrawals`
+```
+// @Summary    	 get all L2 unclaimed withdrawals under the given address
+// @Accept       plain
+// @Produce      plain
+// @Param        address query string true "wallet address"
+// @Param        page_size query int true "page size"
+// @Param        page query int true "page"
+// @Success      200
+// @Router       /api/l2/unclaimed/withdrawals [get]
+```
+
+4. `/api/txsbyhashes`
+```
+// @Summary    	 get txs by given tx hashes
+// @Accept       plain
+// @Produce      plain
+// @Param        hashes query string array true "array of hashes"
+// @Success      200
+// @Router       /api/txsbyhashes [post]
+```
+
+## Running bridge-history-api locally
+
+1. Pull the latest Redis image:
+   ```
+   docker pull redis:latest
+   ```
+
+2. Run the Redis container:
+   ```
+   docker run --name bridgehistoryapi-redis -d -p 6379:6379 redis:latest
+   ```
+
+3. Pull the latest PostgreSQL image:
+   ```
+   docker pull postgres:latest
+   ```
+
+4. Run the PostgreSQL container:
+   ```
+   docker run --name bridgehistoryapi-history-db -p 5444:5432 -e POSTGRES_PASSWORD=123456 -e POSTGRES_DB=test -d postgres
+   ```
+
+5. Run database migrations to initialize the tables:
+   ```
+   make bridgehistoryapi-db-cli
+   ./build/bin/bridgehistoryapi-db-cli migrate
+   ```
+
+6. Run bridgehistoryapi-fetcher:
+   ```
+   make bridgehistoryapi-fetcher
+   ./build/bin/bridgehistoryapi-fetcher
+   ```
+
+7. Run bridgehistoryapi-api:
+   ```
+   make bridgehistoryapi-api
+   ./build/bin/bridgehistoryapi-api
+   ```
+
+The endpoints provided in [./conf/config.json](./conf/config.json) are all public endpoints and have rate limits.
+
+For production usage:
+
+- For L1 endpoints, utilizing a service provider's free tier should suffice.
+- For L2 endpoints, consider [running a Scroll L2geth node](https://docs.scroll.xyz/en/developers/guides/running-a-scroll-node) and using the exposed HTTP port.

bridge-history-api/abi/backend_abi_test.go

@@ -0,0 +1,13 @@
+package backendabi
+
+import (
+	"testing"
+
+	"github.com/scroll-tech/go-ethereum/crypto"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestEventSignatures(t *testing.T) {
+	assert.Equal(t, crypto.Keccak256Hash([]byte("RevertBatch(uint256,bytes32)")), L1RevertBatchV0EventSig)
+	assert.Equal(t, crypto.Keccak256Hash([]byte("RevertBatch(uint256,uint256)")), L1RevertBatchV7EventSig)
+}

bridge-history-api/cmd/api/app/app.go

@@ -0,0 +1,105 @@
+package app
+
+import (
+	"crypto/tls"
+	"fmt"
+	"os"
+	"os/signal"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"github.com/go-redis/redis/v8"
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/scroll-tech/go-ethereum/log"
+	"github.com/urfave/cli/v2"
+
+	"scroll-tech/common/database"
+	"scroll-tech/common/observability"
+	"scroll-tech/common/utils"
+
+	"scroll-tech/bridge-history-api/internal/config"
+	"scroll-tech/bridge-history-api/internal/controller/api"
+	"scroll-tech/bridge-history-api/internal/route"
+)
+
+var app *cli.App
+
+func init() {
+	app = cli.NewApp()
+
+	app.Action = action
+	app.Name = "Scroll Bridge History API Web Service"
+	app.Usage = "The Scroll Bridge History API Web Service"
+	app.Flags = append(app.Flags, utils.CommonFlags...)
+	app.Commands = []*cli.Command{}
+
+	app.Before = func(ctx *cli.Context) error {
+		return utils.LogSetup(ctx)
+	}
+}
+
+func action(ctx *cli.Context) error {
+	// Load config file.
+	cfgFile := ctx.String(utils.ConfigFileFlag.Name)
+	cfg, err := config.NewConfig(cfgFile)
+	if err != nil {
+		log.Crit("failed to load config file", "config file", cfgFile, "error", err)
+	}
+	db, err := database.InitDB(cfg.DB)
+	if err != nil {
+		log.Crit("failed to init db", "err", err)
+	}
+	defer func() {
+		if deferErr := database.CloseDB(db); deferErr != nil {
+			log.Error("failed to close db", "err", err)
+		}
+	}()
+	opts := &redis.Options{
+		Addr:         cfg.Redis.Address,
+		Username:     cfg.Redis.Username,
+		Password:     cfg.Redis.Password,
+		MinIdleConns: cfg.Redis.MinIdleConns,
+		ReadTimeout:  time.Duration(cfg.Redis.ReadTimeoutMs * int(time.Millisecond)),
+	}
+	// Production Redis service has enabled transit_encryption.
+	if !cfg.Redis.Local {
+		opts.TLSConfig = &tls.Config{
+			MinVersion:         tls.VersionTLS12,
+			InsecureSkipVerify: true, //nolint:gosec
+		}
+	}
+	log.Info("init redis client", "addr", opts.Addr, "user name", opts.Username, "is local", cfg.Redis.Local,
+		"min idle connections", opts.MinIdleConns, "read timeout", opts.ReadTimeout)
+	redisClient := redis.NewClient(opts)
+	api.InitController(db, redisClient)
+
+	router := gin.Default()
+	registry := prometheus.DefaultRegisterer
+	route.Route(router, cfg, registry)
+
+	go func() {
+		port := ctx.Int(utils.ServicePortFlag.Name)
+		if runServerErr := router.Run(fmt.Sprintf(":%d", port)); runServerErr != nil {
+			log.Crit("run http server failure", "error", runServerErr)
+		}
+	}()
+
+	observability.Server(ctx, db)
+
+	// Catch CTRL-C to ensure a graceful shutdown.
+	interrupt := make(chan os.Signal, 1)
+	signal.Notify(interrupt, os.Interrupt)
+
+	// Wait until the interrupt signal is received from an OS signal.
+	<-interrupt
+
+	return nil
+}
+
+// Run bridge-history-backend api cmd instance.
+func Run() {
+	if err := app.Run(os.Args); err != nil {
+		_, _ = fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+}

bridge-history-api/cmd/api/main.go

@@ -0,0 +1,7 @@
+package main
+
+import "scroll-tech/bridge-history-api/cmd/api/app"
+
+func main() {
+	app.Run()
+}

bridge-history-api/cmd/backend_server/app/app.go

@@ -1,121 +0,0 @@
-package app
-
-import (
-	"fmt"
-	"os"
-
-	"github.com/ethereum/go-ethereum/log"
-	"github.com/iris-contrib/middleware/cors"
-	"github.com/kataras/iris/v12"
-	"github.com/kataras/iris/v12/mvc"
-	"github.com/urfave/cli/v2"
-
-	"bridge-history-api/config"
-	"bridge-history-api/controller"
-	"bridge-history-api/db"
-	"bridge-history-api/service"
-	cutils "bridge-history-api/utils"
-)
-
-var (
-	app *cli.App
-)
-
-var database db.OrmFactory
-
-func pong(ctx iris.Context) {
-	_, err := ctx.WriteString("pong")
-	if err != nil {
-		log.Error("failed to write pong", "err", err)
-	}
-}
-
-func setupQueryByAddressHandler(backendApp *mvc.Application) {
-	// Register Dependencies.
-	backendApp.Register(
-		database,
-		service.NewHistoryService,
-	)
-
-	// Register Controllers.
-	backendApp.Handle(new(controller.QueryAddressController))
-}
-
-func setupQueryClaimableHandler(backendApp *mvc.Application) {
-	// Register Dependencies.
-	backendApp.Register(
-		database,
-		service.NewHistoryService,
-	)
-
-	// Register Controllers.
-	backendApp.Handle(new(controller.QueryClaimableController))
-}
-
-func setupQueryByHashHandler(backendApp *mvc.Application) {
-	backendApp.Register(
-		database,
-		service.NewHistoryService,
-	)
-	backendApp.Handle(new(controller.QueryHashController))
-}
-
-func init() {
-	app = cli.NewApp()
-
-	app.Action = action
-	app.Name = "Scroll Bridge History Web Service"
-	app.Usage = "The Scroll Bridge History Web Service"
-	app.Flags = append(app.Flags, cutils.CommonFlags...)
-	app.Commands = []*cli.Command{}
-
-	app.Before = func(ctx *cli.Context) error {
-		return cutils.LogSetup(ctx)
-	}
-}
-
-func action(ctx *cli.Context) error {
-	corsOptions := cors.New(cors.Options{
-		AllowedOrigins:   []string{"*"},
-		AllowedMethods:   []string{"GET", "POST", "PUT", "DELETE"},
-		AllowCredentials: true,
-	})
-	// Load config file.
-	cfgFile := ctx.String(cutils.ConfigFileFlag.Name)
-	cfg, err := config.NewConfig(cfgFile)
-	if err != nil {
-		log.Crit("failed to load config file", "config file", cfgFile, "error", err)
-	}
-	database, err = db.NewOrmFactory(cfg)
-	if err != nil {
-		log.Crit("can not connect to database", "err", err)
-	}
-	defer func() {
-		if err = database.Close(); err != nil {
-			log.Error("failed to close database", "err", err)
-		}
-	}()
-	bridgeApp := iris.New()
-	bridgeApp.UseRouter(corsOptions)
-	bridgeApp.Get("/ping", pong).Describe("healthcheck")
-
-	mvc.Configure(bridgeApp.Party("/api/txs"), setupQueryByAddressHandler)
-	mvc.Configure(bridgeApp.Party("/api/txsbyhashes"), setupQueryByHashHandler)
-	mvc.Configure(bridgeApp.Party("/api/claimable"), setupQueryClaimableHandler)
-
-	// TODO: make debug mode configurable
-	err = bridgeApp.Listen(cfg.Server.HostPort, iris.WithLogLevel("debug"))
-	if err != nil {
-		log.Crit("can not start server", "err", err)
-	}
-
-	return nil
-}
-
-// Run event watcher cmd instance.
-func Run() {
-	if err := app.Run(os.Args); err != nil {
-		_, _ = fmt.Fprintln(os.Stderr, err)
-		os.Exit(1)
-	}
-}

bridge-history-api/cmd/backend_server/main.go

@@ -1,7 +0,0 @@
-package main
-
-import "bridge-history-api/cmd/backend_server/app"
-
-func main() {
-	app.Run()
-}

bridge-history-api/cmd/cross_msg_fetcher/app/app.go

@@ -1,139 +0,0 @@
-package app
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"os/signal"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/ethclient"
-	"github.com/ethereum/go-ethereum/log"
-	"github.com/urfave/cli/v2"
-
-	"bridge-history-api/config"
-	"bridge-history-api/crossmsg"
-	"bridge-history-api/crossmsg/messageproof"
-	"bridge-history-api/db"
-	cutils "bridge-history-api/utils"
-)
-
-var (
-	app *cli.App
-)
-
-func init() {
-	app = cli.NewApp()
-
-	app.Action = action
-	app.Name = "Scroll Bridge History API"
-	app.Usage = "The Scroll Bridge Web Backend"
-	app.Flags = append(app.Flags, cutils.CommonFlags...)
-	app.Commands = []*cli.Command{}
-
-	app.Before = func(ctx *cli.Context) error {
-		return cutils.LogSetup(ctx)
-	}
-}
-
-func action(ctx *cli.Context) error {
-	// Load config file.
-	cfgFile := ctx.String(cutils.ConfigFileFlag.Name)
-	cfg, err := config.NewConfig(cfgFile)
-	if err != nil {
-		log.Crit("failed to load config file", "config file", cfgFile, "error", err)
-	}
-	subCtx, cancel := context.WithCancel(ctx.Context)
-	defer cancel()
-
-	l1client, err := ethclient.Dial(cfg.L1.Endpoint)
-	if err != nil {
-		log.Crit("failed to connect l1 geth", "config file", cfgFile, "error", err)
-	}
-	l2client, err := ethclient.Dial(cfg.L2.Endpoint)
-	if err != nil {
-		log.Crit("failed to connect l2 geth", "config file", cfgFile, "error", err)
-	}
-
-	db, err := db.NewOrmFactory(cfg)
-	defer func() {
-		if deferErr := db.Close(); deferErr != nil {
-			log.Error("failed to close db", "err", err)
-		}
-	}()
-	if err != nil {
-		log.Crit("failed to connect to db", "config file", cfgFile, "error", err)
-	}
-
-	l1worker := &crossmsg.FetchEventWorker{F: crossmsg.L1FetchAndSaveEvents, G: crossmsg.GetLatestL1ProcessedHeight, Name: "L1 events fetch Worker"}
-
-	l2worker := &crossmsg.FetchEventWorker{F: crossmsg.L2FetchAndSaveEvents, G: crossmsg.GetLatestL2ProcessedHeight, Name: "L2 events fetch Worker"}
-
-	l1AddressList := []common.Address{
-		common.HexToAddress(cfg.L1.CustomERC20GatewayAddr),
-		common.HexToAddress(cfg.L1.ERC721GatewayAddr),
-		common.HexToAddress(cfg.L1.ERC1155GatewayAddr),
-		common.HexToAddress(cfg.L1.MessengerAddr),
-		common.HexToAddress(cfg.L1.ETHGatewayAddr),
-		common.HexToAddress(cfg.L1.StandardERC20Gateway),
-		common.HexToAddress(cfg.L1.WETHGatewayAddr),
-	}
-
-	l2AddressList := []common.Address{
-		common.HexToAddress(cfg.L2.CustomERC20GatewayAddr),
-		common.HexToAddress(cfg.L2.ERC721GatewayAddr),
-		common.HexToAddress(cfg.L2.ERC1155GatewayAddr),
-		common.HexToAddress(cfg.L2.MessengerAddr),
-		common.HexToAddress(cfg.L2.ETHGatewayAddr),
-		common.HexToAddress(cfg.L2.StandardERC20Gateway),
-		common.HexToAddress(cfg.L2.WETHGatewayAddr),
-	}
-
-	l1crossMsgFetcher, err := crossmsg.NewMsgFetcher(subCtx, cfg.L1, db, l1client, l1worker, l1AddressList, crossmsg.L1ReorgHandling)
-	if err != nil {
-		log.Crit("failed to create l1 cross message fetcher", "error", err)
-	}
-
-	go l1crossMsgFetcher.Start()
-	defer l1crossMsgFetcher.Stop()
-
-	l2crossMsgFetcher, err := crossmsg.NewMsgFetcher(subCtx, cfg.L2, db, l2client, l2worker, l2AddressList, crossmsg.L2ReorgHandling)
-	if err != nil {
-		log.Crit("failed to create l2 cross message fetcher", "error", err)
-	}
-
-	go l2crossMsgFetcher.Start()
-	defer l2crossMsgFetcher.Stop()
-
-	// BlockTimestamp fetcher for l1 and l2
-	l1BlockTimeFetcher := crossmsg.NewBlockTimestampFetcher(subCtx, cfg.L1.Confirmation, int(cfg.L1.BlockTime), l1client, db.UpdateL1BlockTimestamp, db.GetL1EarliestNoBlockTimestampHeight)
-	go l1BlockTimeFetcher.Start()
-	defer l1BlockTimeFetcher.Stop()
-
-	l2BlockTimeFetcher := crossmsg.NewBlockTimestampFetcher(subCtx, cfg.L2.Confirmation, int(cfg.L2.BlockTime), l2client, db.UpdateL2BlockTimestamp, db.GetL2EarliestNoBlockTimestampHeight)
-	go l2BlockTimeFetcher.Start()
-	defer l2BlockTimeFetcher.Stop()
-
-	// Proof updater and batch fetcher
-	l2msgProofUpdater := messageproof.NewMsgProofUpdater(subCtx, cfg.L1.Confirmation, cfg.BatchInfoFetcher.BatchIndexStartBlock, db)
-	batchFetcher := crossmsg.NewBatchInfoFetcher(subCtx, common.HexToAddress(cfg.BatchInfoFetcher.ScrollChainAddr), cfg.BatchInfoFetcher.BatchIndexStartBlock, cfg.L1.Confirmation, int(cfg.L1.BlockTime), l1client, db, l2msgProofUpdater)
-	go batchFetcher.Start()
-	defer batchFetcher.Stop()
-
-	// Catch CTRL-C to ensure a graceful shutdown.
-	interrupt := make(chan os.Signal, 1)
-	signal.Notify(interrupt, os.Interrupt)
-
-	// Wait until the interrupt signal is received from an OS signal.
-	<-interrupt
-
-	return nil
-}
-
-// Run event watcher cmd instance.
-func Run() {
-	if err := app.Run(os.Args); err != nil {
-		_, _ = fmt.Fprintln(os.Stderr, err)
-		os.Exit(1)
-	}
-}

bridge-history-api/cmd/cross_msg_fetcher/main.go

@@ -1,7 +0,0 @@
-package main
-
-import "bridge-history-api/cmd/cross_msg_fetcher/app"
-
-func main() {
-	app.Run()
-}

bridge-history-api/cmd/db_cli/app/app.go

@@ -6,17 +6,13 @@ import (
 
 	"github.com/urfave/cli/v2"
 
-	"bridge-history-api/utils"
+	"scroll-tech/common/utils"
 )
 
-var (
-	// Set up database app info.
-	app *cli.App
-)
+var app *cli.App
 
 func init() {
 	app = cli.NewApp()
-	// Set up database app info.
 	app.Name = "db_cli"
 	app.Usage = "The Scroll Bridge-history-api DB CLI"
 	app.Flags = append(app.Flags, utils.CommonFlags...)
@@ -30,37 +26,33 @@ func init() {
 			Name:   "reset",
 			Usage:  "Clean and reset database.",
 			Action: resetDB,
-			Flags:  []cli.Flag{&utils.ConfigFileFlag},
 		},
 		{
 			Name:   "status",
 			Usage:  "Check migration status.",
 			Action: checkDBStatus,
-			Flags:  []cli.Flag{&utils.ConfigFileFlag},
 		},
 		{
 			Name:   "version",
 			Usage:  "Display the current database version.",
 			Action: dbVersion,
-			Flags:  []cli.Flag{&utils.ConfigFileFlag},
 		},
 		{
 			Name:   "migrate",
 			Usage:  "Migrate the database to the latest version.",
 			Action: migrateDB,
-			Flags:  []cli.Flag{&utils.ConfigFileFlag},
 		},
 		{
 			Name:   "rollback",
 			Usage:  "Roll back the database to a previous <version>. Rolls back a single migration if no version specified.",
 			Action: rollbackDB,
 			Flags: []cli.Flag{
-				&utils.ConfigFileFlag,
 				&cli.IntFlag{
 					Name:  "version",
 					Usage: "Rollback to the specified version.",
 					Value: 0,
-				}},
+				},
+			},
 		},
 	}
 }

bridge-history-api/cmd/db_cli/app/client.go

@@ -1,14 +1,15 @@
 package app
 
 import (
-	"github.com/ethereum/go-ethereum/log"
-	"github.com/jmoiron/sqlx"
+	"github.com/scroll-tech/go-ethereum/log"
 	"github.com/urfave/cli/v2"
+	"gorm.io/gorm"
 
-	"bridge-history-api/config"
-	"bridge-history-api/db"
-	"bridge-history-api/db/migrate"
-	"bridge-history-api/utils"
+	"scroll-tech/common/database"
+	"scroll-tech/common/utils"
+
+	"scroll-tech/bridge-history-api/internal/config"
+	"scroll-tech/bridge-history-api/internal/orm/migrate"
 )
 
 func getConfig(ctx *cli.Context) (*config.Config, error) {
@@ -20,14 +21,8 @@ func getConfig(ctx *cli.Context) (*config.Config, error) {
 	return dbCfg, nil
 }
 
-func initDB(dbCfg *config.Config) (*sqlx.DB, error) {
-	factory, err := db.NewOrmFactory(dbCfg)
-	if err != nil {
-		return nil, err
-	}
-	log.Debug("Got db config from env", "driver name", dbCfg.DB.DriverName, "dsn", dbCfg.DB.DSN)
-
-	return factory.GetDB(), nil
+func initDB(dbCfg *database.Config) (*gorm.DB, error) {
+	return database.InitDB(dbCfg)
 }
 
 // resetDB clean or reset database.
@@ -36,11 +31,15 @@ func resetDB(ctx *cli.Context) error {
 	if err != nil {
 		return err
 	}
-	db, err := initDB(cfg)
+	gormDB, err := initDB(cfg.DB)
 	if err != nil {
 		return err
 	}
-	err = migrate.ResetDB(db.DB)
+	db, err := gormDB.DB()
+	if err != nil {
+		return err
+	}
+	err = migrate.ResetDB(db)
 	if err != nil {
 		return err
 	}
@@ -54,12 +53,15 @@ func checkDBStatus(ctx *cli.Context) error {
 	if err != nil {
 		return err
 	}
-	db, err := initDB(cfg)
+	gormDB, err := initDB(cfg.DB)
 	if err != nil {
 		return err
 	}
-
-	return migrate.Status(db.DB)
+	db, err := gormDB.DB()
+	if err != nil {
+		return err
+	}
+	return migrate.Status(db)
 }
 
 // dbVersion return the latest version
@@ -68,12 +70,15 @@ func dbVersion(ctx *cli.Context) error {
 	if err != nil {
 		return err
 	}
-	db, err := initDB(cfg)
+	gormDB, err := initDB(cfg.DB)
 	if err != nil {
 		return err
 	}
-
-	version, err := migrate.Current(db.DB)
+	db, err := gormDB.DB()
+	if err != nil {
+		return err
+	}
+	version, err := migrate.Current(db)
 	log.Info("show database version", "db version", version)
 
 	return err
@@ -85,12 +90,15 @@ func migrateDB(ctx *cli.Context) error {
 	if err != nil {
 		return err
 	}
-	db, err := initDB(cfg)
+	gormDB, err := initDB(cfg.DB)
 	if err != nil {
 		return err
 	}
-
-	return migrate.Migrate(db.DB)
+	db, err := gormDB.DB()
+	if err != nil {
+		return err
+	}
+	return migrate.Migrate(db)
 }
 
 // rollbackDB rollback db by version
@@ -99,10 +107,14 @@ func rollbackDB(ctx *cli.Context) error {
 	if err != nil {
 		return err
 	}
-	db, err := initDB(cfg)
+	gormDB, err := initDB(cfg.DB)
+	if err != nil {
+		return err
+	}
+	db, err := gormDB.DB()
 	if err != nil {
 		return err
 	}
 	version := ctx.Int64("version")
-	return migrate.Rollback(db.DB, &version)
+	return migrate.Rollback(db, &version)
 }

bridge-history-api/cmd/db_cli/main.go

@@ -1,6 +1,6 @@
 package main
 
-import "bridge-history-api/cmd/db_cli/app"
+import "scroll-tech/bridge-history-api/cmd/db_cli/app"
 
 func main() {
 	app.Run()

bridge-history-api/cmd/fetcher/app/app.go

@@ -0,0 +1,96 @@
+package app
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/signal"
+
+	"github.com/scroll-tech/go-ethereum/ethclient"
+	"github.com/scroll-tech/go-ethereum/log"
+	"github.com/urfave/cli/v2"
+
+	"scroll-tech/common/database"
+	"scroll-tech/common/observability"
+	"scroll-tech/common/utils"
+
+	"scroll-tech/bridge-history-api/internal/config"
+	"scroll-tech/bridge-history-api/internal/controller/fetcher"
+)
+
+var app *cli.App
+
+func init() {
+	app = cli.NewApp()
+
+	app.Action = action
+	app.Name = "Scroll Bridge History API Message Fetcher"
+	app.Usage = "The Scroll Bridge History API Message Fetcher"
+	app.Flags = append(app.Flags, utils.CommonFlags...)
+	app.Commands = []*cli.Command{}
+
+	app.Before = func(ctx *cli.Context) error {
+		return utils.LogSetup(ctx)
+	}
+}
+
+func action(ctx *cli.Context) error {
+	cfgFile := ctx.String(utils.ConfigFileFlag.Name)
+	cfg, err := config.NewConfig(cfgFile)
+	if err != nil {
+		log.Crit("failed to load config file", "config file", cfgFile, "error", err)
+	}
+	subCtx, cancel := context.WithCancel(ctx.Context)
+	defer cancel()
+
+	l1Client, err := ethclient.Dial(cfg.L1.Endpoint)
+	if err != nil {
+		log.Crit("failed to connect to L1 geth", "endpoint", cfg.L1.Endpoint, "err", err)
+	}
+
+	l2Client, err := ethclient.Dial(cfg.L2.Endpoint)
+	if err != nil {
+		log.Crit("failed to connect to L2 geth", "endpoint", cfg.L2.Endpoint, "err", err)
+	}
+
+	db, err := database.InitDB(cfg.DB)
+	if err != nil {
+		log.Crit("failed to init db", "err", err)
+	}
+	defer func() {
+		if deferErr := database.CloseDB(db); deferErr != nil {
+			log.Error("failed to close db", "err", err)
+		}
+	}()
+	if err != nil {
+		log.Crit("failed to connect to db", "config file", cfgFile, "error", err)
+	}
+
+	observability.Server(ctx, db)
+
+	l1MessageFetcher, err := fetcher.NewL1MessageFetcher(subCtx, cfg.L1, db, l1Client)
+	if err != nil {
+		log.Crit("failed to create L1MessageFetcher", "err", err)
+	}
+	go l1MessageFetcher.Start()
+
+	l2MessageFetcher := fetcher.NewL2MessageFetcher(subCtx, cfg.L2, db, l2Client)
+	go l2MessageFetcher.Start()
+
+	// Catch CTRL-C to ensure a graceful shutdown.
+	interrupt := make(chan os.Signal, 1)
+	signal.Notify(interrupt, os.Interrupt)
+
+	// Wait until the interrupt signal is received from an OS signal.
+	<-interrupt
+
+	return nil
+}
+
+// Run bridge-history-backend fetcher cmd instance.
+func Run() {
+	if err := app.Run(os.Args); err != nil {
+		_, _ = fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+}

bridge-history-api/cmd/fetcher/main.go

@@ -0,0 +1,7 @@
+package main
+
+import "scroll-tech/bridge-history-api/cmd/fetcher/app"
+
+func main() {
+	app.Run()
+}

bridge-history-api/conf/config.json

@@ -0,0 +1,62 @@
+{
+	"L1": {
+		"confirmation": 0,
+		"endpoint": "https://rpc.ankr.com/eth",
+		"startHeight": 18306000,
+		"blockTime": 12,
+		"fetchLimit": 16,
+		"MessengerAddr": "0x6774Bcbd5ceCeF1336b5300fb5186a12DDD8b367",
+		"ETHGatewayAddr": "0x7F2b8C31F88B6006c382775eea88297Ec1e3E905",
+		"WETHGatewayAddr": "0x7AC440cAe8EB6328de4fA621163a792c1EA9D4fE",
+		"StandardERC20GatewayAddr": "0xD8A791fE2bE73eb6E6cF1eb0cb3F36adC9B3F8f9",
+		"CustomERC20GatewayAddr": "0xb2b10a289A229415a124EFDeF310C10cb004B6ff",
+		"ERC721GatewayAddr": "0x6260aF48e8948617b8FA17F4e5CEa2d21D21554B",
+		"ERC1155GatewayAddr": "0xb94f7F6ABcb811c5Ac709dE14E37590fcCd975B6",
+		"USDCGatewayAddr": "0xf1AF3b23DE0A5Ca3CAb7261cb0061C0D779A5c7B",
+		"LIDOGatewayAddr": "0x6625C6332c9F91F2D27c304E729B86db87A3f504",
+		"DAIGatewayAddr": "0x67260A8B73C5B77B55c1805218A42A7A6F98F515",
+		"PufferGatewayAddr": "0xA033Ff09f2da45f0e9ae495f525363722Df42b2a",
+		"ScrollChainAddr": "0xa13BAF47339d63B743e7Da8741db5456DAc1E556",
+		"GatewayRouterAddr": "0xF8B1378579659D8F7EE5f3C929c2f3E332E41Fd6",
+		"MessageQueueAddr": "0x0d7E906BD9cAFa154b048cFa766Cc1E54E39AF9B",
+		"MessageQueueV2Addr": "0x0000000000000000000000000000000000000000",
+		"BatchBridgeGatewayAddr": "0x5Bcfd99c34cf7E06fc756f6f5aE7400504852bc4",
+		"GasTokenGatewayAddr": "0x0000000000000000000000000000000000000000",
+		"WrappedTokenGatewayAddr": "0x0000000000000000000000000000000000000000",
+		"BlobScanAPIEndpoint": "https://api.blobscan.com/blobs/"
+	},
+	"L2": {
+		"confirmation": 0,
+		"endpoint": "https://rpc.scroll.io",
+		"blockTime": 3,
+		"fetchLimit": 64,
+		"MessengerAddr": "0x781e90f1c8Fc4611c9b7497C3B47F99Ef6969CbC",
+		"ETHGatewayAddr": "0x6EA73e05AdC79974B931123675ea8F78FfdacDF0",
+		"WETHGatewayAddr": "0x7003E7B7186f0E6601203b99F7B8DECBfA391cf9",
+		"StandardERC20GatewayAddr": "0xE2b4795039517653c5Ae8C2A9BFdd783b48f447A",
+		"CustomERC20GatewayAddr": "0x64CCBE37c9A82D85A1F2E74649b7A42923067988",
+		"ERC721GatewayAddr": "0x7bC08E1c04fb41d75F1410363F0c5746Eae80582",
+		"ERC1155GatewayAddr": "0x62597Cc19703aF10B58feF87B0d5D29eFE263bcc",
+		"USDCGatewayAddr": "0x33B60d5Dd260d453cAC3782b0bDC01ce84672142",
+		"LIDOGatewayAddr": "0x8aE8f22226B9d789A36AC81474e633f8bE2856c9",
+		"DAIGatewayAddr": "0xaC78dff3A87b5b534e366A93E785a0ce8fA6Cc62",
+		"PufferGatewayAddr": "0x9eBf2f33526CD571f8b2ad312492cb650870CFd6",
+		"GatewayRouterAddr": "0x4C0926FF5252A435FD19e10ED15e5a249Ba19d79",
+		"MessageQueueAddr": "0x5300000000000000000000000000000000000000",
+		"BatchBridgeGatewayAddr": "0xa1a12158bE6269D7580C63eC5E609Cdc0ddD82bC"
+	},
+	"db": {
+		"dsn": "postgres://postgres:123456@localhost:5444/test?sslmode=disable",
+		"driverName": "postgres",
+		"maxOpenNum": 200,
+		"maxIdleNum": 20
+	},
+	"redis": {
+		"address": "localhost:6379",
+		"username": "default",
+		"password": "",
+		"local": true,
+		"minIdleConns": 10,
+		"readTimeoutMs": 500
+	}
+}

bridge-history-api/config.json

@@ -1,41 +0,0 @@
-{
-	"batchInfoFetcher": {
-		"batchIndexStartBlock": 9091265,
-		"ScrollChainAddr": "0xcD00DB804C819175B381b2B44Aa16A391c8a01D6"
-	},
-	"l1": {
-		"confirmation": 64,
-		"endpoint": "https://rpc.ankr.com/eth_goerli",
-		"startHeight": 9090194 ,
-		"blockTime": 10,
-		"MessengerAddr": "0x326517Eb8eB1Ce5eaB5b513C2e9A24839b402d90",
-		"ETHGatewayAddr": "0x8305cB7B8448677736095965B63d7431017328fe",
-		"WETHGatewayAddr": "0xe3bA3c60d99a2d9a5f817734bC85353470b23931",
-		"StandardERC20Gateway": "0x16c1079B27eD9c363B7D08aC5Ae937A398972A5C",
-		"CustomERC20GatewayAddr": "0x61f08caD3d6F77801167d3bA8669433701586643",
-		"ERC721GatewayAddr": "0x4A73D25A4C99CB912acaf6C5B5e554f2982201c5",
-		"ERC1155GatewayAddr": "0xa3F5DD3033698c2832C53f3C3Fe6E062F58cD808"
-	},
-	"l2": {
-		"confirmation": 1,
-		"endpoint": "http://staging-l2geth-rpc0.scroll.tech:8545",
-		"blockTime": 3,
-		"startHeight": 0,
-		"CustomERC20GatewayAddr": "0x905db21f836749fEeD12de781afc4A5Ab4Dd0d51",
-		"ERC721GatewayAddr": "0xC53D835514780664BCd7eCfcE7c2E5d9554dc41B",
-		"StandardERC20Gateway": "0x90271634BCB020e06ea4840C3f7aa61b8F860651",
-		"MessengerAddr": "0xE8b0956Ac75c65Aa1669e83888DA13afF2E108f4",
-		"ETHGatewayAddr": "0xD5938590D5dD8ce95812D4D515a219C12C551D67",
-		"WETHGatewayAddr": "0xb0aaA582564fade4232a16fdB1383004A6A7247F",
-		"ERC1155GatewayAddr": "0x4f33B1655619c2C0B7C450128Df760B4365Cb549"
-	},
-	"db": {
-		"dsn": "postgres://postgres:1234@localhost:5444/test?sslmode=disable",
-		"driverName": "postgres",
-		"maxOpenNum": 200,
-		"maxIdleNum": 20
-	},
-	"server": {
-		"hostPort": "0.0.0.0:20006"
-	}
-}

bridge-history-api/config/config.go

@@ -1,71 +0,0 @@
-package config
-
-import (
-	"encoding/json"
-	"os"
-	"path/filepath"
-)
-
-// BatchInfoFetcherConfig is the configuration of BatchInfoFetcher
-type BatchInfoFetcherConfig struct {
-	BatchIndexStartBlock uint64 `json:"batchIndexStartBlock"`
-	ScrollChainAddr      string `json:"ScrollChainAddr"`
-}
-
-// DBConfig db config
-type DBConfig struct {
-	// data source name
-	DSN        string `json:"dsn"`
-	DriverName string `json:"driverName"`
-
-	MaxOpenNum int `json:"maxOpenNum"`
-	MaxIdleNum int `json:"maxIdleNum"`
-}
-
-// LayerConfig is the configuration of Layer1/Layer2
-type LayerConfig struct {
-	Confirmation           uint64 `json:"confirmation"`
-	Endpoint               string `json:"endpoint"`
-	StartHeight            uint64 `json:"startHeight"`
-	BlockTime              int64  `json:"blockTime"`
-	MessengerAddr          string `json:"MessengerAddr"`
-	ETHGatewayAddr         string `json:"ETHGatewayAddr"`
-	WETHGatewayAddr        string `json:"WETHGatewayAddr"`
-	StandardERC20Gateway   string `json:"StandardERC20Gateway"`
-	ERC721GatewayAddr      string `json:"ERC721GatewayAddr"`
-	ERC1155GatewayAddr     string `json:"ERC1155GatewayAddr"`
-	CustomERC20GatewayAddr string `json:"CustomERC20GatewayAddr"`
-}
-
-// ServerConfig is the configuration of the bridge history backend server port
-type ServerConfig struct {
-	HostPort string `json:"hostPort"`
-}
-
-// Config is the configuration of the bridge history backend
-type Config struct {
-	// chain config
-	L1 *LayerConfig `json:"l1"`
-	L2 *LayerConfig `json:"l2"`
-
-	// data source name
-	DB               *DBConfig               `json:"db"`
-	Server           *ServerConfig           `json:"server"`
-	BatchInfoFetcher *BatchInfoFetcherConfig `json:"batchInfoFetcher"`
-}
-
-// NewConfig returns a new instance of Config.
-func NewConfig(file string) (*Config, error) {
-	buf, err := os.ReadFile(filepath.Clean(file))
-	if err != nil {
-		return nil, err
-	}
-
-	cfg := &Config{}
-	err = json.Unmarshal(buf, cfg)
-	if err != nil {
-		return nil, err
-	}
-
-	return cfg, nil
-}

bridge-history-api/controller/controller.go

@@ -1,60 +0,0 @@
-package controller
-
-import (
-	"bridge-history-api/model"
-	"bridge-history-api/service"
-
-	"github.com/ethereum/go-ethereum/common"
-)
-
-// QueryAddressController contains the query by address service
-type QueryAddressController struct {
-	Service service.HistoryService
-}
-
-// QueryHashController contains the query by hash service
-type QueryHashController struct {
-	Service service.HistoryService
-}
-
-// QueryClaimableController contains the query claimable txs service
-type QueryClaimableController struct {
-	Service service.HistoryService
-}
-
-// Get defines the http get method behavior for QueryClaimableController
-func (c *QueryClaimableController) Get(req model.QueryByAddressRequest) (*model.QueryByAddressResponse, error) {
-	txs, total, err := c.Service.GetClaimableTxsByAddress(common.HexToAddress(req.Address), int64(req.Offset), int64(req.Limit))
-	if err != nil {
-		return &model.QueryByAddressResponse{Message: "500", Data: &model.Data{}}, err
-	}
-
-	return &model.QueryByAddressResponse{Message: "ok",
-		Data: &model.Data{
-			Result: txs,
-			Total:  total,
-		}}, nil
-}
-
-// Get defines the http get method behavior for QueryAddressController
-func (c *QueryAddressController) Get(req model.QueryByAddressRequest) (*model.QueryByAddressResponse, error) {
-	message, total, err := c.Service.GetTxsByAddress(common.HexToAddress(req.Address), int64(req.Offset), int64(req.Limit))
-	if err != nil {
-		return &model.QueryByAddressResponse{Message: "500", Data: &model.Data{}}, err
-	}
-
-	return &model.QueryByAddressResponse{Message: "ok",
-		Data: &model.Data{
-			Result: message,
-			Total:  total,
-		}}, nil
-}
-
-// Post defines the http post method behavior for QueryHashController
-func (c *QueryHashController) Post(req model.QueryByHashRequest) (*model.QueryByHashResponse, error) {
-	result, err := c.Service.GetTxsByHashes(req.Txs)
-	if err != nil {
-		return &model.QueryByHashResponse{Message: "500", Data: &model.Data{}}, err
-	}
-	return &model.QueryByHashResponse{Message: "ok", Data: &model.Data{Result: result}}, nil
-}

bridge-history-api/crossmsg/batch_info_fetcher.go

@@ -1,109 +0,0 @@
-package crossmsg
-
-import (
-	"context"
-	"time"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/ethclient"
-	"github.com/ethereum/go-ethereum/log"
-
-	"bridge-history-api/crossmsg/messageproof"
-	"bridge-history-api/db"
-	"bridge-history-api/utils"
-)
-
-// BatchInfoFetcher fetches batch info from l1 chain and update db
-type BatchInfoFetcher struct {
-	ctx                  context.Context
-	scrollChainAddr      common.Address
-	batchInfoStartNumber uint64
-	confirmation         uint64
-	blockTimeInSec       int
-	client               *ethclient.Client
-	db                   db.OrmFactory
-	msgProofUpdater      *messageproof.MsgProofUpdater
-}
-
-// NewBatchInfoFetcher creates a new BatchInfoFetcher instance
-func NewBatchInfoFetcher(ctx context.Context, scrollChainAddr common.Address, batchInfoStartNumber uint64, confirmation uint64, blockTimeInSec int, client *ethclient.Client, db db.OrmFactory, msgProofUpdater *messageproof.MsgProofUpdater) *BatchInfoFetcher {
-	return &BatchInfoFetcher{
-		ctx:                  ctx,
-		scrollChainAddr:      scrollChainAddr,
-		batchInfoStartNumber: batchInfoStartNumber,
-		confirmation:         confirmation,
-		blockTimeInSec:       blockTimeInSec,
-		client:               client,
-		db:                   db,
-		msgProofUpdater:      msgProofUpdater,
-	}
-}
-
-// Start the BatchInfoFetcher
-func (b *BatchInfoFetcher) Start() {
-	log.Info("BatchInfoFetcher Start")
-	// Fetch batch info at beginning
-	// Then start msg proof updater after db have some bridge batch
-	err := b.fetchBatchInfo()
-	if err != nil {
-		log.Error("fetch batch info at beginning failed: ", "err", err)
-	}
-
-	go b.msgProofUpdater.Start()
-
-	go func() {
-		tick := time.NewTicker(time.Duration(b.blockTimeInSec) * time.Second)
-		for {
-			select {
-			case <-b.ctx.Done():
-				tick.Stop()
-				return
-			case <-tick.C:
-				err := b.fetchBatchInfo()
-				if err != nil {
-					log.Error("fetch batch info failed: ", "err", err)
-				}
-			}
-		}
-	}()
-}
-
-// Stop the BatchInfoFetcher and call msg proof updater to stop
-func (b *BatchInfoFetcher) Stop() {
-	log.Info("BatchInfoFetcher Stop")
-	b.msgProofUpdater.Stop()
-}
-
-func (b *BatchInfoFetcher) fetchBatchInfo() error {
-	number, err := utils.GetSafeBlockNumber(b.ctx, b.client, b.confirmation)
-	if err != nil {
-		log.Error("Can not get latest block number: ", "err", err)
-		return err
-	}
-	latestBatch, err := b.db.GetLatestRollupBatch()
-	if err != nil {
-		log.Error("Can not get latest BatchInfo: ", "err", err)
-		return err
-	}
-	var startHeight uint64
-	if latestBatch == nil {
-		startHeight = b.batchInfoStartNumber
-	} else {
-		startHeight = latestBatch.CommitHeight + 1
-	}
-	for from := startHeight; number >= from; from += uint64(fetchLimit) {
-		to := from + uint64(fetchLimit) - 1
-		// number - confirmation can never less than 0 since the for loop condition
-		// but watch out the overflow
-		if to > number {
-			to = number
-		}
-		// filter logs to fetch batches
-		err = FetchAndSaveBatchIndex(b.ctx, b.client, b.db, int64(from), int64(to), b.scrollChainAddr)
-		if err != nil {
-			log.Error("Can not fetch and save from chain: ", "err", err)
-			return err
-		}
-	}
-	return nil
-}

bridge-history-api/crossmsg/block_timestamp_fetcher.go

@@ -1,85 +0,0 @@
-package crossmsg
-
-import (
-	"context"
-	"math/big"
-	"time"
-
-	"github.com/ethereum/go-ethereum/ethclient"
-	"github.com/ethereum/go-ethereum/log"
-)
-
-// GetEarliestNoBlockTimestampHeightFunc is a function type that gets the earliest record without block timestamp from database
-type GetEarliestNoBlockTimestampHeightFunc func() (uint64, error)
-
-// UpdateBlockTimestampFunc is a function type that updates block timestamp into database
-type UpdateBlockTimestampFunc func(height uint64, timestamp time.Time) error
-
-// BlockTimestampFetcher fetches block timestamp from blockchain and saves them to database
-type BlockTimestampFetcher struct {
-	ctx                                   context.Context
-	confirmation                          uint64
-	blockTimeInSec                        int
-	client                                *ethclient.Client
-	updateBlockTimestampFunc              UpdateBlockTimestampFunc
-	getEarliestNoBlockTimestampHeightFunc GetEarliestNoBlockTimestampHeightFunc
-}
-
-// NewBlockTimestampFetcher creates a new BlockTimestampFetcher instance
-func NewBlockTimestampFetcher(ctx context.Context, confirmation uint64, blockTimeInSec int, client *ethclient.Client, updateBlockTimestampFunc UpdateBlockTimestampFunc, getEarliestNoBlockTimestampHeightFunc GetEarliestNoBlockTimestampHeightFunc) *BlockTimestampFetcher {
-	return &BlockTimestampFetcher{
-		ctx:                                   ctx,
-		confirmation:                          confirmation,
-		blockTimeInSec:                        blockTimeInSec,
-		client:                                client,
-		getEarliestNoBlockTimestampHeightFunc: getEarliestNoBlockTimestampHeightFunc,
-		updateBlockTimestampFunc:              updateBlockTimestampFunc,
-	}
-}
-
-// Start the BlockTimestampFetcher
-func (b *BlockTimestampFetcher) Start() {
-	go func() {
-		tick := time.NewTicker(time.Duration(b.blockTimeInSec) * time.Second)
-		for {
-			select {
-			case <-b.ctx.Done():
-				tick.Stop()
-				return
-			case <-tick.C:
-				number, err := b.client.BlockNumber(b.ctx)
-				if err != nil {
-					log.Error("Can not get latest block number", "err", err)
-					continue
-				}
-				startHeight, err := b.getEarliestNoBlockTimestampHeightFunc()
-				if err != nil {
-					log.Error("Can not get latest record without block timestamp", "err", err)
-					continue
-				}
-				for height := startHeight; number >= height+b.confirmation && height > 0; {
-					block, err := b.client.HeaderByNumber(b.ctx, new(big.Int).SetUint64(height))
-					if err != nil {
-						log.Error("Can not get block by number", "err", err)
-						break
-					}
-					err = b.updateBlockTimestampFunc(height, time.Unix(int64(block.Time), 0))
-					if err != nil {
-						log.Error("Can not update blockTimestamp into DB ", "err", err)
-						break
-					}
-					height, err = b.getEarliestNoBlockTimestampHeightFunc()
-					if err != nil {
-						log.Error("Can not get latest record without block timestamp", "err", err)
-						break
-					}
-				}
-			}
-		}
-	}()
-}
-
-// Stop the BlockTimestampFetcher and log the info
-func (b *BlockTimestampFetcher) Stop() {
-	log.Info("BlockTimestampFetcher Stop")
-}

bridge-history-api/crossmsg/cross_msg_fetcher.go

@@ -1,214 +0,0 @@
-package crossmsg
-
-import (
-	"context"
-	"fmt"
-	"math/big"
-	"sync"
-	"time"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/ethclient"
-	"github.com/ethereum/go-ethereum/log"
-	"github.com/modern-go/reflect2"
-
-	"bridge-history-api/config"
-	"bridge-history-api/db"
-	"bridge-history-api/utils"
-)
-
-// MsgFetcher fetches cross message events from blockchain and saves them to database
-type MsgFetcher struct {
-	ctx           context.Context
-	config        *config.LayerConfig
-	db            db.OrmFactory
-	client        *ethclient.Client
-	worker        *FetchEventWorker
-	reorgHandling ReorgHandling
-	addressList   []common.Address
-	cachedHeaders []*types.Header
-	mu            sync.Mutex
-	reorgStartCh  chan struct{}
-	reorgEndCh    chan struct{}
-}
-
-// NewMsgFetcher creates a new MsgFetcher instance
-func NewMsgFetcher(ctx context.Context, config *config.LayerConfig, db db.OrmFactory, client *ethclient.Client, worker *FetchEventWorker, addressList []common.Address, reorg ReorgHandling) (*MsgFetcher, error) {
-	msgFetcher := &MsgFetcher{
-		ctx:           ctx,
-		config:        config,
-		db:            db,
-		client:        client,
-		worker:        worker,
-		reorgHandling: reorg,
-		addressList:   addressList,
-		cachedHeaders: make([]*types.Header, 0),
-		reorgStartCh:  make(chan struct{}),
-		reorgEndCh:    make(chan struct{}),
-	}
-	return msgFetcher, nil
-}
-
-// Start the MsgFetcher
-func (c *MsgFetcher) Start() {
-	log.Info("MsgFetcher Start")
-	// fetch missing events from finalized blocks, we don't handle reorgs here
-	c.forwardFetchAndSaveMissingEvents(c.config.Confirmation)
-
-	tick := time.NewTicker(time.Duration(c.config.BlockTime) * time.Second)
-	headerTick := time.NewTicker(time.Duration(c.config.BlockTime/2) * time.Second)
-	go func() {
-		for {
-			select {
-			case <-c.reorgStartCh:
-				// create timeout here
-				timeout := time.NewTicker(300 * time.Second)
-				select {
-				case <-c.reorgEndCh:
-					log.Info("Reorg finished")
-					timeout.Stop()
-				case <-timeout.C:
-					// TODO: need to notify the on-call members to handle reorg manually
-					timeout.Stop()
-					log.Crit("Reorg timeout")
-				}
-			case <-c.ctx.Done():
-				tick.Stop()
-				return
-			case <-tick.C:
-				c.mu.Lock()
-				c.forwardFetchAndSaveMissingEvents(1)
-				c.mu.Unlock()
-			}
-		}
-	}()
-
-	go func() {
-		for {
-			select {
-			case <-c.ctx.Done():
-				headerTick.Stop()
-				return
-			case <-headerTick.C:
-				c.fetchMissingLatestHeaders()
-			}
-		}
-	}()
-}
-
-// Stop the MsgFetcher and log the info
-func (c *MsgFetcher) Stop() {
-	log.Info("MsgFetcher Stop")
-}
-
-// forwardFetchAndSaveMissingEvents will fetch all events from the latest processed height to the latest block number.
-func (c *MsgFetcher) forwardFetchAndSaveMissingEvents(confirmation uint64) {
-	// if we fetch to the latest block, shall not exceed cachedHeaders
-	var number uint64
-	var err error
-	if len(c.cachedHeaders) != 0 && confirmation == 0 {
-		number = c.cachedHeaders[len(c.cachedHeaders)-1].Number.Uint64() - 1
-	} else {
-		number, err = utils.GetSafeBlockNumber(c.ctx, c.client, confirmation)
-		if err != nil {
-			log.Error(fmt.Sprintf("%s: can not get the safe block number", c.worker.Name), "err", err)
-			return
-		}
-	}
-	if reflect2.IsNil(c.worker.G) || reflect2.IsNil(c.worker.F) {
-		log.Error(fmt.Sprintf("%s: invalid get/fetch function", c.worker.Name))
-		return
-	}
-	processedHeight, err := c.worker.G(c.db)
-	if err != nil {
-		log.Error(fmt.Sprintf("%s: can not get latest processed block height", c.worker.Name))
-	}
-	log.Info(fmt.Sprintf("%s: ", c.worker.Name), "height", processedHeight)
-	if processedHeight <= 0 || processedHeight < int64(c.config.StartHeight) {
-		processedHeight = int64(c.config.StartHeight)
-	} else {
-		processedHeight++
-	}
-	for from := processedHeight; from <= int64(number); from += fetchLimit {
-		to := from + fetchLimit - 1
-		if to > int64(number) {
-			to = int64(number)
-		}
-		err := c.worker.F(c.ctx, c.client, c.db, from, to, c.addressList)
-		if err != nil {
-			log.Error(fmt.Sprintf("%s: failed!", c.worker.Name), "err", err)
-			break
-		}
-	}
-}
-
-func (c *MsgFetcher) fetchMissingLatestHeaders() {
-	var start int64
-	number, err := c.client.BlockNumber(c.ctx)
-	if err != nil {
-		log.Error("fetchMissingLatestHeaders(): can not get the latest block number", "err", err)
-		return
-	}
-
-	if len(c.cachedHeaders) > 0 {
-		start = c.cachedHeaders[len(c.cachedHeaders)-1].Number.Int64() + 1
-	} else {
-		start = int64(number - c.config.Confirmation)
-	}
-	for i := start; i <= int64(number); i++ {
-		select {
-		case <-c.ctx.Done():
-			close(c.reorgStartCh)
-			close(c.reorgEndCh)
-			return
-		default:
-			header, err := c.client.HeaderByNumber(c.ctx, big.NewInt(i))
-			if err != nil {
-				log.Error("failed to get latest header", "err", err)
-				return
-			}
-			if len(c.cachedHeaders) == 0 {
-				c.cachedHeaders = MergeAddIntoHeaderList(c.cachedHeaders, []*types.Header{header}, int(c.config.Confirmation))
-				return
-			}
-			//check if the fetched header is child from the last cached header
-			if IsParentAndChild(c.cachedHeaders[len(c.cachedHeaders)-1], header) {
-				c.cachedHeaders = MergeAddIntoHeaderList(c.cachedHeaders, []*types.Header{header}, int(c.config.Confirmation))
-				log.Debug("fetched block into cache", "height", header.Number, "parent hash", header.ParentHash.Hex(), "block hash", c.cachedHeaders[len(c.cachedHeaders)-1].Hash().Hex(), "len", len(c.cachedHeaders))
-				continue
-			}
-			// reorg happened
-			log.Warn("Reorg happened", "height", header.Number, "parent hash", header.ParentHash.Hex(), "last cached hash", c.cachedHeaders[len(c.cachedHeaders)-1].Hash().Hex(), "last cached height", c.cachedHeaders[len(c.cachedHeaders)-1].Number)
-			c.reorgStartCh <- struct{}{}
-			// waiting here if there is fetcher running
-			c.mu.Lock()
-			index, ok, validHeaders := BackwardFindReorgBlock(c.ctx, c.cachedHeaders, c.client, header)
-			if !ok {
-				log.Error("Reorg happened too earlier than cached headers", "reorg height", header.Number)
-				num, getSafeErr := utils.GetSafeBlockNumber(c.ctx, c.client, c.config.Confirmation)
-				if getSafeErr != nil {
-					log.Crit("Can not get safe number during reorg, quit the process", "err", err)
-				}
-				// clear all our saved data, because no data is safe now
-				err = c.reorgHandling(c.ctx, int64(num), c.db)
-				// if handling success then we can update the cachedHeaders
-				if err == nil {
-					c.cachedHeaders = c.cachedHeaders[:0]
-				}
-				c.mu.Unlock()
-				c.reorgEndCh <- struct{}{}
-				return
-			}
-			err = c.reorgHandling(c.ctx, c.cachedHeaders[index].Number.Int64(), c.db)
-			// if handling success then we can update the cachedHeaders
-			if err == nil {
-				c.cachedHeaders = c.cachedHeaders[:index+1]
-				c.cachedHeaders = MergeAddIntoHeaderList(c.cachedHeaders, validHeaders, int(c.config.Confirmation))
-			}
-			c.mu.Unlock()
-			c.reorgEndCh <- struct{}{}
-		}
-	}
-
-}

bridge-history-api/crossmsg/fetch_missing_event.go

@@ -1,253 +0,0 @@
-package crossmsg
-
-import (
-	"context"
-	"math/big"
-
-	geth "github.com/ethereum/go-ethereum"
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/ethclient"
-	"github.com/ethereum/go-ethereum/log"
-
-	backendabi "bridge-history-api/abi"
-	"bridge-history-api/db"
-	"bridge-history-api/utils"
-)
-
-// Todo : read from config
-var (
-	// the number of blocks fetch per round
-	fetchLimit = int64(3000)
-)
-
-// FetchAndSave is a function type that fetches events from blockchain and saves them to database
-type FetchAndSave func(ctx context.Context, client *ethclient.Client, database db.OrmFactory, from int64, to int64, addressList []common.Address) error
-
-// GetLatestProcessed is a function type that gets the latest processed block height from database
-type GetLatestProcessed func(db db.OrmFactory) (int64, error)
-
-// FetchEventWorker defines worker with fetch and save function, processed number getter, and name
-type FetchEventWorker struct {
-	F    FetchAndSave
-	G    GetLatestProcessed
-	Name string
-}
-
-// GetLatestL1ProcessedHeight get L1 the latest processed height
-func GetLatestL1ProcessedHeight(db db.OrmFactory) (int64, error) {
-	crossHeight, err := db.GetLatestL1ProcessedHeight()
-	if err != nil {
-		log.Error("failed to get L1 cross message processed height: ", "err", err)
-		return 0, err
-	}
-	relayedHeight, err := db.GetLatestRelayedHeightOnL1()
-	if err != nil {
-		log.Error("failed to get L1 relayed message processed height: ", "err", err)
-		return 0, err
-	}
-	if crossHeight > relayedHeight {
-		return crossHeight, nil
-	}
-	return relayedHeight, nil
-}
-
-// GetLatestL2ProcessedHeight get L2 latest processed height
-func GetLatestL2ProcessedHeight(db db.OrmFactory) (int64, error) {
-	crossHeight, err := db.GetLatestL2ProcessedHeight()
-	if err != nil {
-		log.Error("failed to get L2 cross message processed height", "err", err)
-		return 0, err
-	}
-	relayedHeight, err := db.GetLatestRelayedHeightOnL2()
-	if err != nil {
-		log.Error("failed to get L2 relayed message processed height", "err", err)
-		return 0, err
-	}
-	l2SentHeight, err := db.GetLatestSentMsgHeightOnL2()
-	if err != nil {
-		log.Error("failed to get L2 sent message processed height", "err", err)
-		return 0, err
-	}
-	maxHeight := crossHeight
-	if maxHeight < relayedHeight {
-		maxHeight = relayedHeight
-	}
-	if maxHeight < l2SentHeight {
-		maxHeight = l2SentHeight
-	}
-	return maxHeight, nil
-}
-
-// L1FetchAndSaveEvents fetch and save events on L1
-func L1FetchAndSaveEvents(ctx context.Context, client *ethclient.Client, database db.OrmFactory, from int64, to int64, addrList []common.Address) error {
-	query := geth.FilterQuery{
-		FromBlock: big.NewInt(from), // inclusive
-		ToBlock:   big.NewInt(to),   // inclusive
-		Addresses: addrList,
-		Topics:    make([][]common.Hash, 1),
-	}
-	query.Topics[0] = make([]common.Hash, 7)
-	query.Topics[0][0] = backendabi.L1DepositETHSig
-	query.Topics[0][1] = backendabi.L1DepositERC20Sig
-	query.Topics[0][2] = backendabi.L1RelayedMessageEventSignature
-	query.Topics[0][3] = backendabi.L1SentMessageEventSignature
-	query.Topics[0][4] = backendabi.L1DepositERC721Sig
-	query.Topics[0][5] = backendabi.L1DepositERC1155Sig
-	query.Topics[0][6] = backendabi.L1DepositWETHSig
-
-	logs, err := client.FilterLogs(ctx, query)
-	if err != nil {
-		log.Warn("Failed to get l1 event logs", "err", err)
-		return err
-	}
-	depositL1CrossMsgs, relayedMsg, err := utils.ParseBackendL1EventLogs(logs)
-	if err != nil {
-		log.Error("l1FetchAndSaveEvents: Failed to parse cross msg event logs", "err", err)
-		return err
-	}
-	dbTx, err := database.Beginx()
-	if err != nil {
-		log.Error("l2FetchAndSaveEvents: Failed to begin db transaction", "err", err)
-		return err
-	}
-	err = database.BatchInsertL1CrossMsgDBTx(dbTx, depositL1CrossMsgs)
-	if err != nil {
-		if rollBackErr := dbTx.Rollback(); rollBackErr != nil {
-			log.Error("dbTx Rollback failed", "err", rollBackErr)
-		}
-		log.Crit("l1FetchAndSaveEvents: Failed to insert cross msg event logs", "err", err)
-	}
-
-	err = database.BatchInsertRelayedMsgDBTx(dbTx, relayedMsg)
-	if err != nil {
-		if rollBackErr := dbTx.Rollback(); rollBackErr != nil {
-			log.Error("dbTx Rollback failed", "err", rollBackErr)
-		}
-		log.Crit("l1FetchAndSaveEvents: Failed to insert relayed message event logs", "err", err)
-	}
-	err = dbTx.Commit()
-	if err != nil {
-		// if we can not insert into DB, there must something wrong, need a on-call member handle the dababase manually
-		if rollBackErr := dbTx.Rollback(); rollBackErr != nil {
-			log.Error("dbTx Rollback failed", "err", rollBackErr)
-		}
-		log.Error("l1FetchAndSaveEvents: Failed to commit db transaction", "err", err)
-		return err
-	}
-
-	return nil
-}
-
-// L2FetchAndSaveEvents fetche and save events on L2
-func L2FetchAndSaveEvents(ctx context.Context, client *ethclient.Client, database db.OrmFactory, from int64, to int64, addrList []common.Address) error {
-	query := geth.FilterQuery{
-		FromBlock: big.NewInt(from), // inclusive
-		ToBlock:   big.NewInt(to),   // inclusive
-		Addresses: addrList,
-		Topics:    make([][]common.Hash, 1),
-	}
-	query.Topics[0] = make([]common.Hash, 7)
-	query.Topics[0][0] = backendabi.L2WithdrawETHSig
-	query.Topics[0][1] = backendabi.L2WithdrawERC20Sig
-	query.Topics[0][2] = backendabi.L2RelayedMessageEventSignature
-	query.Topics[0][3] = backendabi.L2SentMessageEventSignature
-	query.Topics[0][4] = backendabi.L2WithdrawERC721Sig
-	query.Topics[0][5] = backendabi.L2WithdrawERC1155Sig
-	query.Topics[0][6] = backendabi.L2WithdrawWETHSig
-
-	logs, err := client.FilterLogs(ctx, query)
-	if err != nil {
-		log.Warn("Failed to get l2 event logs", "err", err)
-		return err
-	}
-	depositL2CrossMsgs, relayedMsg, l2SentMsgs, err := utils.ParseBackendL2EventLogs(logs)
-	if err != nil {
-		log.Error("l2FetchAndSaveEvents: Failed to parse cross msg event logs", "err", err)
-		return err
-	}
-
-	dbTx, err := database.Beginx()
-	if err != nil {
-		log.Error("l2FetchAndSaveEvents: Failed to begin db transaction", "err", err)
-		return err
-	}
-	err = database.BatchInsertL2CrossMsgDBTx(dbTx, depositL2CrossMsgs)
-	if err != nil {
-		if rollBackErr := dbTx.Rollback(); rollBackErr != nil {
-			log.Error("dbTx Rollback failed", "err", rollBackErr)
-		}
-		log.Crit("l2FetchAndSaveEvents: Failed to insert cross msg event logs", "err", err)
-	}
-
-	err = database.BatchInsertRelayedMsgDBTx(dbTx, relayedMsg)
-	if err != nil {
-		if rollBackErr := dbTx.Rollback(); rollBackErr != nil {
-			log.Error("dbTx Rollback failed", "err", rollBackErr)
-		}
-		log.Crit("l2FetchAndSaveEvents: Failed to insert relayed message event logs", "err", err)
-	}
-
-	err = database.BatchInsertL2SentMsgDBTx(dbTx, l2SentMsgs)
-	if err != nil {
-		if rollBackErr := dbTx.Rollback(); rollBackErr != nil {
-			log.Error("dbTx Rollback failed", "err", rollBackErr)
-		}
-		log.Crit("l2FetchAndSaveEvents: Failed to insert l2 sent message", "err", err)
-	}
-
-	err = dbTx.Commit()
-	if err != nil {
-		// if we can not insert into DB, there must something wrong, need a on-call member handle the dababase manually
-		if rollBackErr := dbTx.Rollback(); rollBackErr != nil {
-			log.Error("dbTx Rollback failed", "err", rollBackErr)
-		}
-		log.Error("l2FetchAndSaveEvents: Failed to commit db transaction", "err", err)
-		return err
-	}
-
-	return nil
-}
-
-// FetchAndSaveBatchIndex fetche and save batch index
-func FetchAndSaveBatchIndex(ctx context.Context, client *ethclient.Client, database db.OrmFactory, from int64, to int64, scrollChainAddr common.Address) error {
-	query := geth.FilterQuery{
-		FromBlock: big.NewInt(from), // inclusive
-		ToBlock:   big.NewInt(to),   // inclusive
-		Addresses: []common.Address{scrollChainAddr},
-		Topics:    make([][]common.Hash, 1),
-	}
-	query.Topics[0] = make([]common.Hash, 1)
-	query.Topics[0][0] = backendabi.L1CommitBatchEventSignature
-	logs, err := client.FilterLogs(ctx, query)
-	if err != nil {
-		log.Warn("Failed to get batch commit event logs", "err", err)
-		return err
-	}
-	rollupBatches, err := utils.ParseBatchInfoFromScrollChain(ctx, client, logs)
-	if err != nil {
-		log.Error("FetchAndSaveBatchIndex: Failed to parse batch commit msg event logs", "err", err)
-		return err
-	}
-	dbTx, err := database.Beginx()
-	if err != nil {
-		log.Error("FetchAndSaveBatchIndex: Failed to begin db transaction", "err", err)
-		return err
-	}
-	err = database.BatchInsertRollupBatchDBTx(dbTx, rollupBatches)
-	if err != nil {
-		if rollBackErr := dbTx.Rollback(); rollBackErr != nil {
-			log.Error("dbTx Rollback failed", "err", rollBackErr)
-		}
-		log.Crit("FetchAndSaveBatchIndex: Failed to insert batch commit msg event logs", "err", err)
-	}
-	err = dbTx.Commit()
-	if err != nil {
-		// if we can not insert into DB, there must something wrong, need a on-call member handle the dababase manually
-		if rollBackErr := dbTx.Rollback(); rollBackErr != nil {
-			log.Error("dbTx Rollback failed", "err", rollBackErr)
-		}
-		log.Error("FetchAndSaveBatchIndex: Failed to commit db transaction", "err", err)
-		return err
-	}
-	return nil
-}

bridge-history-api/crossmsg/messageproof/msg_proof_updater.go

@@ -1,245 +0,0 @@
-package messageproof
-
-import (
-	"context"
-	"database/sql"
-	"errors"
-	"fmt"
-	"time"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/log"
-
-	"bridge-history-api/db"
-	"bridge-history-api/db/orm"
-)
-
-// MsgProofUpdater is used to update message proof in db
-type MsgProofUpdater struct {
-	ctx          context.Context
-	db           db.OrmFactory
-	withdrawTrie *WithdrawTrie
-}
-
-// NewMsgProofUpdater new MsgProofUpdater instance
-func NewMsgProofUpdater(ctx context.Context, confirmations uint64, startBlock uint64, db db.OrmFactory) *MsgProofUpdater {
-	return &MsgProofUpdater{
-		ctx:          ctx,
-		db:           db,
-		withdrawTrie: NewWithdrawTrie(),
-	}
-}
-
-// Start the MsgProofUpdater
-func (m *MsgProofUpdater) Start() {
-	log.Info("MsgProofUpdater Start")
-	m.initialize(m.ctx)
-	go func() {
-		tick := time.NewTicker(10 * time.Second)
-		for {
-			select {
-			case <-m.ctx.Done():
-				tick.Stop()
-				return
-			case <-tick.C:
-				latestBatch, err := m.db.GetLatestRollupBatch()
-				if err != nil {
-					log.Warn("MsgProofUpdater: Can not get latest RollupBatch: ", "err", err)
-					continue
-				}
-				if latestBatch == nil {
-					continue
-				}
-				latestBatchIndexWithProof, err := m.db.GetLatestL2SentMsgBatchIndex()
-				if err != nil {
-					log.Error("MsgProofUpdater: Can not get latest L2SentMsgBatchIndex: ", "err", err)
-					continue
-				}
-				var start uint64
-				if latestBatchIndexWithProof < 0 {
-					start = 1
-				} else {
-					start = uint64(latestBatchIndexWithProof) + 1
-				}
-				for i := start; i <= latestBatch.BatchIndex; i++ {
-					batch, err := m.db.GetRollupBatchByIndex(i)
-					if err != nil {
-						log.Error("MsgProofUpdater: Can not get RollupBatch: ", "err", err, "index", i)
-						break
-					}
-					// get all l2 messages in this batch
-					msgs, proofs, err := m.appendL2Messages(batch.StartBlockNumber, batch.EndBlockNumber)
-					if err != nil {
-						log.Error("MsgProofUpdater: can not append l2messages", "startBlockNumber", batch.StartBlockNumber, "endBlockNumber", batch.EndBlockNumber, "err", err)
-						break
-					}
-					err = m.updateMsgProof(msgs, proofs, batch.BatchIndex)
-					if err != nil {
-						log.Error("MsgProofUpdater: can not update msg proof", "err", err)
-						break
-					}
-				}
-
-			}
-		}
-	}()
-
-}
-
-// Stop the MsgProofUpdater
-func (m *MsgProofUpdater) Stop() {
-	log.Info("MsgProofUpdater Stop")
-}
-
-func (m *MsgProofUpdater) initialize(ctx context.Context) {
-	for {
-		select {
-		case <-ctx.Done():
-			return
-		default:
-			err := m.initializeWithdrawTrie()
-			if err != nil {
-				log.Error("can not initialize withdraw trie", "err", err)
-				// give it some time to retry
-				time.Sleep(10 * time.Second)
-				continue
-			}
-			return
-		}
-	}
-}
-
-func (m *MsgProofUpdater) initializeWithdrawTrie() error {
-	var batch *orm.RollupBatch
-	firstMsg, err := m.db.GetL2SentMessageByNonce(0)
-	if err != nil && !errors.Is(err, sql.ErrNoRows) {
-		return fmt.Errorf("failed to get first l2 message: %v", err)
-	}
-	// no l2 message
-	// 	TO DO: check if we really dont have l2 sent message with nonce 0
-	if firstMsg == nil {
-		log.Info("No first l2sentmsg in db")
-		return nil
-	}
-
-	// if no batch, return and wait for next try round
-	batch, err = m.db.GetLatestRollupBatch()
-	if err != nil {
-		return fmt.Errorf("failed to get latest batch: %v", err)
-	}
-	if batch == nil {
-		return fmt.Errorf("no batch found")
-	}
-
-	var batches []*orm.RollupBatch
-	batchIndex := batch.BatchIndex
-	for {
-		var msg *orm.L2SentMsg
-		msg, err = m.db.GetLatestL2SentMsgLEHeight(batch.EndBlockNumber)
-		if err != nil {
-			log.Warn("failed to get l2 sent message less than height", "endBlocknum", batch.EndBlockNumber, "err", err)
-		}
-		if msg != nil && msg.MsgProof != "" {
-			log.Info("Found latest l2 sent msg with proof: ", "msg_proof", msg.MsgProof, "height", msg.Height, "msg_hash", msg.MsgHash)
-			// initialize withdrawTrie
-			proofBytes := common.Hex2Bytes(msg.MsgProof)
-			m.withdrawTrie.Initialize(msg.Nonce, common.HexToHash(msg.MsgHash), proofBytes)
-			break
-		}
-
-		// append unprocessed batch
-		batches = append(batches, batch)
-
-		if batchIndex == 1 {
-			// otherwise overflow
-			// and batchIndex 0 is not in DB
-			// To Do: check if we dont have batch with index 0 in future
-			break
-		}
-		// iterate for next batch
-		batchIndex--
-
-		batch, err = m.db.GetRollupBatchByIndex(batchIndex)
-		if err != nil {
-			return fmt.Errorf("failed to get block batch %v: %v", batchIndex, err)
-		}
-	}
-
-	log.Info("Build withdraw trie with pending messages")
-	for i := len(batches) - 1; i >= 0; i-- {
-		b := batches[i]
-		msgs, proofs, err := m.appendL2Messages(b.StartBlockNumber, b.EndBlockNumber)
-		if err != nil {
-			return err
-		}
-
-		err = m.updateMsgProof(msgs, proofs, b.BatchIndex)
-		if err != nil {
-			return err
-		}
-	}
-	log.Info("Build withdraw trie finished")
-
-	return nil
-}
-
-func (m *MsgProofUpdater) updateMsgProof(msgs []*orm.L2SentMsg, proofs [][]byte, batchIndex uint64) error {
-	if len(msgs) == 0 {
-		return nil
-	}
-	// this should not happen, but double check
-	if len(msgs) != len(proofs) {
-		return fmt.Errorf("illegal state: len(msgs) != len(proofs)")
-	}
-	dbTx, err := m.db.Beginx()
-	if err != nil {
-		return err
-	}
-
-	for i, msg := range msgs {
-		proofHex := common.Bytes2Hex(proofs[i])
-		log.Debug("updateMsgProof", "msgHash", msg.MsgHash, "batchIndex", batchIndex, "proof", proofHex)
-		if dbTxErr := m.db.UpdateL2MessageProofInDBTx(m.ctx, dbTx, msg.MsgHash, proofHex, batchIndex); dbTxErr != nil {
-			if err := dbTx.Rollback(); err != nil {
-				log.Error("dbTx.Rollback()", "err", err)
-			}
-			return dbTxErr
-		}
-	}
-
-	if dbTxErr := dbTx.Commit(); dbTxErr != nil {
-		if err := dbTx.Rollback(); err != nil {
-			log.Error("dbTx.Rollback()", "err", err)
-		}
-		return dbTxErr
-	}
-
-	return nil
-}
-
-// appendL2Messages will append all messages between firstBlock and lastBlock (both inclusive) to withdrawTrie and compute corresponding merkle proof of each message.
-func (m *MsgProofUpdater) appendL2Messages(firstBlock, lastBlock uint64) ([]*orm.L2SentMsg, [][]byte, error) {
-	var msgProofs [][]byte
-	messages, err := m.db.GetL2SentMsgMsgHashByHeightRange(firstBlock, lastBlock)
-	if err != nil {
-		log.Error("GetL2SentMsgMsgHashByHeightRange failed", "error", err, "firstBlock", firstBlock, "lastBlock", lastBlock)
-		return messages, msgProofs, err
-	}
-	if len(messages) == 0 {
-		return messages, msgProofs, nil
-	}
-
-	// double check whether nonce is matched
-	if messages[0].Nonce != m.withdrawTrie.NextMessageNonce {
-		log.Error("L2 message nonce mismatch", "expected", m.withdrawTrie.NextMessageNonce, "found", messages[0].Nonce)
-		return messages, msgProofs, fmt.Errorf("l2 message nonce mismatch, expected: %v, found: %v", m.withdrawTrie.NextMessageNonce, messages[0].Nonce)
-	}
-
-	var hashes []common.Hash
-	for _, msg := range messages {
-		hashes = append(hashes, common.HexToHash(msg.MsgHash))
-	}
-	msgProofs = m.withdrawTrie.AppendMessages(hashes)
-
-	return messages, msgProofs, nil
-}

bridge-history-api/crossmsg/msg_fetcher_test.go

@@ -1,65 +0,0 @@
-package crossmsg_test
-
-import (
-	"crypto/rand"
-	"math/big"
-	"testing"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/stretchr/testify/assert"
-
-	"bridge-history-api/crossmsg"
-)
-
-func TestMergeIntoList(t *testing.T) {
-	headers, err := generateHeaders(64)
-	assert.NoError(t, err)
-	assert.Equal(t, headers[0].Hash(), headers[1].ParentHash)
-	headers2, err := generateHeaders(18)
-	assert.NoError(t, err)
-	result := crossmsg.MergeAddIntoHeaderList(headers, headers2, 64)
-	assert.Equal(t, 64, len(result))
-	assert.Equal(t, headers2[len(headers2)-1], result[len(result)-1])
-	assert.NotEqual(t, headers[0], result[0])
-}
-
-func generateHeaders(amount int) ([]*types.Header, error) {
-	headers := make([]*types.Header, amount)
-
-	for i := 0; i < amount; i++ {
-		var parentHash common.Hash
-		if i > 0 {
-			parentHash = headers[i-1].Hash()
-		}
-		nonce, err := rand.Int(rand.Reader, big.NewInt(1<<63-1))
-		if err != nil {
-			return nil, err
-		}
-		difficulty := big.NewInt(131072)
-
-		header := &types.Header{
-			ParentHash:  parentHash,
-			UncleHash:   types.EmptyUncleHash,
-			Coinbase:    common.Address{},
-			Root:        common.Hash{},
-			TxHash:      types.EmptyRootHash,
-			ReceiptHash: types.EmptyRootHash,
-			Bloom:       types.Bloom{},
-			Difficulty:  difficulty,
-			Number:      big.NewInt(int64(i)),
-			GasLimit:    5000000,
-			GasUsed:     0,
-			Time:        uint64(i * 15),
-			Extra:       []byte{},
-			MixDigest:   common.Hash{},
-			Nonce:       types.EncodeNonce(nonce.Uint64()),
-		}
-		headers[i] = header
-	}
-
-	return headers, nil
-}
-
-// TODO: add more test cases
-// func TestReorg(t *testing.T)

bridge-history-api/crossmsg/reorg_handle.go

@@ -1,132 +0,0 @@
-package crossmsg
-
-import (
-	"context"
-
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/ethclient"
-	"github.com/ethereum/go-ethereum/log"
-
-	"bridge-history-api/db"
-)
-
-// ReorgHandling handles reorg function type
-type ReorgHandling func(ctx context.Context, reorgHeight int64, db db.OrmFactory) error
-
-func reverseArray(arr []*types.Header) []*types.Header {
-	for i := 0; i < len(arr)/2; i++ {
-		j := len(arr) - i - 1
-		arr[i], arr[j] = arr[j], arr[i]
-	}
-	return arr
-}
-
-// IsParentAndChild match the child header ParentHash with parent header Hash
-func IsParentAndChild(parentHeader *types.Header, header *types.Header) bool {
-	return header.ParentHash == parentHeader.Hash()
-}
-
-// MergeAddIntoHeaderList merges two header lists, if exceed the max length then drop the oldest entries
-func MergeAddIntoHeaderList(baseArr, extraArr []*types.Header, maxLength int) []*types.Header {
-	mergedArr := append(baseArr, extraArr...)
-	if len(mergedArr) <= maxLength {
-		return mergedArr
-	}
-
-	startIndex := len(mergedArr) - maxLength
-	return mergedArr[startIndex:]
-}
-
-// BackwardFindReorgBlock finds the reorg block by backward search
-func BackwardFindReorgBlock(ctx context.Context, headers []*types.Header, client *ethclient.Client, lastHeader *types.Header) (int, bool, []*types.Header) {
-	maxStep := len(headers)
-	backwardHeaderList := []*types.Header{lastHeader}
-	for iterRound := 0; iterRound < maxStep; iterRound++ {
-		header, err := client.HeaderByHash(ctx, lastHeader.ParentHash)
-		if err != nil {
-			log.Error("BackwardFindReorgBlock failed", "error", err)
-			return -1, false, nil
-		}
-		backwardHeaderList = append(backwardHeaderList, header)
-		for j := len(headers) - 1; j >= 0; j-- {
-			if IsParentAndChild(headers[j], header) {
-				backwardHeaderList = reverseArray(backwardHeaderList)
-				return j, true, backwardHeaderList
-			}
-		}
-		lastHeader = header
-	}
-	return -1, false, nil
-}
-
-// L1ReorgHandling handles l1 reorg
-func L1ReorgHandling(ctx context.Context, reorgHeight int64, db db.OrmFactory) error {
-	dbTx, err := db.Beginx()
-	if err != nil {
-		log.Crit("begin db tx failed", "err", err)
-	}
-	err = db.DeleteL1CrossMsgAfterHeightDBTx(dbTx, reorgHeight)
-	if err != nil {
-		if rollBackErr := dbTx.Rollback(); rollBackErr != nil {
-			log.Error("dbTx Rollback failed", "err", rollBackErr)
-		}
-		log.Crit("delete l1 cross msg from height", "height", reorgHeight, "err", err)
-	}
-	err = db.DeleteL1RelayedHashAfterHeightDBTx(dbTx, reorgHeight)
-	if err != nil {
-		if rollBackErr := dbTx.Rollback(); rollBackErr != nil {
-			log.Error("dbTx Rollback failed", "err", rollBackErr)
-		}
-		log.Crit("delete l1 relayed hash from height", "height", reorgHeight, "err", err)
-	}
-	err = dbTx.Commit()
-	if err != nil {
-		if rollBackErr := dbTx.Rollback(); rollBackErr != nil {
-			log.Error("dbTx Rollback failed", "err", rollBackErr)
-		}
-		log.Error("commit tx failed", "err", err)
-		return err
-	}
-	return nil
-}
-
-// L2ReorgHandling handles l2 reorg
-func L2ReorgHandling(ctx context.Context, reorgHeight int64, db db.OrmFactory) error {
-	dbTx, err := db.Beginx()
-	if err != nil {
-		if rollBackErr := dbTx.Rollback(); rollBackErr != nil {
-			log.Error("dbTx Rollback failed", "err", rollBackErr)
-		}
-		log.Crit("begin db tx failed", "err", err)
-	}
-	err = db.DeleteL2CrossMsgFromHeightDBTx(dbTx, reorgHeight)
-	if err != nil {
-		if rollBackErr := dbTx.Rollback(); rollBackErr != nil {
-			log.Error("dbTx Rollback failed", "err", rollBackErr)
-		}
-		log.Crit("delete l2 cross msg from height", "height", reorgHeight, "err", err)
-	}
-	err = db.DeleteL2RelayedHashAfterHeightDBTx(dbTx, reorgHeight)
-	if err != nil {
-		if rollBackErr := dbTx.Rollback(); rollBackErr != nil {
-			log.Error("dbTx Rollback failed", "err", rollBackErr)
-		}
-		log.Crit("delete l2 relayed hash from height", "height", reorgHeight, "err", err)
-	}
-	err = db.DeleteL2SentMsgAfterHeightDBTx(dbTx, reorgHeight)
-	if err != nil {
-		if rollBackErr := dbTx.Rollback(); rollBackErr != nil {
-			log.Error("dbTx Rollback failed", "err", rollBackErr)
-		}
-		log.Crit("delete l2 sent msg from height", "height", reorgHeight, "err", err)
-	}
-	err = dbTx.Commit()
-	if err != nil {
-		if rollBackErr := dbTx.Rollback(); rollBackErr != nil {
-			log.Error("dbTx Rollback failed", "err", rollBackErr)
-		}
-		log.Error("commit tx failed", "err", err)
-		return err
-	}
-	return nil
-}

bridge-history-api/db/migrate/migrations/00001_cross_msg.sql

@@ -1,57 +0,0 @@
--- +goose Up
--- +goose StatementBegin
-create table cross_message
-(
-    id              BIGSERIAL PRIMARY KEY,
-    msg_hash        VARCHAR NOT NULL,
-    height          BIGINT  NOT NULL,
-    sender          VARCHAR NOT NULL,
-    target          VARCHAR NOT NULL,
-    amount          VARCHAR NOT NULL,
-    layer1_hash     VARCHAR NOT NULL DEFAULT '',
-    layer2_hash     VARCHAR NOT NULL DEFAULT '',
-    layer1_token    VARCHAR NOT NULL DEFAULT '',
-    layer2_token    VARCHAR NOT NULL DEFAULT '',
-    asset           SMALLINT NOT NULL,
-    msg_type        SMALLINT NOT NULL,
-    token_ids       TEXT NOT NULL DEFAULT '',
-    token_amounts   TEXT NOT NULL DEFAULT '',
-    block_timestamp TIMESTAMP(0) DEFAULT 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 uk_msg_hash_msg_type
-on cross_message (msg_hash, msg_type) where deleted_at IS NULL;
-
-comment
-on column cross_message.asset is 'ETH, ERC20, ERC721, ERC1155';
-
-comment
-on column cross_message.msg_type is 'unknown, l1msg, l2msg';
-
-CREATE INDEX idx_l1_msg_index ON cross_message (layer1_hash, deleted_at);
-
-CREATE INDEX idx_l2_msg_index ON cross_message (layer2_hash, deleted_at);
-
-CREATE INDEX idx_height_msg_type_index ON cross_message (height, msg_type, deleted_at);
-
-CREATE OR REPLACE FUNCTION update_timestamp()
-RETURNS TRIGGER AS $$
-BEGIN
-   NEW.updated_at = CURRENT_TIMESTAMP;
-   RETURN NEW;
-END;
-$$ language 'plpgsql';
-
-CREATE TRIGGER update_timestamp BEFORE UPDATE
-ON cross_message FOR EACH ROW EXECUTE PROCEDURE
-update_timestamp();
-
--- +goose StatementEnd
-
--- +goose Down
--- +goose StatementBegin
-drop table if exists cross_message;
--- +goose StatementEnd

bridge-history-api/db/migrate/migrations/00002_relayed_msg.sql

@@ -1,41 +0,0 @@
--- +goose Up
--- +goose StatementBegin
-create table relayed_msg
-(
-    id          BIGSERIAL PRIMARY KEY,
-    msg_hash    VARCHAR NOT NULL,
-    height      BIGINT NOT NULL,
-    layer1_hash VARCHAR NOT NULL DEFAULT '',
-    layer2_hash VARCHAR NOT NULL DEFAULT '',
-    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 uk_msg_hash_l1_hash_l2_hash
-on relayed_msg (msg_hash, layer1_hash, layer2_hash) where deleted_at IS NULL;
-
-CREATE INDEX idx_l1_msg_relayed_msg ON relayed_msg (layer1_hash, deleted_at);
-
-CREATE INDEX idx_l2_msg_relayed_msg ON relayed_msg (layer2_hash, deleted_at);
-
-CREATE INDEX idx_msg_hash_deleted_at_relayed_msg on relayed_msg (msg_hash, deleted_at);
-
-CREATE OR REPLACE FUNCTION update_timestamp()
-RETURNS TRIGGER AS $$
-BEGIN
-   NEW.updated_at = CURRENT_TIMESTAMP;
-   RETURN NEW;
-END;
-$$ language 'plpgsql';
-
-CREATE TRIGGER update_timestamp BEFORE UPDATE
-ON relayed_msg FOR EACH ROW EXECUTE PROCEDURE
-update_timestamp();
-
--- +goose StatementEnd
-
--- +goose Down
--- +goose StatementBegin
-drop table if exists relayed_msg;
--- +goose StatementEnd

bridge-history-api/db/migrate/migrations/00003_l2_sent_msg.sql

@@ -1,47 +0,0 @@
--- +goose Up
--- +goose StatementBegin
-create table l2_sent_msg
-(
-    id               BIGSERIAL PRIMARY KEY,
-    original_sender  VARCHAR NOT NULL DEFAULT '',
-    tx_hash          VARCHAR NOT NULL,
-    sender           VARCHAR NOT NULL,
-    target           VARCHAR NOT NULL,
-    value            VARCHAR NOT NULL,
-    msg_hash         VARCHAR NOT NULL,
-    height           BIGINT NOT NULL,
-    nonce            BIGINT NOT NULL,
-    batch_index      BIGINT NOT NULL DEFAULT 0,
-    msg_proof        TEXT NOT NULL DEFAULT '',
-    msg_data         TEXT NOT NULL DEFAULT '',
-    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 uk_msg_hash
-on l2_sent_msg (msg_hash) where deleted_at IS NULL;
-
-create unique index uk_nonce
-on l2_sent_msg (nonce) where deleted_at IS NULL;
-
-CREATE INDEX idx_msg_hash_deleted_at_l2_sent_msg on l2_sent_msg (msg_hash, deleted_at);
-
-CREATE OR REPLACE FUNCTION update_timestamp()
-RETURNS TRIGGER AS $$
-BEGIN
-   NEW.updated_at = CURRENT_TIMESTAMP;
-   RETURN NEW;
-END;
-$$ language 'plpgsql';
-
-CREATE TRIGGER update_timestamp BEFORE UPDATE
-ON l2_sent_msg FOR EACH ROW EXECUTE PROCEDURE
-update_timestamp();
-
--- +goose StatementEnd
-
--- +goose Down
--- +goose StatementBegin
-drop table if exists l2_sent_msg;
--- +goose StatementEnd

bridge-history-api/db/migrate/migrations/00004_rollup_batch.sql

@@ -1,39 +0,0 @@
--- +goose Up
--- +goose StatementBegin
-create table rollup_batch
-(
-    id                  BIGSERIAL PRIMARY KEY,
-    batch_index         BIGINT NOT NULL,
-    commit_height       BIGINT NOT NULL,
-    start_block_number  BIGINT NOT NULL,
-    end_block_number    BIGINT NOT NULL,
-    batch_hash          VARCHAR 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 uk_batch_index
-on rollup_batch (batch_index) where deleted_at IS NULL;
-
-create unique index uk_batch_hash
-on rollup_batch (batch_hash) where deleted_at IS NULL;
-
-CREATE OR REPLACE FUNCTION update_timestamp()
-RETURNS TRIGGER AS $$
-BEGIN
-   NEW.updated_at = CURRENT_TIMESTAMP;
-   RETURN NEW;
-END;
-$$ language 'plpgsql';
-
-CREATE TRIGGER update_timestamp BEFORE UPDATE
-ON rollup_batch FOR EACH ROW EXECUTE PROCEDURE
-update_timestamp();
-
--- +goose StatementEnd
-
--- +goose Down
--- +goose StatementBegin
-drop table if exists rollup_batch;
--- +goose StatementEnd

bridge-history-api/db/orm/batch.go

@@ -1,71 +0,0 @@
-package orm
-
-import (
-	"database/sql"
-
-	"github.com/ethereum/go-ethereum/log"
-	"github.com/jmoiron/sqlx"
-)
-
-type rollupBatchOrm struct {
-	db *sqlx.DB
-}
-
-// RollupBatch is the struct for rollup_batch table
-type RollupBatch struct {
-	ID               uint64 `json:"id" db:"id"`
-	BatchIndex       uint64 `json:"batch_index" db:"batch_index"`
-	BatchHash        string `json:"batch_hash" db:"batch_hash"`
-	CommitHeight     uint64 `json:"commit_height" db:"commit_height"`
-	StartBlockNumber uint64 `json:"start_block_number" db:"start_block_number"`
-	EndBlockNumber   uint64 `json:"end_block_number" db:"end_block_number"`
-}
-
-// NewRollupBatchOrm create an NewRollupBatchOrm instance
-func NewRollupBatchOrm(db *sqlx.DB) RollupBatchOrm {
-	return &rollupBatchOrm{db: db}
-}
-
-func (b *rollupBatchOrm) BatchInsertRollupBatchDBTx(dbTx *sqlx.Tx, batches []*RollupBatch) error {
-	if len(batches) == 0 {
-		return nil
-	}
-	var err error
-	batchMaps := make([]map[string]interface{}, len(batches))
-	for i, batch := range batches {
-		batchMaps[i] = map[string]interface{}{
-			"commit_height":      batch.CommitHeight,
-			"batch_index":        batch.BatchIndex,
-			"batch_hash":         batch.BatchHash,
-			"start_block_number": batch.StartBlockNumber,
-			"end_block_number":   batch.EndBlockNumber,
-		}
-	}
-	_, err = dbTx.NamedExec(`insert into rollup_batch(commit_height, batch_index, batch_hash, start_block_number, end_block_number) values(:commit_height, :batch_index, :batch_hash, :start_block_number, :end_block_number);`, batchMaps)
-	if err != nil {
-		log.Error("BatchInsertRollupBatchDBTx: failed to insert batch event msgs", "err", err)
-		return err
-	}
-	return nil
-}
-
-func (b *rollupBatchOrm) GetLatestRollupBatch() (*RollupBatch, error) {
-	result := &RollupBatch{}
-	row := b.db.QueryRowx(`SELECT id, batch_index, commit_height, batch_hash, start_block_number, end_block_number FROM rollup_batch ORDER BY batch_index DESC LIMIT 1;`)
-	if err := row.StructScan(result); err != nil {
-		if err == sql.ErrNoRows {
-			return nil, nil
-		}
-		return nil, err
-	}
-	return result, nil
-}
-
-func (b *rollupBatchOrm) GetRollupBatchByIndex(index uint64) (*RollupBatch, error) {
-	result := &RollupBatch{}
-	row := b.db.QueryRowx(`SELECT id, batch_index, batch_hash, commit_height, start_block_number, end_block_number FROM rollup_batch WHERE batch_index = $1;`, index)
-	if err := row.StructScan(result); err != nil {
-		return nil, err
-	}
-	return result, nil
-}

bridge-history-api/db/orm/interface.go

@@ -1,132 +0,0 @@
-package orm
-
-import (
-	"context"
-	"time"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/jmoiron/sqlx"
-)
-
-// AssetType can be ETH/ERC20/ERC1155/ERC721
-type AssetType int
-
-// MsgType can be layer1/layer2 msg
-type MsgType int
-
-func (a AssetType) String() string {
-	switch a {
-	case ETH:
-		return "ETH"
-	case ERC20:
-		return "ERC20"
-	case ERC1155:
-		return "ERC1155"
-	case ERC721:
-		return "ERC721"
-	}
-	return "Unknown Asset Type"
-}
-
-const (
-	// ETH = 0
-	ETH AssetType = iota
-	// ERC20 = 1
-	ERC20
-	// ERC721 = 2
-	ERC721
-	// ERC1155 = 3
-	ERC1155
-)
-
-const (
-	// UnknownMsg = 0
-	UnknownMsg MsgType = iota
-	// Layer1Msg = 1
-	Layer1Msg
-	// Layer2Msg = 2
-	Layer2Msg
-)
-
-// CrossMsg represents a cross message from layer 1 to layer 2
-type CrossMsg struct {
-	ID           uint64     `json:"id" db:"id"`
-	MsgHash      string     `json:"msg_hash" db:"msg_hash"`
-	Height       uint64     `json:"height" db:"height"`
-	Sender       string     `json:"sender" db:"sender"`
-	Target       string     `json:"target" db:"target"`
-	Amount       string     `json:"amount" db:"amount"`
-	Layer1Hash   string     `json:"layer1_hash" db:"layer1_hash"`
-	Layer2Hash   string     `json:"layer2_hash" db:"layer2_hash"`
-	Layer1Token  string     `json:"layer1_token" db:"layer1_token"`
-	Layer2Token  string     `json:"layer2_token" db:"layer2_token"`
-	TokenIDs     string     `json:"token_ids" db:"token_ids"`
-	TokenAmounts string     `json:"token_amounts" db:"token_amounts"`
-	Asset        int        `json:"asset" db:"asset"`
-	MsgType      int        `json:"msg_type" db:"msg_type"`
-	Timestamp    *time.Time `json:"timestamp" db:"block_timestamp"`
-	CreatedAt    *time.Time `json:"created_at" db:"created_at"`
-	UpdatedAt    *time.Time `json:"updated_at" db:"updated_at"`
-	DeletedAt    *time.Time `json:"deleted_at" db:"deleted_at"`
-}
-
-// L1CrossMsgOrm provides operations on l1_cross_message table
-type L1CrossMsgOrm interface {
-	GetL1CrossMsgByHash(l1Hash common.Hash) (*CrossMsg, error)
-	GetL1CrossMsgsByAddress(sender common.Address) ([]*CrossMsg, error)
-	BatchInsertL1CrossMsgDBTx(dbTx *sqlx.Tx, messages []*CrossMsg) error
-	// UpdateL1CrossMsgHashDBTx invoked when SentMessage event is received
-	UpdateL1CrossMsgHashDBTx(ctx context.Context, dbTx *sqlx.Tx, l1Hash, msgHash common.Hash) error
-	UpdateL1CrossMsgHash(ctx context.Context, l1Hash, msgHash common.Hash) error
-	GetLatestL1ProcessedHeight() (int64, error)
-	DeleteL1CrossMsgAfterHeightDBTx(dbTx *sqlx.Tx, height int64) error
-	UpdateL1BlockTimestamp(height uint64, timestamp time.Time) error
-	GetL1EarliestNoBlockTimestampHeight() (uint64, error)
-}
-
-// L2CrossMsgOrm provides operations on cross_message table
-type L2CrossMsgOrm interface {
-	GetL2CrossMsgByHash(l2Hash common.Hash) (*CrossMsg, error)
-	GetL2CrossMsgByAddress(sender common.Address) ([]*CrossMsg, error)
-	BatchInsertL2CrossMsgDBTx(dbTx *sqlx.Tx, messages []*CrossMsg) error
-	// UpdateL2CrossMsgHashDBTx invoked when SentMessage event is received
-	UpdateL2CrossMsgHashDBTx(ctx context.Context, dbTx *sqlx.Tx, l2Hash, msgHash common.Hash) error
-	UpdateL2CrossMsgHash(ctx context.Context, l2Hash, msgHash common.Hash) error
-	GetLatestL2ProcessedHeight() (int64, error)
-	DeleteL2CrossMsgFromHeightDBTx(dbTx *sqlx.Tx, height int64) error
-	UpdateL2BlockTimestamp(height uint64, timestamp time.Time) error
-	GetL2EarliestNoBlockTimestampHeight() (uint64, error)
-	GetL2CrossMsgByMsgHashList(msgHashList []string) ([]*CrossMsg, error)
-}
-
-// RelayedMsgOrm provides operations on relayed_msg table
-type RelayedMsgOrm interface {
-	BatchInsertRelayedMsgDBTx(dbTx *sqlx.Tx, messages []*RelayedMsg) error
-	GetRelayedMsgByHash(msgHash string) (*RelayedMsg, error)
-	GetLatestRelayedHeightOnL1() (int64, error)
-	GetLatestRelayedHeightOnL2() (int64, error)
-	DeleteL1RelayedHashAfterHeightDBTx(dbTx *sqlx.Tx, height int64) error
-	DeleteL2RelayedHashAfterHeightDBTx(dbTx *sqlx.Tx, height int64) error
-}
-
-// L2SentMsgOrm provides operations on l2_sent_msg table
-type L2SentMsgOrm interface {
-	BatchInsertL2SentMsgDBTx(dbTx *sqlx.Tx, messages []*L2SentMsg) error
-	GetL2SentMsgByHash(l2Hash string) (*L2SentMsg, error)
-	GetLatestSentMsgHeightOnL2() (int64, error)
-	GetL2SentMessageByNonce(nonce uint64) (*L2SentMsg, error)
-	GetLatestL2SentMsgLEHeight(endBlockNumber uint64) (*L2SentMsg, error)
-	GetL2SentMsgMsgHashByHeightRange(startHeight, endHeight uint64) ([]*L2SentMsg, error)
-	UpdateL2MessageProofInDBTx(ctx context.Context, dbTx *sqlx.Tx, msgHash string, proof string, batchIndex uint64) error
-	GetLatestL2SentMsgBatchIndex() (int64, error)
-	GetClaimableL2SentMsgByAddressWithOffset(address string, offset int64, limit int64) ([]*L2SentMsg, error)
-	GetClaimableL2SentMsgByAddressTotalNum(address string) (uint64, error)
-	DeleteL2SentMsgAfterHeightDBTx(dbTx *sqlx.Tx, height int64) error
-}
-
-// RollupBatchOrm provides operations on rollup_batch table
-type RollupBatchOrm interface {
-	GetLatestRollupBatch() (*RollupBatch, error)
-	GetRollupBatchByIndex(index uint64) (*RollupBatch, error)
-	BatchInsertRollupBatchDBTx(dbTx *sqlx.Tx, messages []*RollupBatch) error
-}

bridge-history-api/db/orm/l1_cross_msg.go

@@ -1,148 +0,0 @@
-package orm
-
-import (
-	"context"
-	"database/sql"
-	"errors"
-	"time"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/log"
-	"github.com/jmoiron/sqlx"
-)
-
-type l1CrossMsgOrm struct {
-	db *sqlx.DB
-}
-
-// NewL1CrossMsgOrm create an NewL1CrossMsgOrm instance
-func NewL1CrossMsgOrm(db *sqlx.DB) L1CrossMsgOrm {
-	return &l1CrossMsgOrm{db: db}
-}
-
-func (l *l1CrossMsgOrm) GetL1CrossMsgByHash(l1Hash common.Hash) (*CrossMsg, error) {
-	result := &CrossMsg{}
-	row := l.db.QueryRowx(`SELECT * FROM cross_message WHERE layer1_hash = $1 AND msg_type = $2 AND deleted_at IS NULL;`, l1Hash.String(), Layer1Msg)
-	if err := row.StructScan(result); err != nil {
-		if errors.Is(err, sql.ErrNoRows) {
-			return nil, nil
-		}
-		return nil, err
-	}
-	return result, nil
-}
-
-// GetL1CrossMsgsByAddress returns all layer1 cross messages under given address
-// Warning: return empty slice if no data found
-func (l *l1CrossMsgOrm) GetL1CrossMsgsByAddress(sender common.Address) ([]*CrossMsg, error) {
-	var results []*CrossMsg
-	rows, err := l.db.Queryx(`SELECT * FROM cross_message WHERE sender = $1 AND msg_type = 1 AND deleted_at IS NULL;`, sender.String(), Layer1Msg)
-	if err != nil {
-		return nil, err
-	}
-	defer func() {
-		if err = rows.Close(); err != nil {
-			log.Error("failed to close rows", "err", err)
-		}
-	}()
-	for rows.Next() {
-		msg := &CrossMsg{}
-		if err = rows.StructScan(msg); err != nil {
-			break
-		}
-		results = append(results, msg)
-	}
-	if len(results) == 0 && errors.Is(err, sql.ErrNoRows) {
-	} else if err != nil {
-		return nil, err
-	}
-	return results, nil
-}
-
-func (l *l1CrossMsgOrm) BatchInsertL1CrossMsgDBTx(dbTx *sqlx.Tx, messages []*CrossMsg) error {
-	if len(messages) == 0 {
-		return nil
-	}
-	var err error
-	messageMaps := make([]map[string]interface{}, len(messages))
-	for i, msg := range messages {
-		messageMaps[i] = map[string]interface{}{
-			"height":       msg.Height,
-			"sender":       msg.Sender,
-			"target":       msg.Target,
-			"amount":       msg.Amount,
-			"asset":        msg.Asset,
-			"msg_hash":     msg.MsgHash,
-			"layer1_hash":  msg.Layer1Hash,
-			"layer1_token": msg.Layer1Token,
-			"layer2_token": msg.Layer2Token,
-			"token_ids":    msg.TokenIDs,
-			"msg_type":     Layer1Msg,
-		}
-	}
-	_, err = dbTx.NamedExec(`insert into cross_message(height, sender, target, amount, asset, msg_hash, layer1_hash, layer1_token, layer2_token, token_ids, msg_type) values(:height, :sender, :target, :amount, :asset, :msg_hash, :layer1_hash, :layer1_token, :layer2_token, :token_ids, :msg_type);`, messageMaps)
-	if err != nil {
-		log.Error("BatchInsertL1CrossMsgDBTx: failed to insert l1 cross msgs", "err", err)
-		return err
-	}
-
-	return nil
-}
-
-// UpdateL1CrossMsgHashDBTx update l1 cross msg hash in db, no need to check msg_type since layer1_hash wont be empty if its layer1 msg
-func (l *l1CrossMsgOrm) UpdateL1CrossMsgHashDBTx(ctx context.Context, dbTx *sqlx.Tx, l1Hash, msgHash common.Hash) error {
-	if _, err := dbTx.ExecContext(ctx, l.db.Rebind("update public.cross_message set msg_hash = ? where layer1_hash = ? AND deleted_at IS NULL;"), msgHash.String(), l1Hash.String()); err != nil {
-		return err
-	}
-	return nil
-
-}
-
-func (l *l1CrossMsgOrm) UpdateL1CrossMsgHash(ctx context.Context, l1Hash, msgHash common.Hash) error {
-	if _, err := l.db.ExecContext(ctx, l.db.Rebind("update public.l1_cross_message set msg_hash = ? where layer1_hash = ? AND deleted_at IS NULL;"), msgHash.String(), l1Hash.String()); err != nil {
-		return err
-	}
-	return nil
-
-}
-
-func (l *l1CrossMsgOrm) GetLatestL1ProcessedHeight() (int64, error) {
-	row := l.db.QueryRowx(`SELECT height FROM cross_message WHERE msg_type = $1 AND deleted_at IS NULL ORDER BY id DESC LIMIT 1;`, Layer1Msg)
-	var result sql.NullInt64
-	if err := row.Scan(&result); err != nil {
-		if err == sql.ErrNoRows || !result.Valid {
-			return -1, nil
-		}
-		return 0, err
-	}
-	if result.Valid {
-		return result.Int64, nil
-	}
-	return 0, nil
-}
-
-func (l *l1CrossMsgOrm) DeleteL1CrossMsgAfterHeightDBTx(dbTx *sqlx.Tx, height int64) error {
-	if _, err := l.db.Exec(`UPDATE cross_message SET deleted_at = current_timestamp WHERE height > $1 AND msg_type = $2;`, height, Layer1Msg); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (l *l1CrossMsgOrm) UpdateL1BlockTimestamp(height uint64, timestamp time.Time) error {
-	if _, err := l.db.Exec(`UPDATE cross_message SET block_timestamp = $1 where height = $2 AND msg_type = $3 AND deleted_at IS NULL`, timestamp, height, Layer1Msg); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (l *l1CrossMsgOrm) GetL1EarliestNoBlockTimestampHeight() (uint64, error) {
-	row := l.db.QueryRowx(`SELECT height FROM cross_message WHERE block_timestamp IS NULL AND msg_type = $1 AND deleted_at IS NULL ORDER BY height ASC LIMIT 1;`, Layer1Msg)
-	var result uint64
-	if err := row.Scan(&result); err != nil {
-		if err == sql.ErrNoRows {
-			return 0, nil
-		}
-		return 0, err
-	}
-	return result, nil
-}

bridge-history-api/db/orm/l2_cross_msg.go

@@ -1,177 +0,0 @@
-package orm
-
-import (
-	"context"
-	"database/sql"
-	"errors"
-	"time"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/log"
-	"github.com/jmoiron/sqlx"
-	"github.com/lib/pq"
-)
-
-type l2CrossMsgOrm struct {
-	db *sqlx.DB
-}
-
-// NewL2CrossMsgOrm create an NewL2CrossMsgOrm instance
-func NewL2CrossMsgOrm(db *sqlx.DB) L2CrossMsgOrm {
-	return &l2CrossMsgOrm{db: db}
-}
-
-func (l *l2CrossMsgOrm) GetL2CrossMsgByHash(l2Hash common.Hash) (*CrossMsg, error) {
-	result := &CrossMsg{}
-	row := l.db.QueryRowx(`SELECT * FROM cross_message WHERE layer2_hash = $1 AND deleted_at IS NULL;`, l2Hash.String())
-	if err := row.StructScan(result); err != nil {
-		if errors.Is(err, sql.ErrNoRows) {
-			return nil, nil
-		}
-		return nil, err
-	}
-	return result, nil
-}
-
-// GetL2CrossMsgByAddress returns all layer2 cross messages under given address
-// Warning: return empty slice if no data found
-func (l *l2CrossMsgOrm) GetL2CrossMsgByAddress(sender common.Address) ([]*CrossMsg, error) {
-	var results []*CrossMsg
-	rows, err := l.db.Queryx(`SELECT * FROM cross_message WHERE sender = $1 AND msg_type = $2 AND deleted_at IS NULL;`, sender.String(), Layer2Msg)
-	if err != nil {
-		return nil, err
-	}
-	defer func() {
-		if err = rows.Close(); err != nil {
-			log.Error("failed to close rows", "err", err)
-		}
-	}()
-	for rows.Next() {
-		msg := &CrossMsg{}
-		if err = rows.StructScan(msg); err != nil {
-			break
-		}
-		results = append(results, msg)
-	}
-	if len(results) == 0 && errors.Is(err, sql.ErrNoRows) {
-		// log.Warn("no unprocessed layer1 messages in db", "err", err)
-	} else if err != nil {
-		return nil, err
-	}
-	return results, nil
-
-}
-
-func (l *l2CrossMsgOrm) DeleteL2CrossMsgFromHeightDBTx(dbTx *sqlx.Tx, height int64) error {
-	_, err := dbTx.Exec(`UPDATE cross_message SET deleted_at = current_timestamp where height > $1 AND msg_type = $2 ;`, height, Layer2Msg)
-	if err != nil {
-		log.Error("DeleteL1CrossMsgAfterHeightDBTx: failed to delete", "height", height, "err", err)
-		return err
-	}
-	return nil
-}
-
-func (l *l2CrossMsgOrm) BatchInsertL2CrossMsgDBTx(dbTx *sqlx.Tx, messages []*CrossMsg) error {
-	if len(messages) == 0 {
-		return nil
-	}
-
-	var err error
-	messageMaps := make([]map[string]interface{}, len(messages))
-	for i, msg := range messages {
-		messageMaps[i] = map[string]interface{}{
-			"height":       msg.Height,
-			"sender":       msg.Sender,
-			"target":       msg.Target,
-			"asset":        msg.Asset,
-			"msg_hash":     msg.MsgHash,
-			"layer2_hash":  msg.Layer2Hash,
-			"layer1_token": msg.Layer1Token,
-			"layer2_token": msg.Layer2Token,
-			"token_ids":    msg.TokenIDs,
-			"amount":       msg.Amount,
-			"msg_type":     Layer2Msg,
-		}
-	}
-	_, err = dbTx.NamedExec(`insert into cross_message(height, sender, target, asset, msg_hash, layer2_hash, layer1_token, layer2_token, token_ids, amount, msg_type) values(:height, :sender, :target, :asset, :msg_hash, :layer2_hash, :layer1_token, :layer2_token, :token_ids, :amount, :msg_type);`, messageMaps)
-	if err != nil {
-		log.Error("BatchInsertL2CrossMsgDBTx: failed to insert l2 cross msgs", "err", err)
-		return err
-	}
-	return nil
-}
-
-func (l *l2CrossMsgOrm) UpdateL2CrossMsgHashDBTx(ctx context.Context, dbTx *sqlx.Tx, l2Hash, msgHash common.Hash) error {
-	if _, err := dbTx.ExecContext(ctx, l.db.Rebind("update cross_message set msg_hash = ? where layer2_hash = ? AND deleted_at IS NULL;"), msgHash.String(), l2Hash.String()); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (l *l2CrossMsgOrm) UpdateL2CrossMsgHash(ctx context.Context, l2Hash, msgHash common.Hash) error {
-	if _, err := l.db.ExecContext(ctx, l.db.Rebind("update cross_message set msg_hash = ? where layer2_hash = ? AND deleted_at IS NULL;"), msgHash.String(), l2Hash.String()); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (l *l2CrossMsgOrm) GetLatestL2ProcessedHeight() (int64, error) {
-	row := l.db.QueryRowx(`SELECT height FROM cross_message WHERE msg_type = $1 AND deleted_at IS NULL ORDER BY id DESC LIMIT 1;`, Layer2Msg)
-	var result sql.NullInt64
-	if err := row.Scan(&result); err != nil {
-		if err == sql.ErrNoRows || !result.Valid {
-			return -1, nil
-		}
-		return 0, err
-	}
-	if result.Valid {
-		return result.Int64, nil
-	}
-	return 0, nil
-}
-
-func (l *l2CrossMsgOrm) UpdateL2BlockTimestamp(height uint64, timestamp time.Time) error {
-	if _, err := l.db.Exec(`UPDATE cross_message SET block_timestamp = $1 where height = $2 AND msg_type = $3 AND deleted_at IS NULL`, timestamp, height, Layer2Msg); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (l *l2CrossMsgOrm) GetL2EarliestNoBlockTimestampHeight() (uint64, error) {
-	row := l.db.QueryRowx(`SELECT height FROM cross_message WHERE block_timestamp IS NULL AND msg_type = $1 AND deleted_at IS NULL ORDER BY height ASC LIMIT 1;`, Layer2Msg)
-	var result uint64
-	if err := row.Scan(&result); err != nil {
-		if err == sql.ErrNoRows {
-			return 0, nil
-		}
-		return 0, err
-	}
-	return result, nil
-}
-
-func (l *l2CrossMsgOrm) GetL2CrossMsgByMsgHashList(msgHashList []string) ([]*CrossMsg, error) {
-	var results []*CrossMsg
-	rows, err := l.db.Queryx(`SELECT * FROM cross_message WHERE msg_hash = ANY($1) AND msg_type = $2 AND deleted_at IS NULL;`, pq.Array(msgHashList), Layer2Msg)
-	if err != nil {
-		return nil, err
-	}
-	defer func() {
-		if err = rows.Close(); err != nil {
-			log.Error("failed to close rows", "err", err)
-		}
-	}()
-	for rows.Next() {
-		msg := &CrossMsg{}
-		if err = rows.StructScan(msg); err != nil {
-			break
-		}
-		results = append(results, msg)
-	}
-	if err != nil && !errors.Is(err, sql.ErrNoRows) {
-		return nil, err
-	}
-	if len(results) == 0 {
-		log.Debug("no L2CrossMsg under given msg hashes", "msg hash list", msgHashList)
-	}
-	return results, nil
-}

bridge-history-api/db/orm/l2_sent_msg.go

@@ -1,189 +0,0 @@
-package orm
-
-import (
-	"context"
-	"database/sql"
-	"time"
-
-	"github.com/ethereum/go-ethereum/log"
-	"github.com/jmoiron/sqlx"
-)
-
-// L2SentMsg defines the struct for l2_sent_msg table record
-type L2SentMsg struct {
-	ID             uint64     `json:"id" db:"id"`
-	OriginalSender string     `json:"original_sender" db:"original_sender"`
-	TxHash         string     `json:"tx_hash" db:"tx_hash"`
-	MsgHash        string     `json:"msg_hash" db:"msg_hash"`
-	Sender         string     `json:"sender" db:"sender"`
-	Target         string     `json:"target" db:"target"`
-	Value          string     `json:"value" db:"value"`
-	Height         uint64     `json:"height" db:"height"`
-	Nonce          uint64     `json:"nonce" db:"nonce"`
-	BatchIndex     uint64     `json:"batch_index" db:"batch_index"`
-	MsgProof       string     `json:"msg_proof" db:"msg_proof"`
-	MsgData        string     `json:"msg_data" db:"msg_data"`
-	CreatedAt      *time.Time `json:"created_at" db:"created_at"`
-	UpdatedAt      *time.Time `json:"updated_at" db:"updated_at"`
-	DeletedAt      *time.Time `json:"deleted_at" db:"deleted_at"`
-}
-
-type l2SentMsgOrm struct {
-	db *sqlx.DB
-}
-
-// NewL2SentMsgOrm create an NewRollupBatchOrm instance
-func NewL2SentMsgOrm(db *sqlx.DB) L2SentMsgOrm {
-	return &l2SentMsgOrm{db: db}
-}
-
-func (l *l2SentMsgOrm) GetL2SentMsgByHash(msgHash string) (*L2SentMsg, error) {
-	result := &L2SentMsg{}
-	row := l.db.QueryRowx(`SELECT * FROM l2_sent_msg WHERE msg_hash = $1 AND deleted_at IS NULL;`, msgHash)
-	if err := row.StructScan(result); err != nil {
-		return nil, err
-	}
-	return result, nil
-}
-
-func (l *l2SentMsgOrm) BatchInsertL2SentMsgDBTx(dbTx *sqlx.Tx, messages []*L2SentMsg) error {
-	if len(messages) == 0 {
-		return nil
-	}
-	var err error
-	messageMaps := make([]map[string]interface{}, len(messages))
-	for i, msg := range messages {
-		messageMaps[i] = map[string]interface{}{
-			"original_sender": msg.OriginalSender,
-			"tx_hash":         msg.TxHash,
-			"sender":          msg.Sender,
-			"target":          msg.Target,
-			"value":           msg.Value,
-			"msg_hash":        msg.MsgHash,
-			"height":          msg.Height,
-			"nonce":           msg.Nonce,
-			"batch_index":     msg.BatchIndex,
-			"msg_proof":       msg.MsgProof,
-			"msg_data":        msg.MsgData,
-		}
-	}
-	_, err = dbTx.NamedExec(`insert into l2_sent_msg(original_sender, tx_hash, sender, target, value, msg_hash, height, nonce, batch_index, msg_proof, msg_data) values(:original_sender, :tx_hash, :sender, :target, :value, :msg_hash, :height, :nonce, :batch_index, :msg_proof, :msg_data);`, messageMaps)
-	if err != nil {
-		log.Error("BatchInsertL2SentMsgDBTx: failed to insert l2 sent msgs", "err", err)
-		return err
-	}
-	return err
-}
-
-func (l *l2SentMsgOrm) GetLatestSentMsgHeightOnL2() (int64, error) {
-	row := l.db.QueryRow(`SELECT height FROM l2_sent_msg WHERE deleted_at IS NULL ORDER BY nonce DESC LIMIT 1;`)
-	var result sql.NullInt64
-	if err := row.Scan(&result); err != nil {
-		if err == sql.ErrNoRows || !result.Valid {
-			return -1, nil
-		}
-		return 0, err
-	}
-	if result.Valid {
-		return result.Int64, nil
-	}
-	return 0, nil
-}
-
-func (l *l2SentMsgOrm) UpdateL2MessageProofInDBTx(ctx context.Context, dbTx *sqlx.Tx, msgHash string, proof string, batchIndex uint64) error {
-	if _, err := dbTx.ExecContext(ctx, l.db.Rebind("update l2_sent_msg set msg_proof = ?, batch_index = ? where msg_hash = ? AND deleted_at IS NULL;"), proof, batchIndex, msgHash); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (l *l2SentMsgOrm) GetLatestL2SentMsgBatchIndex() (int64, error) {
-	row := l.db.QueryRow(`SELECT batch_index FROM l2_sent_msg WHERE batch_index != 0 AND deleted_at IS NULL ORDER BY batch_index DESC LIMIT 1;`)
-	var result sql.NullInt64
-	if err := row.Scan(&result); err != nil {
-		if err == sql.ErrNoRows || !result.Valid {
-			return -1, nil
-		}
-		return -1, err
-	}
-	if result.Valid {
-		return result.Int64, nil
-	}
-	return -1, nil
-}
-
-func (l *l2SentMsgOrm) GetL2SentMsgMsgHashByHeightRange(startHeight, endHeight uint64) ([]*L2SentMsg, error) {
-	var results []*L2SentMsg
-	rows, err := l.db.Queryx(`SELECT * FROM l2_sent_msg WHERE height >= $1 AND height <= $2 AND deleted_at IS NULL ORDER BY nonce ASC;`, startHeight, endHeight)
-	if err != nil {
-		return nil, err
-	}
-	defer func() {
-		if err = rows.Close(); err != nil {
-			log.Error("failed to close rows", "err", err)
-		}
-	}()
-	for rows.Next() {
-		msg := &L2SentMsg{}
-		if err = rows.StructScan(msg); err != nil {
-			break
-		}
-		results = append(results, msg)
-	}
-	return results, err
-}
-
-func (l *l2SentMsgOrm) GetL2SentMessageByNonce(nonce uint64) (*L2SentMsg, error) {
-	result := &L2SentMsg{}
-	row := l.db.QueryRowx(`SELECT * FROM l2_sent_msg WHERE nonce = $1 AND deleted_at IS NULL;`, nonce)
-	err := row.StructScan(result)
-	if err != nil {
-		return nil, err
-	}
-	return result, nil
-}
-
-func (l *l2SentMsgOrm) GetLatestL2SentMsgLEHeight(endBlockNumber uint64) (*L2SentMsg, error) {
-	result := &L2SentMsg{}
-	row := l.db.QueryRowx(`select * from l2_sent_msg where height <= $1 AND deleted_at IS NULL order by nonce desc limit 1`, endBlockNumber)
-	err := row.StructScan(result)
-	if err != nil {
-		return nil, err
-	}
-	return result, nil
-}
-
-func (l *l2SentMsgOrm) DeleteL2SentMsgAfterHeightDBTx(dbTx *sqlx.Tx, height int64) error {
-	_, err := dbTx.Exec(`UPDATE l2_sent_msg SET deleted_at = current_timestamp WHERE height > $1;`, height)
-	return err
-}
-
-func (l *l2SentMsgOrm) GetClaimableL2SentMsgByAddressWithOffset(address string, offset int64, limit int64) ([]*L2SentMsg, error) {
-	var results []*L2SentMsg
-	rows, err := l.db.Queryx(`SELECT * FROM l2_sent_msg WHERE id NOT IN (SELECT l2_sent_msg.id FROM l2_sent_msg INNER JOIN relayed_msg ON l2_sent_msg.msg_hash = relayed_msg.msg_hash WHERE l2_sent_msg.deleted_at IS NULL AND relayed_msg.deleted_at IS NULL) AND (original_sender=$1 OR sender = $1) ORDER BY id DESC LIMIT $2 OFFSET $3;`, address, limit, offset)
-	if err != nil {
-		return nil, err
-	}
-	defer func() {
-		if err = rows.Close(); err != nil {
-			log.Error("failed to close rows", "err", err)
-		}
-	}()
-	for rows.Next() {
-		msg := &L2SentMsg{}
-		if err = rows.StructScan(msg); err != nil {
-			break
-		}
-		results = append(results, msg)
-	}
-	return results, err
-}
-
-func (l *l2SentMsgOrm) GetClaimableL2SentMsgByAddressTotalNum(address string) (uint64, error) {
-	var count uint64
-	row := l.db.QueryRowx(`SELECT COUNT(*) FROM l2_sent_msg WHERE id NOT IN (SELECT l2_sent_msg.id FROM l2_sent_msg INNER JOIN relayed_msg ON l2_sent_msg.msg_hash = relayed_msg.msg_hash WHERE l2_sent_msg.deleted_at IS NULL AND relayed_msg.deleted_at IS NULL) AND (original_sender=$1 OR sender = $1);`, address)
-	if err := row.Scan(&count); err != nil {
-		return 0, err
-	}
-	return count, nil
-}

bridge-history-api/db/orm/relayed_msg.go

@@ -1,100 +0,0 @@
-package orm
-
-import (
-	"database/sql"
-	"errors"
-
-	"github.com/ethereum/go-ethereum/log"
-	"github.com/jmoiron/sqlx"
-)
-
-// RelayedMsg is the struct for relayed_msg table
-type RelayedMsg struct {
-	MsgHash    string `json:"msg_hash" db:"msg_hash"`
-	Height     uint64 `json:"height" db:"height"`
-	Layer1Hash string `json:"layer1_hash" db:"layer1_hash"`
-	Layer2Hash string `json:"layer2_hash" db:"layer2_hash"`
-}
-
-type relayedMsgOrm struct {
-	db *sqlx.DB
-}
-
-// NewRelayedMsgOrm create an NewRelayedMsgOrm instance
-func NewRelayedMsgOrm(db *sqlx.DB) RelayedMsgOrm {
-	return &relayedMsgOrm{db: db}
-}
-
-func (l *relayedMsgOrm) BatchInsertRelayedMsgDBTx(dbTx *sqlx.Tx, messages []*RelayedMsg) error {
-	if len(messages) == 0 {
-		return nil
-	}
-	var err error
-	messageMaps := make([]map[string]interface{}, len(messages))
-	for i, msg := range messages {
-		messageMaps[i] = map[string]interface{}{
-			"msg_hash":    msg.MsgHash,
-			"height":      msg.Height,
-			"layer1_hash": msg.Layer1Hash,
-			"layer2_hash": msg.Layer2Hash,
-		}
-	}
-	_, err = dbTx.NamedExec(`insert into relayed_msg(msg_hash, height, layer1_hash, layer2_hash) values(:msg_hash, :height, :layer1_hash, :layer2_hash);`, messageMaps)
-	if err != nil {
-		log.Error("BatchInsertRelayedMsgDBTx: failed to insert relayed msgs", "err", err)
-		return err
-	}
-	return nil
-}
-
-func (l *relayedMsgOrm) GetRelayedMsgByHash(msgHash string) (*RelayedMsg, error) {
-	result := &RelayedMsg{}
-	row := l.db.QueryRowx(`SELECT msg_hash, height, layer1_hash, layer2_hash FROM relayed_msg WHERE msg_hash = $1 AND deleted_at IS NULL;`, msgHash)
-	if err := row.StructScan(result); err != nil {
-		if errors.Is(err, sql.ErrNoRows) {
-			return nil, nil
-		}
-		return nil, err
-	}
-	return result, nil
-}
-
-func (l *relayedMsgOrm) GetLatestRelayedHeightOnL1() (int64, error) {
-	row := l.db.QueryRow(`SELECT height FROM relayed_msg WHERE layer1_hash != '' AND deleted_at IS NULL ORDER BY height DESC LIMIT 1;`)
-	var result sql.NullInt64
-	if err := row.Scan(&result); err != nil {
-		if err == sql.ErrNoRows || !result.Valid {
-			return -1, nil
-		}
-		return 0, err
-	}
-	if result.Valid {
-		return result.Int64, nil
-	}
-	return 0, nil
-}
-
-func (l *relayedMsgOrm) GetLatestRelayedHeightOnL2() (int64, error) {
-	row := l.db.QueryRow(`SELECT height FROM relayed_msg WHERE layer2_hash != '' AND deleted_at IS NULL ORDER BY height DESC LIMIT 1;`)
-	var result sql.NullInt64
-	if err := row.Scan(&result); err != nil {
-		if err == sql.ErrNoRows || !result.Valid {
-			return -1, nil
-		}
-		return 0, err
-	}
-	if result.Valid {
-		return result.Int64, nil
-	}
-	return 0, nil
-}
-
-func (l *relayedMsgOrm) DeleteL1RelayedHashAfterHeightDBTx(dbTx *sqlx.Tx, height int64) error {
-	_, err := dbTx.Exec(`UPDATE relayed_msg SET deleted_at = current_timestamp WHERE height > $1 AND layer1_hash != '';`, height)
-	return err
-}
-
-func (l *relayedMsgOrm) DeleteL2RelayedHashAfterHeightDBTx(dbTx *sqlx.Tx, height int64) error {
-	_, err := dbTx.Exec(`UPDATE relayed_msg SET deleted_at = current_timestamp WHERE height > $1 AND layer2_hash != '';`, height)
-	return err
-}

bridge-history-api/db/orm_factory.go

@@ -1,103 +0,0 @@
-package db
-
-import (
-	"database/sql"
-	"errors"
-
-	"github.com/ethereum/go-ethereum/log"
-	"github.com/jmoiron/sqlx"
-	_ "github.com/lib/pq" //nolint:golint
-
-	"bridge-history-api/config"
-	"bridge-history-api/db/orm"
-)
-
-// OrmFactory include all ormFactory interface
-type OrmFactory interface {
-	orm.L1CrossMsgOrm
-	orm.L2CrossMsgOrm
-	orm.RelayedMsgOrm
-	orm.L2SentMsgOrm
-	orm.RollupBatchOrm
-	GetTotalCrossMsgCountByAddress(sender string) (uint64, error)
-	GetCrossMsgsByAddressWithOffset(sender string, offset int64, limit int64) ([]*orm.CrossMsg, error)
-	GetDB() *sqlx.DB
-	Beginx() (*sqlx.Tx, error)
-	Close() error
-}
-
-type ormFactory struct {
-	orm.L1CrossMsgOrm
-	orm.L2CrossMsgOrm
-	orm.RelayedMsgOrm
-	orm.L2SentMsgOrm
-	orm.RollupBatchOrm
-	*sqlx.DB
-}
-
-// NewOrmFactory create an ormFactory factory include all ormFactory interface
-func NewOrmFactory(cfg *config.Config) (OrmFactory, error) {
-	// Initialize sql/sqlx
-	db, err := sqlx.Open(cfg.DB.DriverName, cfg.DB.DSN)
-	if err != nil {
-		return nil, err
-	}
-
-	db.SetMaxOpenConns(cfg.DB.MaxOpenNum)
-	db.SetMaxIdleConns(cfg.DB.MaxIdleNum)
-	if err = db.Ping(); err != nil {
-		return nil, err
-	}
-
-	return &ormFactory{
-		L1CrossMsgOrm:  orm.NewL1CrossMsgOrm(db),
-		L2CrossMsgOrm:  orm.NewL2CrossMsgOrm(db),
-		RelayedMsgOrm:  orm.NewRelayedMsgOrm(db),
-		L2SentMsgOrm:   orm.NewL2SentMsgOrm(db),
-		RollupBatchOrm: orm.NewRollupBatchOrm(db),
-		DB:             db,
-	}, nil
-}
-
-func (o *ormFactory) GetDB() *sqlx.DB {
-	return o.DB
-}
-
-func (o *ormFactory) Beginx() (*sqlx.Tx, error) {
-	return o.DB.Beginx()
-}
-
-func (o *ormFactory) GetTotalCrossMsgCountByAddress(sender string) (uint64, error) {
-	var count uint64
-	row := o.DB.QueryRowx(`SELECT COUNT(*) FROM cross_message WHERE sender = $1 AND deleted_at IS NULL;`, sender)
-	if err := row.Scan(&count); err != nil {
-		return 0, err
-	}
-	return count, nil
-}
-
-func (o *ormFactory) GetCrossMsgsByAddressWithOffset(sender string, offset int64, limit int64) ([]*orm.CrossMsg, error) {
-	para := sender
-	var results []*orm.CrossMsg
-	rows, err := o.DB.Queryx(`SELECT * FROM cross_message WHERE sender = $1 AND deleted_at IS NULL ORDER BY block_timestamp DESC NULLS FIRST, id DESC LIMIT $2 OFFSET $3;`, para, limit, offset)
-	if err != nil || rows == nil {
-		return nil, err
-	}
-	defer func() {
-		if err = rows.Close(); err != nil {
-			log.Error("failed to close rows", "err", err)
-		}
-	}()
-	for rows.Next() {
-		msg := &orm.CrossMsg{}
-		if err = rows.StructScan(msg); err != nil {
-			break
-		}
-		results = append(results, msg)
-	}
-	if len(results) == 0 && errors.Is(err, sql.ErrNoRows) {
-	} else if err != nil {
-		return nil, err
-	}
-	return results, nil
-}

bridge-history-api/go.mod

@@ -1,154 +1,124 @@
-module bridge-history-api
+module scroll-tech/bridge-history-api
 
-go 1.19
+go 1.22
+
+toolchain go1.22.2
 
 require (
-	github.com/ethereum/go-ethereum v1.12.0
-	github.com/iris-contrib/middleware/cors v0.0.0-20230531125531-980d3a09a458
-	github.com/jmoiron/sqlx v1.3.5
-	github.com/kataras/iris/v12 v12.2.0
-	github.com/lib/pq v1.10.7
-	github.com/mattn/go-colorable v0.1.13
-	github.com/mattn/go-isatty v0.0.19
-	github.com/modern-go/reflect2 v1.0.2
-	github.com/pressly/goose/v3 v3.7.0
-	github.com/stretchr/testify v1.8.3
+	github.com/gin-contrib/cors v1.5.0
+	github.com/gin-gonic/gin v1.9.1
+	github.com/go-redis/redis/v8 v8.11.5
+	github.com/pressly/goose/v3 v3.16.0
+	github.com/prometheus/client_golang v1.19.0
+	github.com/scroll-tech/da-codec v0.1.3-0.20250826112206-b4cce5c5d178
+	github.com/scroll-tech/go-ethereum v1.10.14-0.20250729113104-bd8f141bb3e9
+	github.com/stretchr/testify v1.9.0
 	github.com/urfave/cli/v2 v2.25.7
+	golang.org/x/sync v0.11.0
+	gorm.io/gorm v1.25.7-0.20240204074919-46816ad31dde
 )
 
+replace github.com/scroll-tech/go-ethereum => github.com/scroll-tech/go-ethereum v1.10.14-0.20250729113104-bd8f141bb3e9 // It's a hotfix for the header hash incompatibility issue, pls change this with caution
+
 require (
-	github.com/BurntSushi/toml v1.3.2 // indirect
-	github.com/CloudyKit/fastprinter v0.0.0-20200109182630-33d98a066a53 // indirect
-	github.com/CloudyKit/jet/v6 v6.2.0 // indirect
-	github.com/DataDog/zstd v1.5.2 // indirect
-	github.com/Joker/jade v1.1.3 // indirect
-	github.com/Shopify/goreferrer v0.0.0-20220729165902-8cddb4f5de06 // indirect
-	github.com/VictoriaMetrics/fastcache v1.6.0 // indirect
-	github.com/andybalholm/brotli v1.0.5 // indirect
-	github.com/aymerick/douceur v0.2.0 // indirect
+	dario.cat/mergo v1.0.0 // indirect
+	github.com/VictoriaMetrics/fastcache v1.12.2 // indirect
 	github.com/beorn7/perks v1.0.1 // indirect
-	github.com/bits-and-blooms/bitset v1.7.0 // indirect
-	github.com/blang/semver/v4 v4.0.0 // indirect
+	github.com/bits-and-blooms/bitset v1.20.0 // indirect
 	github.com/btcsuite/btcd v0.20.1-beta // indirect
-	github.com/btcsuite/btcd/btcec/v2 v2.3.2 // indirect
+	github.com/bytedance/sonic v1.10.1 // indirect
 	github.com/cespare/xxhash/v2 v2.2.0 // indirect
-	github.com/cockroachdb/errors v1.9.1 // indirect
-	github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b // indirect
-	github.com/cockroachdb/pebble v0.0.0-20230209160836-829675f94811 // indirect
-	github.com/cockroachdb/redact v1.1.3 // indirect
+	github.com/chenzhuoyu/base64x v0.0.0-20230717121745-296ad89f973d // indirect
+	github.com/chenzhuoyu/iasm v0.9.0 // indirect
 	github.com/consensys/bavard v0.1.13 // indirect
-	github.com/consensys/gnark-crypto v0.10.0 // indirect
-	github.com/cpuguy83/go-md2man/v2 v2.0.2 // indirect
-	github.com/crate-crypto/go-kzg-4844 v0.2.0 // indirect
+	github.com/consensys/gnark-crypto v0.13.0 // indirect
+	github.com/cpuguy83/go-md2man/v2 v2.0.3 // indirect
+	github.com/crate-crypto/go-kzg-4844 v1.1.0 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/deckarep/golang-set/v2 v2.1.0 // indirect
-	github.com/decred/dcrd/dcrec/secp256k1/v4 v4.2.0 // indirect
-	github.com/deepmap/oapi-codegen v1.8.2 // indirect
-	github.com/docker/docker v20.10.21+incompatible // indirect
-	github.com/eknkc/amber v0.0.0-20171010120322-cdade1c07385 // indirect
-	github.com/ethereum/c-kzg-4844 v0.2.0 // indirect
-	github.com/fatih/structs v1.1.0 // indirect
-	github.com/fjl/memsize v0.0.0-20190710130421-bcb5799ab5e5 // indirect
-	github.com/flosch/pongo2/v4 v4.0.2 // indirect
+	github.com/deckarep/golang-set v0.0.0-20180603214616-504e848d77ea // indirect
+	github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
+	github.com/docker/cli v25.0.4-0.20240305161310-2bf4225ad269+incompatible // indirect
+	github.com/docker/docker v26.1.0+incompatible // indirect
+	github.com/docker/go-connections v0.5.0 // indirect
+	github.com/edsrzf/mmap-go v1.0.0 // indirect
+	github.com/ethereum/c-kzg-4844 v1.0.3 // indirect
+	github.com/fjl/memsize v0.0.2 // indirect
 	github.com/fsnotify/fsnotify v1.6.0 // indirect
+	github.com/gabriel-vasile/mimetype v1.4.2 // indirect
 	github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff // indirect
-	github.com/getsentry/sentry-go v0.18.0 // indirect
-	github.com/go-ole/go-ole v1.2.6 // indirect
-	github.com/go-sql-driver/mysql v1.7.0 // indirect
+	github.com/gin-contrib/sse v0.1.0 // indirect
+	github.com/go-ole/go-ole v1.3.0 // indirect
+	github.com/go-playground/locales v0.14.1 // indirect
+	github.com/go-playground/universal-translator v0.18.1 // indirect
+	github.com/go-playground/validator/v10 v10.15.5 // indirect
 	github.com/go-stack/stack v1.8.1 // indirect
-	github.com/gobwas/httphead v0.1.0 // indirect
-	github.com/gobwas/pool v0.2.1 // indirect
-	github.com/gobwas/ws v1.1.0 // indirect
-	github.com/gofrs/flock v0.8.1 // indirect
-	github.com/gogo/protobuf v1.3.2 // indirect
-	github.com/golang-jwt/jwt/v4 v4.5.0 // indirect
-	github.com/golang/protobuf v1.5.2 // indirect
+	github.com/goccy/go-json v0.10.2 // indirect
 	github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb // indirect
-	github.com/google/uuid v1.3.0 // indirect
-	github.com/gorilla/css v1.0.0 // indirect
+	github.com/google/uuid v1.6.0 // indirect
 	github.com/gorilla/websocket v1.5.0 // indirect
-	github.com/graph-gophers/graphql-go v1.3.0 // indirect
 	github.com/hashicorp/go-bexpr v0.1.10 // indirect
+	github.com/hashicorp/golang-lru v0.5.5-0.20210104140557-80c98217689d // indirect
 	github.com/holiman/bloomfilter/v2 v2.0.3 // indirect
-	github.com/holiman/uint256 v1.2.2 // indirect
-	github.com/huin/goupnp v1.0.3 // indirect
-	github.com/influxdata/influxdb-client-go/v2 v2.4.0 // indirect
-	github.com/influxdata/influxdb1-client v0.0.0-20220302092344-a9ab5670611c // indirect
-	github.com/influxdata/line-protocol v0.0.0-20210311194329-9aa0e372d097 // indirect
-	github.com/iris-contrib/go.uuid v2.0.0+incompatible // indirect
-	github.com/iris-contrib/schema v0.0.6 // indirect
+	github.com/holiman/uint256 v1.3.2 // indirect
+	github.com/huin/goupnp v1.3.0 // indirect
+	github.com/iden3/go-iden3-crypto v0.0.17 // indirect
+	github.com/jackc/pgx/v5 v5.5.4 // indirect
 	github.com/jackpal/go-nat-pmp v1.0.2 // indirect
-	github.com/josharian/intern v1.0.0 // indirect
-	github.com/kataras/blocks v0.0.7 // indirect
-	github.com/kataras/golog v0.1.8 // indirect
-	github.com/kataras/neffos v0.0.21 // indirect
-	github.com/kataras/pio v0.0.11 // indirect
-	github.com/kataras/sitemap v0.0.6 // indirect
-	github.com/kataras/tunnel v0.0.4 // indirect
-	github.com/klauspost/compress v1.16.0 // indirect
-	github.com/kr/pretty v0.3.1 // indirect
-	github.com/kr/text v0.2.0 // indirect
-	github.com/mailgun/raymond/v2 v2.0.48 // indirect
-	github.com/mailru/easyjson v0.7.7 // indirect
-	github.com/mattn/go-runewidth v0.0.14 // indirect
-	github.com/mattn/go-sqlite3 v1.14.14 // indirect
-	github.com/matttproud/golang_protobuf_extensions v1.0.4 // indirect
-	github.com/mediocregopher/radix/v3 v3.8.1 // indirect
-	github.com/microcosm-cc/bluemonday v1.0.23 // indirect
+	github.com/jinzhu/inflection v1.0.0 // indirect
+	github.com/jinzhu/now v1.1.5 // indirect
+	github.com/json-iterator/go v1.1.12 // indirect
+	github.com/klauspost/compress v1.17.9 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.5 // indirect
+	github.com/leodido/go-urn v1.2.4 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
+	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/mattn/go-runewidth v0.0.15 // indirect
 	github.com/mitchellh/mapstructure v1.5.0 // indirect
 	github.com/mitchellh/pointerstructure v1.2.0 // indirect
 	github.com/mmcloughlin/addchain v0.4.0 // indirect
-	github.com/nats-io/nats.go v1.23.0 // indirect
-	github.com/nats-io/nkeys v0.3.0 // indirect
-	github.com/nats-io/nuid v1.0.1 // indirect
+	github.com/moby/docker-image-spec v1.3.1 // indirect
+	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
+	github.com/modern-go/reflect2 v1.0.2 // indirect
 	github.com/olekukonko/tablewriter v0.0.5 // indirect
-	github.com/onsi/ginkgo v1.16.5 // indirect
 	github.com/onsi/gomega v1.27.1 // indirect
-	github.com/opentracing/opentracing-go v1.1.0 // indirect
-	github.com/peterh/liner v1.1.1-0.20190123174540-a2c9a5303de7 // indirect
+	github.com/opencontainers/image-spec v1.1.0 // indirect
+	github.com/pelletier/go-toml/v2 v2.1.0 // indirect
 	github.com/pkg/errors v0.9.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
-	github.com/prometheus/client_golang v1.14.0 // indirect
-	github.com/prometheus/client_model v0.3.0 // indirect
-	github.com/prometheus/common v0.39.0 // indirect
-	github.com/prometheus/procfs v0.9.0 // indirect
+	github.com/prometheus/client_model v0.5.0 // indirect
+	github.com/prometheus/common v0.48.0 // indirect
+	github.com/prometheus/procfs v0.12.0 // indirect
+	github.com/prometheus/tsdb v0.7.1 // indirect
 	github.com/rivo/uniseg v0.4.4 // indirect
-	github.com/rogpeppe/go-internal v1.10.0 // indirect
+	github.com/rjeczalik/notify v0.9.1 // indirect
 	github.com/rs/cors v1.7.0 // indirect
 	github.com/russross/blackfriday/v2 v2.1.0 // indirect
-	github.com/schollz/closestmatch v2.1.0+incompatible // indirect
-	github.com/sergi/go-diff v1.2.0 // indirect
+	github.com/scroll-tech/zktrie v0.8.4 // indirect
+	github.com/sethvargo/go-retry v0.2.4 // indirect
 	github.com/shirou/gopsutil v3.21.11+incompatible // indirect
-	github.com/sirupsen/logrus v1.9.0 // indirect
+	github.com/sourcegraph/conc v0.3.0 // indirect
 	github.com/status-im/keycard-go v0.2.0 // indirect
-	github.com/supranational/blst v0.3.11-0.20230406105308-e9dfc5ee724b // indirect
+	github.com/supranational/blst v0.3.13 // indirect
 	github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 // indirect
-	github.com/tdewolff/minify/v2 v2.12.4 // indirect
-	github.com/tdewolff/parse/v2 v2.6.4 // indirect
-	github.com/tklauser/go-sysconf v0.3.11 // indirect
-	github.com/tklauser/numcpus v0.6.0 // indirect
+	github.com/tklauser/go-sysconf v0.3.14 // indirect
+	github.com/tklauser/numcpus v0.9.0 // indirect
+	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
 	github.com/tyler-smith/go-bip39 v1.1.0 // indirect
-	github.com/valyala/bytebufferpool v1.0.0 // indirect
-	github.com/vmihailenco/msgpack/v5 v5.3.5 // indirect
-	github.com/vmihailenco/tagparser/v2 v2.0.0 // indirect
+	github.com/ugorji/go/codec v1.2.11 // indirect
 	github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 // indirect
-	github.com/yosssi/ace v0.0.5 // indirect
-	github.com/yusufpapurcu/wmi v1.2.2 // indirect
-	golang.org/x/crypto v0.11.0 // indirect
-	golang.org/x/exp v0.0.0-20230206171751-46f607a40771 // indirect
-	golang.org/x/net v0.12.0 // indirect
-	golang.org/x/sync v0.3.0 // indirect
-	golang.org/x/sys v0.10.0 // indirect
-	golang.org/x/text v0.11.0 // indirect
+	github.com/yusufpapurcu/wmi v1.2.4 // indirect
+	go.opentelemetry.io/otel/trace v1.24.0 // indirect
+	go.uber.org/multierr v1.11.0 // indirect
+	golang.org/x/arch v0.5.0 // indirect
+	golang.org/x/crypto v0.24.0 // indirect
+	golang.org/x/net v0.25.0 // indirect
+	golang.org/x/sys v0.30.0 // indirect
+	golang.org/x/text v0.21.0 // indirect
 	golang.org/x/time v0.3.0 // indirect
-	golang.org/x/tools v0.11.0 // indirect
-	golang.org/x/xerrors v0.0.0-20220517211312-f3a8303e98df // indirect
-	google.golang.org/protobuf v1.31.0 // indirect
-	gopkg.in/ini.v1 v1.67.0 // indirect
-	gopkg.in/natefinch/lumberjack.v2 v2.0.0 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20231127180814-3a041ad873d4 // indirect
+	google.golang.org/protobuf v1.33.0 // indirect
 	gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce // indirect
-	gopkg.in/yaml.v2 v2.4.0 // indirect
+	gopkg.in/urfave/cli.v1 v1.20.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 	rsc.io/tmplfunc v0.0.3 // indirect
-
 )

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

@@ -0,0 +1,83 @@
+package config
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+
+	"scroll-tech/common/database"
+	"scroll-tech/common/utils"
+)
+
+// FetcherConfig is the configuration of Layer1 or Layer2 fetcher.
+type FetcherConfig struct {
+	Confirmation             uint64 `json:"confirmation"`
+	Endpoint                 string `json:"endpoint"`
+	StartHeight              uint64 `json:"startHeight"` // Can only be configured to contract deployment height, message proof should be updated from the very beginning.
+	BlockTime                int64  `json:"blockTime"`
+	FetchLimit               uint64 `json:"fetchLimit"`
+	MessengerAddr            string `json:"MessengerAddr"`
+	ETHGatewayAddr           string `json:"ETHGatewayAddr"`
+	StandardERC20GatewayAddr string `json:"StandardERC20GatewayAddr"`
+	CustomERC20GatewayAddr   string `json:"CustomERC20GatewayAddr"`
+	WETHGatewayAddr          string `json:"WETHGatewayAddr"`
+	DAIGatewayAddr           string `json:"DAIGatewayAddr"`
+	USDCGatewayAddr          string `json:"USDCGatewayAddr"`
+	LIDOGatewayAddr          string `json:"LIDOGatewayAddr"`
+	PufferGatewayAddr        string `json:"PufferGatewayAddr"`
+	ERC721GatewayAddr        string `json:"ERC721GatewayAddr"`
+	ERC1155GatewayAddr       string `json:"ERC1155GatewayAddr"`
+	ScrollChainAddr          string `json:"ScrollChainAddr"`
+	GatewayRouterAddr        string `json:"GatewayRouterAddr"`
+	MessageQueueAddr         string `json:"MessageQueueAddr"`
+	MessageQueueV2Addr       string `json:"MessageQueueV2Addr"`
+	BatchBridgeGatewayAddr   string `json:"BatchBridgeGatewayAddr"`
+	GasTokenGatewayAddr      string `json:"GasTokenGatewayAddr"`
+	WrappedTokenGatewayAddr  string `json:"WrappedTokenGatewayAddr"`
+
+	BeaconNodeAPIEndpoint  string `json:"BeaconNodeAPIEndpoint"`
+	BlobScanAPIEndpoint    string `json:"BlobScanAPIEndpoint"`
+	BlockNativeAPIEndpoint string `json:"BlockNativeAPIEndpoint"`
+	AwsS3Endpoint          string `json:"AwsS3Endpoint"`
+}
+
+// RedisConfig redis config
+type RedisConfig struct {
+	Address       string `json:"address"`
+	Username      string `json:"username"`
+	Password      string `json:"password"`
+	DB            int    `json:"db"`
+	Local         bool   `json:"local"`
+	MinIdleConns  int    `json:"minIdleConns"`
+	ReadTimeoutMs int    `json:"readTimeoutMs"`
+}
+
+// Config is the configuration of the bridge history backend
+type Config struct {
+	L1    *FetcherConfig   `json:"L1"`
+	L2    *FetcherConfig   `json:"L2"`
+	DB    *database.Config `json:"db"`
+	Redis *RedisConfig     `json:"redis"`
+}
+
+// NewConfig returns a new instance of Config.
+func NewConfig(file string) (*Config, error) {
+	buf, err := os.ReadFile(filepath.Clean(file))
+	if err != nil {
+		return nil, err
+	}
+
+	cfg := &Config{}
+	err = json.Unmarshal(buf, cfg)
+	if err != nil {
+		return nil, err
+	}
+
+	// Override config with environment variables
+	err = utils.OverrideConfigWithEnv(cfg, "SCROLL_BRIDGE_HISTORY")
+	if err != nil {
+		return nil, err
+	}
+
+	return cfg, nil
+}

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

@@ -0,0 +1,34 @@
+package api
+
+import (
+	"sync"
+
+	"github.com/go-redis/redis/v8"
+	"gorm.io/gorm"
+)
+
+var (
+	// TxsByAddressCtl the TxsByAddressController instance
+	TxsByAddressCtl *TxsByAddressController
+
+	// TxsByHashesCtl the TxsByHashesController instance
+	TxsByHashesCtl *TxsByHashesController
+
+	// L2UnclaimedWithdrawalsByAddressCtl the L2UnclaimedWithdrawalsByAddressController instance
+	L2UnclaimedWithdrawalsByAddressCtl *L2UnclaimedWithdrawalsByAddressController
+
+	// L2WithdrawalsByAddressCtl the L2WithdrawalsByAddressController instance
+	L2WithdrawalsByAddressCtl *L2WithdrawalsByAddressController
+
+	initControllerOnce sync.Once
+)
+
+// InitController inits Controller with database
+func InitController(db *gorm.DB, redis *redis.Client) {
+	initControllerOnce.Do(func() {
+		TxsByAddressCtl = NewTxsByAddressController(db, redis)
+		TxsByHashesCtl = NewTxsByHashesController(db, redis)
+		L2UnclaimedWithdrawalsByAddressCtl = NewL2UnclaimedWithdrawalsByAddressController(db, redis)
+		L2WithdrawalsByAddressCtl = NewL2WithdrawalsByAddressController(db, redis)
+	})
+}

bridge-history-api/internal/controller/api/l2unclaimed_withdrawals_by_address.go

@@ -0,0 +1,40 @@
+package api
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/go-redis/redis/v8"
+	"gorm.io/gorm"
+
+	"scroll-tech/bridge-history-api/internal/logic"
+	"scroll-tech/bridge-history-api/internal/types"
+)
+
+// L2UnclaimedWithdrawalsByAddressController the controller of GetL2UnclaimedWithdrawalsByAddress
+type L2UnclaimedWithdrawalsByAddressController struct {
+	historyLogic *logic.HistoryLogic
+}
+
+// NewL2UnclaimedWithdrawalsByAddressController create new L2UnclaimedWithdrawalsByAddressController
+func NewL2UnclaimedWithdrawalsByAddressController(db *gorm.DB, redisClient *redis.Client) *L2UnclaimedWithdrawalsByAddressController {
+	return &L2UnclaimedWithdrawalsByAddressController{
+		historyLogic: logic.NewHistoryLogic(db, redisClient),
+	}
+}
+
+// GetL2UnclaimedWithdrawalsByAddress defines the http get method behavior
+func (c *L2UnclaimedWithdrawalsByAddressController) GetL2UnclaimedWithdrawalsByAddress(ctx *gin.Context) {
+	var req types.QueryByAddressRequest
+	if err := ctx.ShouldBind(&req); err != nil {
+		types.RenderFailure(ctx, types.ErrParameterInvalidNo, err)
+		return
+	}
+
+	pagedTxs, total, err := c.historyLogic.GetL2UnclaimedWithdrawalsByAddress(ctx, req.Address, req.Page, req.PageSize)
+	if err != nil {
+		types.RenderFailure(ctx, types.ErrGetL2ClaimableWithdrawalsError, err)
+		return
+	}
+
+	resultData := &types.ResultData{Results: pagedTxs, Total: total}
+	types.RenderSuccess(ctx, resultData)
+}

bridge-history-api/internal/controller/api/l2withdrawals_by_address.go

@@ -0,0 +1,40 @@
+package api
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/go-redis/redis/v8"
+	"gorm.io/gorm"
+
+	"scroll-tech/bridge-history-api/internal/logic"
+	"scroll-tech/bridge-history-api/internal/types"
+)
+
+// L2WithdrawalsByAddressController the controller of GetL2WithdrawalsByAddress
+type L2WithdrawalsByAddressController struct {
+	historyLogic *logic.HistoryLogic
+}
+
+// NewL2WithdrawalsByAddressController create new L2WithdrawalsByAddressController
+func NewL2WithdrawalsByAddressController(db *gorm.DB, redisClient *redis.Client) *L2WithdrawalsByAddressController {
+	return &L2WithdrawalsByAddressController{
+		historyLogic: logic.NewHistoryLogic(db, redisClient),
+	}
+}
+
+// GetL2WithdrawalsByAddress defines the http get method behavior
+func (c *L2WithdrawalsByAddressController) GetL2WithdrawalsByAddress(ctx *gin.Context) {
+	var req types.QueryByAddressRequest
+	if err := ctx.ShouldBind(&req); err != nil {
+		types.RenderFailure(ctx, types.ErrParameterInvalidNo, err)
+		return
+	}
+
+	pagedTxs, total, err := c.historyLogic.GetL2WithdrawalsByAddress(ctx, req.Address, req.Page, req.PageSize)
+	if err != nil {
+		types.RenderFailure(ctx, types.ErrGetL2WithdrawalsError, err)
+		return
+	}
+
+	resultData := &types.ResultData{Results: pagedTxs, Total: total}
+	types.RenderSuccess(ctx, resultData)
+}

bridge-history-api/internal/controller/api/txs_by_address.go

@@ -0,0 +1,40 @@
+package api
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/go-redis/redis/v8"
+	"gorm.io/gorm"
+
+	"scroll-tech/bridge-history-api/internal/logic"
+	"scroll-tech/bridge-history-api/internal/types"
+)
+
+// TxsByAddressController the controller of GetTxsByAddress
+type TxsByAddressController struct {
+	historyLogic *logic.HistoryLogic
+}
+
+// NewTxsByAddressController create new TxsByAddressController
+func NewTxsByAddressController(db *gorm.DB, redisClient *redis.Client) *TxsByAddressController {
+	return &TxsByAddressController{
+		historyLogic: logic.NewHistoryLogic(db, redisClient),
+	}
+}
+
+// GetTxsByAddress defines the http get method behavior
+func (c *TxsByAddressController) GetTxsByAddress(ctx *gin.Context) {
+	var req types.QueryByAddressRequest
+	if err := ctx.ShouldBind(&req); err != nil {
+		types.RenderFailure(ctx, types.ErrParameterInvalidNo, err)
+		return
+	}
+
+	pagedTxs, total, err := c.historyLogic.GetTxsByAddress(ctx, req.Address, req.Page, req.PageSize)
+	if err != nil {
+		types.RenderFailure(ctx, types.ErrGetTxsError, err)
+		return
+	}
+
+	resultData := &types.ResultData{Results: pagedTxs, Total: total}
+	types.RenderSuccess(ctx, resultData)
+}

bridge-history-api/internal/controller/api/txs_by_hashes.go

@@ -0,0 +1,40 @@
+package api
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/go-redis/redis/v8"
+	"gorm.io/gorm"
+
+	"scroll-tech/bridge-history-api/internal/logic"
+	"scroll-tech/bridge-history-api/internal/types"
+)
+
+// TxsByHashesController the controller of PostQueryTxsByHashes
+type TxsByHashesController struct {
+	historyLogic *logic.HistoryLogic
+}
+
+// NewTxsByHashesController create a new TxsByHashesController
+func NewTxsByHashesController(db *gorm.DB, redisClient *redis.Client) *TxsByHashesController {
+	return &TxsByHashesController{
+		historyLogic: logic.NewHistoryLogic(db, redisClient),
+	}
+}
+
+// PostQueryTxsByHashes query the txs by hashes
+func (c *TxsByHashesController) PostQueryTxsByHashes(ctx *gin.Context) {
+	var req types.QueryByHashRequest
+	if err := ctx.ShouldBindJSON(&req); err != nil {
+		types.RenderFailure(ctx, types.ErrParameterInvalidNo, err)
+		return
+	}
+
+	results, err := c.historyLogic.GetTxsByHashes(ctx, req.Txs)
+	if err != nil {
+		types.RenderFailure(ctx, types.ErrGetTxsByHashError, err)
+		return
+	}
+
+	resultData := &types.ResultData{Results: results, Total: uint64(len(results))}
+	types.RenderSuccess(ctx, resultData)
+}

bridge-history-api/internal/controller/fetcher/l1_fetcher.go

@@ -0,0 +1,189 @@
+package fetcher
+
+import (
+	"context"
+	"fmt"
+	"math/big"
+	"time"
+
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promauto"
+	"github.com/scroll-tech/go-ethereum/common"
+	"github.com/scroll-tech/go-ethereum/ethclient"
+	"github.com/scroll-tech/go-ethereum/log"
+	"github.com/scroll-tech/go-ethereum/rollup/da_syncer/blob_client"
+	"gorm.io/gorm"
+
+	"scroll-tech/bridge-history-api/internal/config"
+	"scroll-tech/bridge-history-api/internal/logic"
+	"scroll-tech/bridge-history-api/internal/utils"
+)
+
+// L1MessageFetcher fetches cross message events from L1 and saves them to database.
+type L1MessageFetcher struct {
+	ctx    context.Context
+	cfg    *config.FetcherConfig
+	client *ethclient.Client
+
+	l1SyncHeight        uint64
+	l1LastSyncBlockHash common.Hash
+
+	eventUpdateLogic *logic.EventUpdateLogic
+	l1FetcherLogic   *logic.L1FetcherLogic
+
+	l1MessageFetcherRunningTotal prometheus.Counter
+	l1MessageFetcherReorgTotal   prometheus.Counter
+	l1MessageFetcherSyncHeight   prometheus.Gauge
+}
+
+// NewL1MessageFetcher creates a new L1MessageFetcher instance.
+func NewL1MessageFetcher(ctx context.Context, cfg *config.FetcherConfig, db *gorm.DB, client *ethclient.Client) (*L1MessageFetcher, error) {
+	blobClient := blob_client.NewBlobClients()
+	if cfg.AwsS3Endpoint != "" {
+		blobClient.AddBlobClient(blob_client.NewAwsS3Client(cfg.AwsS3Endpoint))
+	}
+	if cfg.BeaconNodeAPIEndpoint != "" {
+		beaconNodeClient, err := blob_client.NewBeaconNodeClient(cfg.BeaconNodeAPIEndpoint)
+		if err != nil {
+			log.Warn("failed to create BeaconNodeClient", "err", err)
+		} else {
+			blobClient.AddBlobClient(beaconNodeClient)
+		}
+	}
+	if cfg.BlobScanAPIEndpoint != "" {
+		blobClient.AddBlobClient(blob_client.NewBlobScanClient(cfg.BlobScanAPIEndpoint))
+	}
+	if cfg.BlockNativeAPIEndpoint != "" {
+		blobClient.AddBlobClient(blob_client.NewBlockNativeClient(cfg.BlockNativeAPIEndpoint))
+	}
+	if blobClient.Size() == 0 {
+		return nil, fmt.Errorf("no blob client is configured")
+	}
+
+	c := &L1MessageFetcher{
+		ctx:              ctx,
+		cfg:              cfg,
+		client:           client,
+		eventUpdateLogic: logic.NewEventUpdateLogic(db, true),
+		l1FetcherLogic:   logic.NewL1FetcherLogic(cfg, db, client, blobClient),
+	}
+
+	reg := prometheus.DefaultRegisterer
+	c.l1MessageFetcherRunningTotal = promauto.With(reg).NewCounter(prometheus.CounterOpts{
+		Name: "L1_message_fetcher_running_total",
+		Help: "Current count of running L1 message fetcher instances.",
+	})
+	c.l1MessageFetcherReorgTotal = promauto.With(reg).NewCounter(prometheus.CounterOpts{
+		Name: "L1_message_fetcher_reorg_total",
+		Help: "Total count of blockchain reorgs encountered by the L1 message fetcher.",
+	})
+	c.l1MessageFetcherSyncHeight = promauto.With(reg).NewGauge(prometheus.GaugeOpts{
+		Name: "L1_message_fetcher_sync_height",
+		Help: "Latest blockchain height the L1 message fetcher has synced with.",
+	})
+
+	return c, nil
+}
+
+// Start starts the L1 message fetching process.
+func (c *L1MessageFetcher) Start() {
+	messageSyncedHeight, batchSyncedHeight, bridgeBatchDepositSyncedHeight, dbErr := c.eventUpdateLogic.GetL1SyncHeight(c.ctx)
+	if dbErr != nil {
+		log.Crit("L1MessageFetcher start failed", "err", dbErr)
+	}
+
+	l1SyncHeight := messageSyncedHeight
+	if batchSyncedHeight > l1SyncHeight {
+		l1SyncHeight = batchSyncedHeight
+	}
+
+	if bridgeBatchDepositSyncedHeight > l1SyncHeight {
+		l1SyncHeight = bridgeBatchDepositSyncedHeight
+	}
+
+	if c.cfg.StartHeight > l1SyncHeight {
+		l1SyncHeight = c.cfg.StartHeight - 1
+	}
+
+	// Sync from an older block to prevent reorg during restart.
+	if l1SyncHeight < logic.L1ReorgSafeDepth {
+		l1SyncHeight = 0
+	} else {
+		l1SyncHeight -= logic.L1ReorgSafeDepth
+	}
+
+	header, err := c.client.HeaderByNumber(c.ctx, new(big.Int).SetUint64(l1SyncHeight))
+	if err != nil {
+		log.Crit("failed to get L1 header by number", "block number", l1SyncHeight, "err", err)
+		return
+	}
+
+	c.updateL1SyncHeight(l1SyncHeight, header.Hash())
+
+	log.Info("Start L1 message fetcher",
+		"message synced height", messageSyncedHeight,
+		"batch synced height", batchSyncedHeight,
+		"bridge batch deposit height", bridgeBatchDepositSyncedHeight,
+		"config start height", c.cfg.StartHeight,
+		"sync start height", c.l1SyncHeight+1,
+	)
+
+	tick := time.NewTicker(time.Duration(c.cfg.BlockTime) * time.Second)
+	go func() {
+		for {
+			select {
+			case <-c.ctx.Done():
+				tick.Stop()
+				return
+			case <-tick.C:
+				c.fetchAndSaveEvents(c.cfg.Confirmation)
+			}
+		}
+	}()
+}
+
+func (c *L1MessageFetcher) fetchAndSaveEvents(confirmation uint64) {
+	startHeight := c.l1SyncHeight + 1
+	endHeight, rpcErr := utils.GetBlockNumber(c.ctx, c.client, confirmation)
+	if rpcErr != nil {
+		log.Error("failed to get L1 block number", "confirmation", confirmation, "err", rpcErr)
+		return
+	}
+
+	log.Info("fetch and save missing L1 events", "start height", startHeight, "end height", endHeight, "confirmation", confirmation)
+
+	for from := startHeight; from <= endHeight; from += c.cfg.FetchLimit {
+		to := from + c.cfg.FetchLimit - 1
+		if to > endHeight {
+			to = endHeight
+		}
+
+		isReorg, resyncHeight, lastBlockHash, l1FetcherResult, fetcherErr := c.l1FetcherLogic.L1Fetcher(c.ctx, from, to, c.l1LastSyncBlockHash)
+		if fetcherErr != nil {
+			log.Error("failed to fetch L1 events", "from", from, "to", to, "err", fetcherErr)
+			return
+		}
+
+		if isReorg {
+			c.l1MessageFetcherReorgTotal.Inc()
+			log.Warn("L1 reorg happened, exit and re-enter fetchAndSaveEvents", "re-sync height", resyncHeight)
+			c.updateL1SyncHeight(resyncHeight, lastBlockHash)
+			c.l1MessageFetcherRunningTotal.Inc()
+			return
+		}
+
+		if insertUpdateErr := c.eventUpdateLogic.L1InsertOrUpdate(c.ctx, l1FetcherResult); insertUpdateErr != nil {
+			log.Error("failed to save L1 events", "from", from, "to", to, "err", insertUpdateErr)
+			return
+		}
+
+		c.updateL1SyncHeight(to, lastBlockHash)
+		c.l1MessageFetcherRunningTotal.Inc()
+	}
+}
+
+func (c *L1MessageFetcher) updateL1SyncHeight(height uint64, blockHash common.Hash) {
+	c.l1MessageFetcherSyncHeight.Set(float64(height))
+	c.l1LastSyncBlockHash = blockHash
+	c.l1SyncHeight = height
+}

bridge-history-api/internal/controller/fetcher/l2_fetcher.go

@@ -0,0 +1,163 @@
+package fetcher
+
+import (
+	"context"
+	"math/big"
+	"time"
+
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promauto"
+	"github.com/scroll-tech/go-ethereum/common"
+	"github.com/scroll-tech/go-ethereum/ethclient"
+	"github.com/scroll-tech/go-ethereum/log"
+	"gorm.io/gorm"
+
+	"scroll-tech/bridge-history-api/internal/config"
+	"scroll-tech/bridge-history-api/internal/logic"
+	"scroll-tech/bridge-history-api/internal/utils"
+)
+
+// L2MessageFetcher fetches cross message events from L2 and saves them to database.
+type L2MessageFetcher struct {
+	ctx                 context.Context
+	cfg                 *config.FetcherConfig
+	db                  *gorm.DB
+	client              *ethclient.Client
+	l2SyncHeight        uint64
+	l2LastSyncBlockHash common.Hash
+
+	eventUpdateLogic *logic.EventUpdateLogic
+	l2FetcherLogic   *logic.L2FetcherLogic
+
+	l2MessageFetcherRunningTotal prometheus.Counter
+	l2MessageFetcherReorgTotal   prometheus.Counter
+	l2MessageFetcherSyncHeight   prometheus.Gauge
+}
+
+// NewL2MessageFetcher creates a new L2MessageFetcher instance.
+func NewL2MessageFetcher(ctx context.Context, cfg *config.FetcherConfig, db *gorm.DB, client *ethclient.Client) *L2MessageFetcher {
+	c := &L2MessageFetcher{
+		ctx:              ctx,
+		cfg:              cfg,
+		db:               db,
+		client:           client,
+		eventUpdateLogic: logic.NewEventUpdateLogic(db, false),
+		l2FetcherLogic:   logic.NewL2FetcherLogic(cfg, db, client),
+	}
+
+	reg := prometheus.DefaultRegisterer
+	c.l2MessageFetcherRunningTotal = promauto.With(reg).NewCounter(prometheus.CounterOpts{
+		Name: "L2_message_fetcher_running_total",
+		Help: "Current count of running L2 message fetcher instances.",
+	})
+	c.l2MessageFetcherReorgTotal = promauto.With(reg).NewCounter(prometheus.CounterOpts{
+		Name: "L2_message_fetcher_reorg_total",
+		Help: "Total count of blockchain reorgs encountered by the L2 message fetcher.",
+	})
+	c.l2MessageFetcherSyncHeight = promauto.With(reg).NewGauge(prometheus.GaugeOpts{
+		Name: "L2_message_fetcher_sync_height",
+		Help: "Latest blockchain height the L2 message fetcher has synced with.",
+	})
+
+	return c
+}
+
+// Start starts the L2 message fetching process.
+func (c *L2MessageFetcher) Start() {
+	l2SentMessageSyncedHeight, l2BridgeBatchDepositSyncedHeight, dbErr := c.eventUpdateLogic.GetL2MessageSyncedHeightInDB(c.ctx)
+	if dbErr != nil {
+		log.Crit("failed to get L2 cross message processed height", "err", dbErr)
+		return
+	}
+
+	l2SyncHeight := l2SentMessageSyncedHeight
+	if l2BridgeBatchDepositSyncedHeight > l2SyncHeight {
+		l2SyncHeight = l2BridgeBatchDepositSyncedHeight
+	}
+
+	// Sync from an older block to prevent reorg during restart.
+	if l2SyncHeight < logic.L2ReorgSafeDepth {
+		l2SyncHeight = 0
+	} else {
+		l2SyncHeight -= logic.L2ReorgSafeDepth
+	}
+
+	header, err := c.client.HeaderByNumber(c.ctx, new(big.Int).SetUint64(l2SyncHeight))
+	if err != nil {
+		log.Crit("failed to get L2 header by number", "block number", l2SyncHeight, "err", err)
+		return
+	}
+
+	c.updateL2SyncHeight(l2SyncHeight, header.Hash())
+
+	log.Info("Start L2 message fetcher", "l2 sent message synced height", l2SentMessageSyncedHeight,
+		"bridge batch deposit synced height", l2BridgeBatchDepositSyncedHeight, "sync start height", l2SyncHeight+1)
+
+	tick := time.NewTicker(time.Duration(c.cfg.BlockTime) * time.Second)
+	go func() {
+		for {
+			select {
+			case <-c.ctx.Done():
+				tick.Stop()
+				return
+			case <-tick.C:
+				c.fetchAndSaveEvents(c.cfg.Confirmation)
+			}
+		}
+	}()
+}
+
+func (c *L2MessageFetcher) fetchAndSaveEvents(confirmation uint64) {
+	startHeight := c.l2SyncHeight + 1
+	endHeight, rpcErr := utils.GetBlockNumber(c.ctx, c.client, confirmation)
+	if rpcErr != nil {
+		log.Error("failed to get L2 block number", "confirmation", confirmation, "err", rpcErr)
+		return
+	}
+	log.Info("fetch and save missing L2 events", "start height", startHeight, "end height", endHeight, "confirmation", confirmation)
+
+	for from := startHeight; from <= endHeight; from += c.cfg.FetchLimit {
+		to := from + c.cfg.FetchLimit - 1
+		if to > endHeight {
+			to = endHeight
+		}
+
+		isReorg, resyncHeight, lastBlockHash, l2FetcherResult, fetcherErr := c.l2FetcherLogic.L2Fetcher(c.ctx, from, to, c.l2LastSyncBlockHash)
+		if fetcherErr != nil {
+			log.Error("failed to fetch L2 events", "from", from, "to", to, "err", fetcherErr)
+			return
+		}
+
+		if isReorg {
+			c.l2MessageFetcherReorgTotal.Inc()
+			log.Warn("L2 reorg happened, exit and re-enter fetchAndSaveEvents", "re-sync height", resyncHeight)
+			c.updateL2SyncHeight(resyncHeight, lastBlockHash)
+			c.l2MessageFetcherRunningTotal.Inc()
+			return
+		}
+
+		if insertUpdateErr := c.eventUpdateLogic.L2InsertOrUpdate(c.ctx, l2FetcherResult); insertUpdateErr != nil {
+			log.Error("failed to save L2 events", "from", from, "to", to, "err", insertUpdateErr)
+			return
+		}
+
+		if updateErr := c.eventUpdateLogic.UpdateL2WithdrawMessageProofs(c.ctx, c.l2SyncHeight); updateErr != nil {
+			log.Error("failed to update L1 batch index and status", "from", from, "to", to, "err", updateErr)
+			return
+		}
+
+		if updateErr := c.eventUpdateLogic.UpdateL2BridgeBatchDepositEvent(c.ctx, l2FetcherResult.BridgeBatchDepositMessage); updateErr != nil {
+			log.Error("failed to update L1 batch index and status", "from", from, "to", to, "err", updateErr)
+			return
+		}
+
+		c.updateL2SyncHeight(to, lastBlockHash)
+		c.l2MessageFetcherRunningTotal.Inc()
+	}
+}
+
+func (c *L2MessageFetcher) updateL2SyncHeight(height uint64, blockHash common.Hash) {
+	c.l2MessageFetcherSyncHeight.Set(float64(height))
+	c.l2LastSyncBlockHash = blockHash
+	c.l2SyncHeight = height
+}

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

@@ -0,0 +1,263 @@
+package logic
+
+import (
+	"context"
+	"errors"
+
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promauto"
+	"github.com/scroll-tech/go-ethereum/common"
+	"github.com/scroll-tech/go-ethereum/log"
+	"gorm.io/gorm"
+
+	"scroll-tech/bridge-history-api/internal/orm"
+	btypes "scroll-tech/bridge-history-api/internal/types"
+	"scroll-tech/bridge-history-api/internal/utils"
+)
+
+// EventUpdateLogic the logic of insert/update the database
+type EventUpdateLogic struct {
+	db                         *gorm.DB
+	crossMessageOrm            *orm.CrossMessage
+	batchEventOrm              *orm.BatchEvent
+	bridgeBatchDepositEventOrm *orm.BridgeBatchDepositEvent
+
+	eventUpdateLogicL1FinalizeBatchEventL2BlockUpdateHeight prometheus.Gauge
+	eventUpdateLogicL2MessageNonceUpdateHeight              prometheus.Gauge
+}
+
+// NewEventUpdateLogic creates a EventUpdateLogic instance
+func NewEventUpdateLogic(db *gorm.DB, isL1 bool) *EventUpdateLogic {
+	b := &EventUpdateLogic{
+		db:                         db,
+		crossMessageOrm:            orm.NewCrossMessage(db),
+		batchEventOrm:              orm.NewBatchEvent(db),
+		bridgeBatchDepositEventOrm: orm.NewBridgeBatchDepositEvent(db),
+	}
+
+	if !isL1 {
+		reg := prometheus.DefaultRegisterer
+		b.eventUpdateLogicL1FinalizeBatchEventL2BlockUpdateHeight = promauto.With(reg).NewGauge(prometheus.GaugeOpts{
+			Name: "event_update_logic_L1_finalize_batch_event_L2_block_update_height",
+			Help: "L2 block height of the latest L1 batch event that has been finalized and updated in the message_table.",
+		})
+		b.eventUpdateLogicL2MessageNonceUpdateHeight = promauto.With(reg).NewGauge(prometheus.GaugeOpts{
+			Name: "event_update_logic_L2_message_nonce_update_height",
+			Help: "L2 message nonce height in the latest L1 batch event that has been finalized and updated in the message_table.",
+		})
+	}
+
+	return b
+}
+
+// GetL1SyncHeight gets the l1 sync height from db
+func (b *EventUpdateLogic) GetL1SyncHeight(ctx context.Context) (uint64, uint64, uint64, error) {
+	messageSyncedHeight, err := b.crossMessageOrm.GetMessageSyncedHeightInDB(ctx, btypes.MessageTypeL1SentMessage)
+	if err != nil {
+		log.Error("failed to get L1 cross message synced height", "error", err)
+		return 0, 0, 0, err
+	}
+
+	batchSyncedHeight, err := b.batchEventOrm.GetBatchEventSyncedHeightInDB(ctx)
+	if err != nil {
+		log.Error("failed to get L1 batch event synced height", "error", err)
+		return 0, 0, 0, err
+	}
+
+	bridgeBatchDepositSyncedHeight, err := b.bridgeBatchDepositEventOrm.GetMessageL1SyncedHeightInDB(ctx)
+	if err != nil {
+		log.Error("failed to get l1 bridge batch deposit synced height", "error", err)
+		return 0, 0, 0, err
+	}
+
+	return messageSyncedHeight, batchSyncedHeight, bridgeBatchDepositSyncedHeight, nil
+}
+
+// GetL2MessageSyncedHeightInDB gets L2 messages synced height
+func (b *EventUpdateLogic) GetL2MessageSyncedHeightInDB(ctx context.Context) (uint64, uint64, error) {
+	l2SentMessageSyncedHeight, err := b.crossMessageOrm.GetMessageSyncedHeightInDB(ctx, btypes.MessageTypeL2SentMessage)
+	if err != nil {
+		log.Error("failed to get L2 cross message processed height", "err", err)
+		return 0, 0, err
+	}
+
+	l2BridgeBatchDepositSyncHeight, err := b.bridgeBatchDepositEventOrm.GetMessageL2SyncedHeightInDB(ctx)
+	if err != nil {
+		log.Error("failed to get bridge batch deposit processed height", "err", err)
+		return 0, 0, err
+	}
+	return l2SentMessageSyncedHeight, l2BridgeBatchDepositSyncHeight, nil
+}
+
+// L1InsertOrUpdate inserts or updates l1 messages
+func (b *EventUpdateLogic) L1InsertOrUpdate(ctx context.Context, l1FetcherResult *L1FilterResult) error {
+	if err := b.crossMessageOrm.InsertOrUpdateL1Messages(ctx, l1FetcherResult.DepositMessages); err != nil {
+		log.Error("failed to insert L1 deposit messages", "err", err)
+		return err
+	}
+
+	if err := b.crossMessageOrm.InsertOrUpdateL1RelayedMessagesOfL2Withdrawals(ctx, l1FetcherResult.RelayedMessages); err != nil {
+		log.Error("failed to update L1 relayed messages of L2 withdrawals", "err", err)
+		return err
+	}
+
+	if err := b.batchEventOrm.InsertOrUpdateBatchEvents(ctx, l1FetcherResult.BatchEvents); err != nil {
+		log.Error("failed to insert or update batch events", "err", err)
+		return err
+	}
+
+	if err := b.crossMessageOrm.UpdateL1MessageQueueEventsInfo(ctx, l1FetcherResult.MessageQueueEvents); err != nil {
+		log.Error("failed to insert L1 message queue events", "err", err)
+		return err
+	}
+
+	if err := b.crossMessageOrm.InsertFailedL1GatewayTxs(ctx, l1FetcherResult.RevertedTxs); err != nil {
+		log.Error("failed to insert failed L1 gateway transactions", "err", err)
+		return err
+	}
+
+	if err := b.bridgeBatchDepositEventOrm.InsertOrUpdateL1BridgeBatchDepositEvent(ctx, l1FetcherResult.BridgeBatchDepositEvents); err != nil {
+		log.Error("failed to insert L1 bridge batch deposit transactions", "err", err)
+		return err
+	}
+
+	return nil
+}
+
+func (b *EventUpdateLogic) updateL2WithdrawMessageInfos(ctx context.Context, batchIndex, startBlock, endBlock uint64) error {
+	if startBlock > endBlock {
+		log.Warn("start block is greater than end block", "start", startBlock, "end", endBlock)
+		return nil
+	}
+
+	l2WithdrawMessages, err := b.crossMessageOrm.GetL2WithdrawalsByBlockRange(ctx, startBlock, endBlock)
+	if err != nil {
+		log.Error("failed to get L2 withdrawals by batch index", "batch index", batchIndex, "err", err)
+		return err
+	}
+
+	if len(l2WithdrawMessages) == 0 {
+		return nil
+	}
+
+	withdrawTrie := utils.NewWithdrawTrie()
+	lastMessage, err := b.crossMessageOrm.GetL2LatestFinalizedWithdrawal(ctx)
+	if err != nil {
+		log.Error("failed to get latest L2 finalized sent message event", "err", err)
+		return err
+	}
+
+	if lastMessage != nil {
+		withdrawTrie.Initialize(lastMessage.MessageNonce, common.HexToHash(lastMessage.MessageHash), lastMessage.MerkleProof)
+	}
+
+	if withdrawTrie.NextMessageNonce != l2WithdrawMessages[0].MessageNonce {
+		log.Error("nonce mismatch", "expected next message nonce", withdrawTrie.NextMessageNonce, "actual next message nonce", l2WithdrawMessages[0].MessageNonce)
+		return errors.New("nonce mismatch")
+	}
+
+	messageHashes := make([]common.Hash, len(l2WithdrawMessages))
+	for i, message := range l2WithdrawMessages {
+		messageHashes[i] = common.HexToHash(message.MessageHash)
+	}
+
+	proofs := withdrawTrie.AppendMessages(messageHashes)
+
+	for i, message := range l2WithdrawMessages {
+		message.MerkleProof = proofs[i]
+		message.RollupStatus = int(btypes.RollupStatusTypeFinalized)
+		message.BatchIndex = batchIndex
+	}
+
+	if dbErr := b.crossMessageOrm.UpdateBatchIndexRollupStatusMerkleProofOfL2Messages(ctx, l2WithdrawMessages); dbErr != nil {
+		log.Error("failed to update batch index and rollup status and merkle proof of L2 messages", "err", dbErr)
+		return dbErr
+	}
+
+	b.eventUpdateLogicL2MessageNonceUpdateHeight.Set(float64(withdrawTrie.NextMessageNonce - 1))
+	return nil
+}
+
+// UpdateL2WithdrawMessageProofs updates L2 withdrawal message proofs.
+func (b *EventUpdateLogic) UpdateL2WithdrawMessageProofs(ctx context.Context, height uint64) error {
+	lastUpdatedFinalizedBlockHeight, err := b.batchEventOrm.GetLastUpdatedFinalizedBlockHeight(ctx)
+	if err != nil {
+		log.Error("failed to get last updated finalized block height", "error", err)
+		return err
+	}
+
+	finalizedBatches, err := b.batchEventOrm.GetUnupdatedFinalizedBatchesLEBlockHeight(ctx, height)
+	if err != nil {
+		log.Error("failed to get unupdated finalized batches >= block height", "error", err)
+		return err
+	}
+
+	for _, finalizedBatch := range finalizedBatches {
+		log.Info("update finalized batch or bundle info of L2 withdrawals", "index", finalizedBatch.BatchIndex, "lastUpdatedFinalizedBlockHeight", lastUpdatedFinalizedBlockHeight, "start", finalizedBatch.StartBlockNumber, "end", finalizedBatch.EndBlockNumber)
+		// This method is compatible with both "finalize by batch" and "finalize by bundle" modes:
+		// - In "finalize by batch" mode, each batch emits a FinalizedBatch event.
+		// - In "finalize by bundle" mode, all batches in the bundle emit only one FinalizedBatch event, using the last batch's index and hash.
+		//
+		// The method updates two types of information in L2 withdrawal messages:
+		// 1. Withdraw proof generation:
+		//    - finalize by batch: Generates proofs for each batch.
+		//    - finalize by bundle: Generates proofs for the entire bundle at once.
+		// 2. Batch index updating:
+		//    - finalize by batch: Updates the batch index for withdrawal messages in each processed batch.
+		//    - finalize by bundle: Updates the batch index for all withdrawal messages in the bundle, using the index of the last batch in the bundle.
+		if updateErr := b.updateL2WithdrawMessageInfos(ctx, finalizedBatch.BatchIndex, lastUpdatedFinalizedBlockHeight+1, finalizedBatch.EndBlockNumber); updateErr != nil {
+			log.Error("failed to update L2 withdraw message infos", "index", finalizedBatch.BatchIndex, "lastUpdatedFinalizedBlockHeight", lastUpdatedFinalizedBlockHeight, "start", finalizedBatch.StartBlockNumber, "end", finalizedBatch.EndBlockNumber, "error", updateErr)
+			return updateErr
+		}
+		if dbErr := b.batchEventOrm.UpdateBatchEventStatus(ctx, finalizedBatch.BatchIndex); dbErr != nil {
+			log.Error("failed to update batch event status as updated", "index", finalizedBatch.BatchIndex, "lastUpdatedFinalizedBlockHeight", lastUpdatedFinalizedBlockHeight, "start", finalizedBatch.StartBlockNumber, "end", finalizedBatch.EndBlockNumber, "error", dbErr)
+			return dbErr
+		}
+		lastUpdatedFinalizedBlockHeight = finalizedBatch.EndBlockNumber
+		b.eventUpdateLogicL1FinalizeBatchEventL2BlockUpdateHeight.Set(float64(finalizedBatch.EndBlockNumber))
+	}
+	return nil
+}
+
+// UpdateL2BridgeBatchDepositEvent update l2 bridge batch deposit status
+func (b *EventUpdateLogic) UpdateL2BridgeBatchDepositEvent(ctx context.Context, l2BatchDistributes []*orm.BridgeBatchDepositEvent) error {
+	distributeFailedMap := make(map[uint64][]string)
+	for _, l2BatchDistribute := range l2BatchDistributes {
+		if btypes.TxStatusType(l2BatchDistribute.TxStatus) == btypes.TxStatusBridgeBatchDistributeFailed {
+			distributeFailedMap[l2BatchDistribute.BatchIndex] = append(distributeFailedMap[l2BatchDistribute.BatchIndex], l2BatchDistribute.Sender)
+		}
+
+		if err := b.bridgeBatchDepositEventOrm.UpdateBatchEventStatus(ctx, l2BatchDistribute); err != nil {
+			log.Error("failed to update L1 bridge batch distribute event", "batchIndex", l2BatchDistribute.BatchIndex, "err", err)
+			return err
+		}
+	}
+
+	for batchIndex, distributeFailedSenders := range distributeFailedMap {
+		if err := b.bridgeBatchDepositEventOrm.UpdateDistributeFailedStatus(ctx, batchIndex, distributeFailedSenders); err != nil {
+			log.Error("failed to update L1 bridge batch distribute failed event", "batchIndex", batchIndex, "failed senders", distributeFailedSenders, "err", err)
+			return err
+		}
+	}
+
+	return nil
+}
+
+// L2InsertOrUpdate inserts or updates L2 messages
+func (b *EventUpdateLogic) L2InsertOrUpdate(ctx context.Context, l2FetcherResult *L2FilterResult) error {
+	if err := b.crossMessageOrm.InsertOrUpdateL2Messages(ctx, l2FetcherResult.WithdrawMessages); err != nil {
+		log.Error("failed to insert L2 withdrawal messages", "err", err)
+		return err
+	}
+
+	if err := b.crossMessageOrm.InsertOrUpdateL2RelayedMessagesOfL1Deposits(ctx, l2FetcherResult.RelayedMessages); err != nil {
+		log.Error("failed to update L2 relayed messages of L1 deposits", "err", err)
+		return err
+	}
+
+	if err := b.crossMessageOrm.InsertFailedL2GatewayTxs(ctx, l2FetcherResult.OtherRevertedTxs); err != nil {
+		log.Error("failed to insert failed L2 gateway transactions", "err", err)
+		return err
+	}
+	return nil
+}

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

@@ -0,0 +1,454 @@
+package logic
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"reflect"
+	"strconv"
+	"time"
+
+	"github.com/go-redis/redis/v8"
+	"github.com/scroll-tech/go-ethereum/common"
+	"github.com/scroll-tech/go-ethereum/log"
+	"golang.org/x/sync/singleflight"
+	"gorm.io/gorm"
+
+	"scroll-tech/bridge-history-api/internal/orm"
+	"scroll-tech/bridge-history-api/internal/types"
+	btypes "scroll-tech/bridge-history-api/internal/types"
+	"scroll-tech/bridge-history-api/internal/utils"
+)
+
+const (
+	// cacheKeyPrefixBridgeHistory serves as a specific namespace for all Redis cache keys
+	// associated with the 'bridge-history' user. This prefix is used to enforce access controls
+	// in Redis, allowing permissions to be set such that only users with the appropriate
+	// access rights can read or write to keys starting with "bridge-history".
+	cacheKeyPrefixBridgeHistory = "bridge-history-"
+
+	cacheKeyPrefixL2ClaimableWithdrawalsByAddr = cacheKeyPrefixBridgeHistory + "l2ClaimableWithdrawalsByAddr:"
+	cacheKeyPrefixL2WithdrawalsByAddr          = cacheKeyPrefixBridgeHistory + "l2WithdrawalsByAddr:"
+	cacheKeyPrefixTxsByAddr                    = cacheKeyPrefixBridgeHistory + "txsByAddr:"
+	cacheKeyPrefixQueryTxsByHashes             = cacheKeyPrefixBridgeHistory + "queryTxsByHashes:"
+	cacheKeyExpiredTime                        = 1 * time.Minute
+)
+
+// HistoryLogic services.
+type HistoryLogic struct {
+	crossMessageOrm       *orm.CrossMessage
+	batchEventOrm         *orm.BatchEvent
+	bridgeBatchDepositOrm *orm.BridgeBatchDepositEvent
+
+	redis        *redis.Client
+	singleFlight singleflight.Group
+	cacheMetrics *cacheMetrics
+}
+
+// NewHistoryLogic returns bridge history services.
+func NewHistoryLogic(db *gorm.DB, redis *redis.Client) *HistoryLogic {
+	logic := &HistoryLogic{
+		crossMessageOrm:       orm.NewCrossMessage(db),
+		batchEventOrm:         orm.NewBatchEvent(db),
+		bridgeBatchDepositOrm: orm.NewBridgeBatchDepositEvent(db),
+		redis:                 redis,
+		cacheMetrics:          initCacheMetrics(),
+	}
+	return logic
+}
+
+// GetL2UnclaimedWithdrawalsByAddress gets all unclaimed withdrawal txs under given address.
+func (h *HistoryLogic) GetL2UnclaimedWithdrawalsByAddress(ctx context.Context, address string, page, pageSize uint64) ([]*types.TxHistoryInfo, uint64, error) {
+	cacheKey := cacheKeyPrefixL2ClaimableWithdrawalsByAddr + address
+	pagedTxs, total, isHit, err := h.getCachedTxsInfo(ctx, cacheKey, page, pageSize)
+	if err != nil {
+		log.Error("failed to get cached tx info", "cached key", cacheKey, "page", page, "page size", pageSize, "error", err)
+		return nil, 0, err
+	}
+
+	if isHit {
+		h.cacheMetrics.cacheHits.WithLabelValues("GetL2UnclaimedWithdrawalsByAddress").Inc()
+		log.Info("cache hit", "cache key", cacheKey)
+		return pagedTxs, total, nil
+	}
+
+	h.cacheMetrics.cacheMisses.WithLabelValues("GetL2UnclaimedWithdrawalsByAddress").Inc()
+	log.Info("cache miss", "cache key", cacheKey)
+
+	result, err, _ := h.singleFlight.Do(cacheKey, func() (interface{}, error) {
+		var txHistoryInfos []*types.TxHistoryInfo
+		crossMessages, getErr := h.crossMessageOrm.GetL2UnclaimedWithdrawalsByAddress(ctx, address)
+		if getErr != nil {
+			return nil, getErr
+		}
+		for _, message := range crossMessages {
+			txHistoryInfos = append(txHistoryInfos, getTxHistoryInfoFromCrossMessage(message))
+		}
+		return txHistoryInfos, nil
+	})
+	if err != nil {
+		log.Error("failed to get L2 claimable withdrawals by address", "address", address, "error", err)
+		return nil, 0, err
+	}
+
+	txHistoryInfos, ok := result.([]*types.TxHistoryInfo)
+	if !ok {
+		log.Error("unexpected type", "expected", "[]*types.TxHistoryInfo", "got", reflect.TypeOf(result), "address", address)
+		return nil, 0, errors.New("unexpected error")
+	}
+
+	return h.processAndCacheTxHistoryInfo(ctx, cacheKey, txHistoryInfos, page, pageSize)
+}
+
+// GetL2WithdrawalsByAddress gets all withdrawal txs under given address.
+func (h *HistoryLogic) GetL2WithdrawalsByAddress(ctx context.Context, address string, page, pageSize uint64) ([]*types.TxHistoryInfo, uint64, error) {
+	cacheKey := cacheKeyPrefixL2WithdrawalsByAddr + address
+	pagedTxs, total, isHit, err := h.getCachedTxsInfo(ctx, cacheKey, page, pageSize)
+	if err != nil {
+		log.Error("failed to get cached tx info", "cached key", cacheKey, "page", page, "page size", pageSize, "error", err)
+		return nil, 0, err
+	}
+
+	if isHit {
+		h.cacheMetrics.cacheHits.WithLabelValues("GetL2WithdrawalsByAddress").Inc()
+		log.Info("cache hit", "cache key", cacheKey)
+		return pagedTxs, total, nil
+	}
+
+	h.cacheMetrics.cacheMisses.WithLabelValues("GetL2WithdrawalsByAddress").Inc()
+	log.Info("cache miss", "cache key", cacheKey)
+
+	result, err, _ := h.singleFlight.Do(cacheKey, func() (interface{}, error) {
+		var txHistoryInfos []*types.TxHistoryInfo
+		crossMessages, getErr := h.crossMessageOrm.GetL2WithdrawalsByAddress(ctx, address)
+		if getErr != nil {
+			return nil, getErr
+		}
+		for _, message := range crossMessages {
+			txHistoryInfos = append(txHistoryInfos, getTxHistoryInfoFromCrossMessage(message))
+		}
+		return txHistoryInfos, nil
+	})
+	if err != nil {
+		log.Error("failed to get L2 withdrawals by address", "address", address, "error", err)
+		return nil, 0, err
+	}
+
+	txHistoryInfos, ok := result.([]*types.TxHistoryInfo)
+	if !ok {
+		log.Error("unexpected type", "expected", "[]*types.TxHistoryInfo", "got", reflect.TypeOf(result), "address", address)
+		return nil, 0, errors.New("unexpected error")
+	}
+
+	return h.processAndCacheTxHistoryInfo(ctx, cacheKey, txHistoryInfos, page, pageSize)
+}
+
+// GetTxsByAddress gets tx infos under given address.
+func (h *HistoryLogic) GetTxsByAddress(ctx context.Context, address string, page, pageSize uint64) ([]*types.TxHistoryInfo, uint64, error) {
+	cacheKey := cacheKeyPrefixTxsByAddr + address
+	pagedTxs, total, isHit, err := h.getCachedTxsInfo(ctx, cacheKey, page, pageSize)
+	if err != nil {
+		log.Error("failed to get cached tx info", "cached key", cacheKey, "page", page, "page size", pageSize, "error", err)
+		return nil, 0, err
+	}
+
+	if isHit {
+		h.cacheMetrics.cacheHits.WithLabelValues("GetTxsByAddress").Inc()
+		log.Info("cache hit", "cache key", cacheKey)
+		return pagedTxs, total, nil
+	}
+
+	h.cacheMetrics.cacheMisses.WithLabelValues("GetTxsByAddress").Inc()
+	log.Info("cache miss", "cache key", cacheKey)
+
+	result, err, _ := h.singleFlight.Do(cacheKey, func() (interface{}, error) {
+		var txHistoryInfos []*types.TxHistoryInfo
+		crossMessages, getErr := h.crossMessageOrm.GetTxsByAddress(ctx, address)
+		if getErr != nil {
+			return nil, getErr
+		}
+		for _, message := range crossMessages {
+			txHistoryInfos = append(txHistoryInfos, getTxHistoryInfoFromCrossMessage(message))
+		}
+
+		batchDepositMessages, getErr := h.bridgeBatchDepositOrm.GetTxsByAddress(ctx, address)
+		if getErr != nil {
+			return nil, getErr
+		}
+		for _, message := range batchDepositMessages {
+			txHistoryInfos = append(txHistoryInfos, getTxHistoryInfoFromBridgeBatchDepositMessage(message))
+		}
+		return txHistoryInfos, nil
+	})
+	if err != nil {
+		log.Error("failed to get txs by address", "address", address, "error", err)
+		return nil, 0, err
+	}
+
+	txHistoryInfos, ok := result.([]*types.TxHistoryInfo)
+	if !ok {
+		log.Error("unexpected type", "expected", "[]*types.TxHistoryInfo", "got", reflect.TypeOf(result), "address", address)
+		return nil, 0, errors.New("unexpected error")
+	}
+
+	return h.processAndCacheTxHistoryInfo(ctx, cacheKey, txHistoryInfos, page, pageSize)
+}
+
+// GetTxsByHashes gets tx infos under given tx hashes.
+func (h *HistoryLogic) GetTxsByHashes(ctx context.Context, txHashes []string) ([]*types.TxHistoryInfo, error) {
+	hashesMap := make(map[string]struct{}, len(txHashes))
+	results := make([]*types.TxHistoryInfo, 0, len(txHashes))
+	uncachedHashes := make([]string, 0, len(txHashes))
+
+	for _, hash := range txHashes {
+		if _, exists := hashesMap[hash]; exists {
+			// Skip duplicate tx hash values.
+			continue
+		}
+		hashesMap[hash] = struct{}{}
+
+		cacheKey := cacheKeyPrefixQueryTxsByHashes + hash
+		cachedData, err := h.redis.Get(ctx, cacheKey).Bytes()
+		if err != nil && errors.Is(err, redis.Nil) {
+			h.cacheMetrics.cacheMisses.WithLabelValues("PostQueryTxsByHashes").Inc()
+			log.Info("cache miss", "cache key", cacheKey)
+			uncachedHashes = append(uncachedHashes, hash)
+			continue
+		}
+
+		if err != nil {
+			log.Error("failed to get data from Redis", "error", err)
+			uncachedHashes = append(uncachedHashes, hash)
+			continue
+		}
+
+		h.cacheMetrics.cacheHits.WithLabelValues("PostQueryTxsByHashes").Inc()
+		log.Info("cache hit", "cache key", cacheKey)
+
+		if len(cachedData) == 0 {
+			continue
+		}
+
+		var txInfo types.TxHistoryInfo
+		if unmarshalErr := json.Unmarshal(cachedData, &txInfo); unmarshalErr != nil {
+			log.Error("failed to unmarshal cached data", "error", unmarshalErr)
+			uncachedHashes = append(uncachedHashes, hash)
+			continue
+		}
+		results = append(results, &txInfo)
+	}
+
+	if len(uncachedHashes) > 0 {
+		var txHistories []*types.TxHistoryInfo
+
+		crossMessages, err := h.crossMessageOrm.GetMessagesByTxHashes(ctx, uncachedHashes)
+		if err != nil {
+			log.Error("failed to get cross messages by tx hashes", "hashes", uncachedHashes)
+			return nil, err
+		}
+		for _, message := range crossMessages {
+			txHistories = append(txHistories, getTxHistoryInfoFromCrossMessage(message))
+		}
+
+		batchDepositMessages, err := h.bridgeBatchDepositOrm.GetMessagesByTxHashes(ctx, uncachedHashes)
+		if err != nil {
+			log.Error("failed to get batch deposit messages by tx hashes", "hashes", uncachedHashes)
+			return nil, err
+		}
+		for _, message := range batchDepositMessages {
+			txHistories = append(txHistories, getTxHistoryInfoFromBridgeBatchDepositMessage(message))
+		}
+
+		resultMap := make(map[string]*types.TxHistoryInfo)
+		for _, result := range txHistories {
+			results = append(results, result)
+			resultMap[result.Hash] = result
+		}
+
+		for _, hash := range uncachedHashes {
+			cacheKey := cacheKeyPrefixQueryTxsByHashes + hash
+			result, found := resultMap[hash]
+			if !found {
+				// tx hash not found, which is also a valid result, cache empty string.
+				if cacheErr := h.redis.Set(ctx, cacheKey, "", cacheKeyExpiredTime).Err(); cacheErr != nil {
+					log.Error("failed to set data to Redis", "error", cacheErr)
+				}
+				continue
+			}
+
+			jsonData, unmarshalErr := json.Marshal(result)
+			if unmarshalErr != nil {
+				log.Error("failed to marshal data", "error", unmarshalErr)
+				continue
+			}
+
+			if cacheErr := h.redis.Set(ctx, cacheKey, jsonData, cacheKeyExpiredTime).Err(); cacheErr != nil {
+				log.Error("failed to set data to Redis", "error", cacheErr)
+			}
+		}
+	}
+	return results, nil
+}
+
+func getTxHistoryInfoFromCrossMessage(message *orm.CrossMessage) *types.TxHistoryInfo {
+	txHistory := &types.TxHistoryInfo{
+		MessageHash:    message.MessageHash,
+		TokenType:      btypes.TokenType(message.TokenType),
+		TokenIDs:       utils.ConvertStringToStringArray(message.TokenIDs),
+		TokenAmounts:   utils.ConvertStringToStringArray(message.TokenAmounts),
+		L1TokenAddress: message.L1TokenAddress,
+		L2TokenAddress: message.L2TokenAddress,
+		MessageType:    btypes.MessageType(message.MessageType),
+		TxStatus:       btypes.TxStatusType(message.TxStatus),
+		BlockTimestamp: message.BlockTimestamp,
+	}
+	if txHistory.MessageType == btypes.MessageTypeL1SentMessage {
+		txHistory.Hash = message.L1TxHash
+		txHistory.ReplayTxHash = message.L1ReplayTxHash
+		txHistory.RefundTxHash = message.L1RefundTxHash
+		txHistory.BlockNumber = message.L1BlockNumber
+		txHistory.CounterpartChainTx = &types.CounterpartChainTx{
+			Hash:        message.L2TxHash,
+			BlockNumber: message.L2BlockNumber,
+		}
+	} else {
+		txHistory.Hash = message.L2TxHash
+		txHistory.BlockNumber = message.L2BlockNumber
+		txHistory.CounterpartChainTx = &types.CounterpartChainTx{
+			Hash:        message.L1TxHash,
+			BlockNumber: message.L1BlockNumber,
+		}
+		if btypes.RollupStatusType(message.RollupStatus) == btypes.RollupStatusTypeFinalized {
+			txHistory.ClaimInfo = &types.ClaimInfo{
+				From:    message.MessageFrom,
+				To:      message.MessageTo,
+				Value:   message.MessageValue,
+				Nonce:   strconv.FormatUint(message.MessageNonce, 10),
+				Message: message.MessageData,
+				Proof: types.L2MessageProof{
+					BatchIndex:  strconv.FormatUint(message.BatchIndex, 10),
+					MerkleProof: "0x" + common.Bytes2Hex(message.MerkleProof),
+				},
+				Claimable: true,
+			}
+		}
+	}
+	return txHistory
+}
+
+func getTxHistoryInfoFromBridgeBatchDepositMessage(message *orm.BridgeBatchDepositEvent) *types.TxHistoryInfo {
+	txHistory := &types.TxHistoryInfo{
+		Hash:         message.L1TxHash,
+		TokenType:    btypes.TokenType(message.TokenType),
+		TokenAmounts: utils.ConvertStringToStringArray(message.TokenAmount),
+		BlockNumber:  message.L1BlockNumber,
+		MessageType:  btypes.MessageTypeL1BatchDeposit,
+		TxStatus:     btypes.TxStatusType(message.TxStatus),
+		CounterpartChainTx: &types.CounterpartChainTx{
+			Hash:        message.L2TxHash,
+			BlockNumber: message.L2BlockNumber,
+		},
+		BlockTimestamp:  message.BlockTimestamp,
+		BatchDepositFee: message.Fee,
+	}
+	if txHistory.TokenType != btypes.TokenTypeETH {
+		txHistory.L1TokenAddress = message.L1TokenAddress
+		txHistory.L2TokenAddress = message.L2TokenAddress
+	}
+	return txHistory
+}
+
+func (h *HistoryLogic) getCachedTxsInfo(ctx context.Context, cacheKey string, pageNum, pageSize uint64) ([]*types.TxHistoryInfo, uint64, bool, error) {
+	start := int64((pageNum - 1) * pageSize)
+	end := start + int64(pageSize) - 1
+
+	total, err := h.redis.ZCard(ctx, cacheKey).Result()
+	if err != nil {
+		log.Error("failed to get zcard result", "error", err)
+		return nil, 0, false, err
+	}
+
+	if total == 0 {
+		return nil, 0, false, nil
+	}
+
+	values, err := h.redis.ZRevRange(ctx, cacheKey, start, end).Result()
+	if err != nil {
+		log.Error("failed to get zrange result", "error", err)
+		return nil, 0, false, err
+	}
+
+	if len(values) == 0 {
+		return nil, 0, false, nil
+	}
+
+	// check if it's empty placeholder.
+	if len(values) == 1 && values[0] == "empty_page" {
+		return nil, 0, true, nil
+	}
+
+	var pagedTxs []*types.TxHistoryInfo
+	for _, v := range values {
+		var tx types.TxHistoryInfo
+		if unmarshalErr := json.Unmarshal([]byte(v), &tx); unmarshalErr != nil {
+			log.Error("failed to unmarshal transaction data", "error", unmarshalErr)
+			return nil, 0, false, unmarshalErr
+		}
+		pagedTxs = append(pagedTxs, &tx)
+	}
+	return pagedTxs, uint64(total), true, nil
+}
+
+func (h *HistoryLogic) cacheTxsInfo(ctx context.Context, cacheKey string, txs []*types.TxHistoryInfo) error {
+	_, err := h.redis.TxPipelined(ctx, func(pipe redis.Pipeliner) error {
+		if len(txs) == 0 {
+			if err := pipe.ZAdd(ctx, cacheKey, &redis.Z{Score: 0, Member: "empty_page"}).Err(); err != nil {
+				log.Error("failed to add empty page indicator to sorted set", "error", err)
+				return err
+			}
+		} else {
+			// The transactions are sorted, thus we set the score as their index.
+			for _, tx := range txs {
+				txBytes, err := json.Marshal(tx)
+				if err != nil {
+					log.Error("failed to marshal transaction to json", "error", err)
+					return err
+				}
+				if err := pipe.ZAdd(ctx, cacheKey, &redis.Z{Score: float64(tx.BlockTimestamp), Member: txBytes}).Err(); err != nil {
+					log.Error("failed to add transaction to sorted set", "error", err)
+					return err
+				}
+			}
+		}
+		if err := pipe.Expire(ctx, cacheKey, cacheKeyExpiredTime).Err(); err != nil {
+			log.Error("failed to set expiry time", "error", err)
+			return err
+		}
+		return nil
+	})
+	if err != nil {
+		log.Error("failed to execute transaction", "error", err)
+		return err
+	}
+	return nil
+}
+
+func (h *HistoryLogic) processAndCacheTxHistoryInfo(ctx context.Context, cacheKey string, txHistories []*types.TxHistoryInfo, page, pageSize uint64) ([]*types.TxHistoryInfo, uint64, error) {
+	err := h.cacheTxsInfo(ctx, cacheKey, txHistories)
+	if err != nil {
+		log.Error("failed to cache txs info", "key", cacheKey, "err", err)
+		return nil, 0, err
+	}
+
+	pagedTxs, total, isHit, err := h.getCachedTxsInfo(ctx, cacheKey, page, pageSize)
+	if err != nil {
+		log.Error("failed to get cached tx info", "cached key", cacheKey, "page", page, "page size", pageSize, "error", err)
+		return nil, 0, err
+	}
+
+	if !isHit {
+		log.Error("cache miss after write, expect hit", "cached key", cacheKey, "page", page, "page size", pageSize, "error", err)
+		return nil, 0, err
+	}
+	return pagedTxs, total, nil
+}

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

@@ -0,0 +1,40 @@
+package logic
+
+import (
+	"sync"
+
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promauto"
+)
+
+type cacheMetrics struct {
+	cacheHits   *prometheus.CounterVec
+	cacheMisses *prometheus.CounterVec
+}
+
+var (
+	initMetricsOnce sync.Once
+	cm              *cacheMetrics
+)
+
+func initCacheMetrics() *cacheMetrics {
+	initMetricsOnce.Do(func() {
+		cm = &cacheMetrics{
+			cacheHits: promauto.NewCounterVec(
+				prometheus.CounterOpts{
+					Name: "bridge_history_api_cache_hits_total",
+					Help: "The total number of cache hits",
+				},
+				[]string{"api"},
+			),
+			cacheMisses: promauto.NewCounterVec(
+				prometheus.CounterOpts{
+					Name: "bridge_history_api_cache_misses_total",
+					Help: "The total number of cache misses",
+				},
+				[]string{"api"},
+			),
+		}
+	})
+	return cm
+}

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

@@ -0,0 +1,524 @@
+package logic
+
+import (
+	"context"
+	"fmt"
+	"math/big"
+	"time"
+
+	"github.com/scroll-tech/da-codec/encoding"
+	"github.com/scroll-tech/go-ethereum/common"
+	"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/rollup/da_syncer/blob_client"
+
+	backendabi "scroll-tech/bridge-history-api/abi"
+	"scroll-tech/bridge-history-api/internal/config"
+	"scroll-tech/bridge-history-api/internal/orm"
+	btypes "scroll-tech/bridge-history-api/internal/types"
+	"scroll-tech/bridge-history-api/internal/utils"
+)
+
+// L1EventParser the l1 event parser
+type L1EventParser struct {
+	cfg        *config.FetcherConfig
+	client     *ethclient.Client
+	blobClient blob_client.BlobClient
+}
+
+// NewL1EventParser creates l1 event parser
+func NewL1EventParser(cfg *config.FetcherConfig, client *ethclient.Client, blobClient blob_client.BlobClient) *L1EventParser {
+	return &L1EventParser{
+		cfg:        cfg,
+		client:     client,
+		blobClient: blobClient,
+	}
+}
+
+// ParseL1CrossChainEventLogs parse l1 cross chain event logs
+func (e *L1EventParser) ParseL1CrossChainEventLogs(ctx context.Context, logs []types.Log, blockTimestampsMap map[uint64]uint64) ([]*orm.CrossMessage, []*orm.CrossMessage, []*orm.BridgeBatchDepositEvent, error) {
+	l1CrossChainDepositMessages, l1CrossChainRelayedMessages, err := e.ParseL1SingleCrossChainEventLogs(ctx, logs, blockTimestampsMap)
+	if err != nil {
+		return nil, nil, nil, err
+	}
+
+	l1BridgeBatchDepositMessages, err := e.ParseL1BridgeBatchDepositCrossChainEventLogs(logs, blockTimestampsMap)
+	if err != nil {
+		return nil, nil, nil, err
+	}
+
+	return l1CrossChainDepositMessages, l1CrossChainRelayedMessages, l1BridgeBatchDepositMessages, nil
+}
+
+// ParseL1BridgeBatchDepositCrossChainEventLogs parse L1 watched batch bridge cross chain events.
+func (e *L1EventParser) ParseL1BridgeBatchDepositCrossChainEventLogs(logs []types.Log, blockTimestampsMap map[uint64]uint64) ([]*orm.BridgeBatchDepositEvent, error) {
+	var l1BridgeBatchDepositMessages []*orm.BridgeBatchDepositEvent
+	for _, vlog := range logs {
+		switch vlog.Topics[0] {
+		case backendabi.L1BridgeBatchDepositSig:
+			event := backendabi.L1BatchBridgeGatewayDeposit{}
+			if err := utils.UnpackLog(backendabi.L1BatchBridgeGatewayABI, &event, "Deposit", vlog); err != nil {
+				log.Error("Failed to unpack batch bridge gateway deposit event", "err", err)
+				return nil, err
+			}
+
+			var tokenType btypes.TokenType
+			if event.Token == common.HexToAddress("0") {
+				tokenType = btypes.TokenTypeETH
+			} else {
+				tokenType = btypes.TokenTypeERC20
+			}
+
+			l1BridgeBatchDepositMessages = append(l1BridgeBatchDepositMessages, &orm.BridgeBatchDepositEvent{
+				TokenType:      int(tokenType),
+				Sender:         event.Sender.String(),
+				BatchIndex:     event.BatchIndex.Uint64(),
+				TokenAmount:    event.Amount.String(),
+				Fee:            event.Fee.String(),
+				L1TokenAddress: event.Token.String(),
+				L1BlockNumber:  vlog.BlockNumber,
+				L1TxHash:       vlog.TxHash.String(),
+				TxStatus:       int(btypes.TxStatusBridgeBatchDeposit),
+				BlockTimestamp: blockTimestampsMap[vlog.BlockNumber],
+				L1LogIndex:     vlog.Index,
+			})
+		}
+	}
+	return l1BridgeBatchDepositMessages, nil
+}
+
+// ParseL1SingleCrossChainEventLogs parses L1 watched single cross chain events.
+func (e *L1EventParser) ParseL1SingleCrossChainEventLogs(ctx context.Context, logs []types.Log, blockTimestampsMap map[uint64]uint64) ([]*orm.CrossMessage, []*orm.CrossMessage, error) {
+	var l1DepositMessages []*orm.CrossMessage
+	var l1RelayedMessages []*orm.CrossMessage
+	for _, vlog := range logs {
+		switch vlog.Topics[0] {
+		case backendabi.L1DepositETHSig:
+			event := backendabi.ETHMessageEvent{}
+			if err := utils.UnpackLog(backendabi.IL1ETHGatewayABI, &event, "DepositETH", vlog); err != nil {
+				log.Error("Failed to unpack DepositETH event", "err", err)
+				return nil, nil, err
+			}
+			lastMessage := l1DepositMessages[len(l1DepositMessages)-1]
+			lastMessage.Sender = event.From.String()
+			lastMessage.Receiver = event.To.String()
+			lastMessage.TokenType = int(btypes.TokenTypeETH)
+			lastMessage.TokenAmounts = event.Amount.String()
+		case backendabi.L1DepositERC20Sig:
+			event := backendabi.ERC20MessageEvent{}
+			err := utils.UnpackLog(backendabi.IL1ERC20GatewayABI, &event, "DepositERC20", vlog)
+			if err != nil {
+				log.Error("Failed to unpack DepositERC20 event", "err", err)
+				return nil, nil, err
+			}
+			lastMessage := l1DepositMessages[len(l1DepositMessages)-1]
+			lastMessage.Sender = event.From.String()
+			lastMessage.Receiver = event.To.String()
+			lastMessage.TokenType = int(btypes.TokenTypeERC20)
+			lastMessage.L1TokenAddress = event.L1Token.String()
+			lastMessage.L2TokenAddress = event.L2Token.String()
+			lastMessage.TokenAmounts = event.Amount.String()
+		case backendabi.L1DepositERC721Sig:
+			event := backendabi.ERC721MessageEvent{}
+			if err := utils.UnpackLog(backendabi.IL1ERC721GatewayABI, &event, "DepositERC721", vlog); err != nil {
+				log.Error("Failed to unpack DepositERC721 event", "err", err)
+				return nil, nil, err
+			}
+			lastMessage := l1DepositMessages[len(l1DepositMessages)-1]
+			lastMessage.Sender = event.From.String()
+			lastMessage.Receiver = event.To.String()
+			lastMessage.TokenType = int(btypes.TokenTypeERC721)
+			lastMessage.L1TokenAddress = event.L1Token.String()
+			lastMessage.L2TokenAddress = event.L2Token.String()
+			lastMessage.TokenIDs = event.TokenID.String()
+		case backendabi.L1BatchDepositERC721Sig:
+			event := backendabi.BatchERC721MessageEvent{}
+			if err := utils.UnpackLog(backendabi.IL1ERC721GatewayABI, &event, "BatchDepositERC721", vlog); err != nil {
+				log.Error("Failed to unpack BatchDepositERC721 event", "err", err)
+				return nil, nil, err
+			}
+			lastMessage := l1DepositMessages[len(l1DepositMessages)-1]
+			lastMessage.Sender = event.From.String()
+			lastMessage.Receiver = event.To.String()
+			lastMessage.TokenType = int(btypes.TokenTypeERC721)
+			lastMessage.L1TokenAddress = event.L1Token.String()
+			lastMessage.L2TokenAddress = event.L2Token.String()
+			lastMessage.TokenIDs = utils.ConvertBigIntArrayToString(event.TokenIDs)
+		case backendabi.L1DepositERC1155Sig:
+			event := backendabi.ERC1155MessageEvent{}
+			if err := utils.UnpackLog(backendabi.IL1ERC1155GatewayABI, &event, "DepositERC1155", vlog); err != nil {
+				log.Error("Failed to unpack DepositERC1155 event", "err", err)
+				return nil, nil, err
+			}
+			lastMessage := l1DepositMessages[len(l1DepositMessages)-1]
+			lastMessage.Sender = event.From.String()
+			lastMessage.Receiver = event.To.String()
+			lastMessage.TokenType = int(btypes.TokenTypeERC1155)
+			lastMessage.L1TokenAddress = event.L1Token.String()
+			lastMessage.L2TokenAddress = event.L2Token.String()
+			lastMessage.TokenIDs = event.TokenID.String()
+			lastMessage.TokenAmounts = event.Amount.String()
+		case backendabi.L1BatchDepositERC1155Sig:
+			event := backendabi.BatchERC1155MessageEvent{}
+			if err := utils.UnpackLog(backendabi.IL1ERC1155GatewayABI, &event, "BatchDepositERC1155", vlog); err != nil {
+				log.Error("Failed to unpack BatchDepositERC1155 event", "err", err)
+				return nil, nil, err
+			}
+			lastMessage := l1DepositMessages[len(l1DepositMessages)-1]
+			lastMessage.Sender = event.From.String()
+			lastMessage.Receiver = event.To.String()
+			lastMessage.TokenType = int(btypes.TokenTypeERC1155)
+			lastMessage.L1TokenAddress = event.L1Token.String()
+			lastMessage.L2TokenAddress = event.L2Token.String()
+			lastMessage.TokenIDs = utils.ConvertBigIntArrayToString(event.TokenIDs)
+			lastMessage.TokenAmounts = utils.ConvertBigIntArrayToString(event.TokenAmounts)
+		case backendabi.L1DepositWrappedTokenSig:
+			event := backendabi.WrappedTokenMessageEvent{}
+			if err := utils.UnpackLog(backendabi.L1WrappedTokenGatewayABI, &event, "DepositWrappedToken", vlog); err != nil {
+				log.Error("Failed to unpack DepositWrappedToken event", "err", err)
+				return nil, nil, err
+			}
+			lastMessage := l1DepositMessages[len(l1DepositMessages)-1]
+			lastMessage.Sender = event.From.String()
+		case backendabi.L1SentMessageEventSig:
+			event := backendabi.L1SentMessageEvent{}
+			if err := utils.UnpackLog(backendabi.IL1ScrollMessengerABI, &event, "SentMessage", vlog); err != nil {
+				log.Error("Failed to unpack SentMessage event", "err", err)
+				return nil, nil, err
+			}
+			from, err := getRealFromAddress(ctx, event.Sender, event.Message, e.client, vlog.TxHash, e.cfg.GatewayRouterAddr)
+			if err != nil {
+				log.Error("Failed to get real 'from' address", "err", err)
+				return nil, nil, err
+			}
+			l1DepositMessages = append(l1DepositMessages, &orm.CrossMessage{
+				L1BlockNumber:  vlog.BlockNumber,
+				Sender:         from,
+				Receiver:       event.Target.String(),
+				TokenType:      int(btypes.TokenTypeETH),
+				L1TxHash:       vlog.TxHash.String(),
+				TokenAmounts:   event.Value.String(),
+				MessageNonce:   event.MessageNonce.Uint64(),
+				MessageType:    int(btypes.MessageTypeL1SentMessage),
+				TxStatus:       int(btypes.TxStatusTypeSent),
+				BlockTimestamp: blockTimestampsMap[vlog.BlockNumber],
+				MessageHash:    utils.ComputeMessageHash(event.Sender, event.Target, event.Value, event.MessageNonce, event.Message).String(),
+			})
+		case backendabi.L1RelayedMessageEventSig:
+			event := backendabi.L1RelayedMessageEvent{}
+			if err := utils.UnpackLog(backendabi.IL1ScrollMessengerABI, &event, "RelayedMessage", vlog); err != nil {
+				log.Error("Failed to unpack RelayedMessage event", "err", err)
+				return nil, nil, err
+			}
+			l1RelayedMessages = append(l1RelayedMessages, &orm.CrossMessage{
+				MessageHash:   event.MessageHash.String(),
+				L1BlockNumber: vlog.BlockNumber,
+				L1TxHash:      vlog.TxHash.String(),
+				TxStatus:      int(btypes.TxStatusTypeRelayed),
+				MessageType:   int(btypes.MessageTypeL2SentMessage),
+			})
+		case backendabi.L1FailedRelayedMessageEventSig:
+			event := backendabi.L1FailedRelayedMessageEvent{}
+			if err := utils.UnpackLog(backendabi.IL1ScrollMessengerABI, &event, "FailedRelayedMessage", vlog); err != nil {
+				log.Error("Failed to unpack FailedRelayedMessage event", "err", err)
+				return nil, nil, err
+			}
+			l1RelayedMessages = append(l1RelayedMessages, &orm.CrossMessage{
+				MessageHash:   event.MessageHash.String(),
+				L1BlockNumber: vlog.BlockNumber,
+				L1TxHash:      vlog.TxHash.String(),
+				TxStatus:      int(btypes.TxStatusTypeFailedRelayed),
+				MessageType:   int(btypes.MessageTypeL2SentMessage),
+			})
+		}
+	}
+	return l1DepositMessages, l1RelayedMessages, nil
+}
+
+// ParseL1BatchEventLogs parses L1 watched batch events.
+func (e *L1EventParser) ParseL1BatchEventLogs(ctx context.Context, logs []types.Log, client *ethclient.Client, blockTimestampsMap map[uint64]uint64) ([]*orm.BatchEvent, error) {
+	// Since multiple CommitBatch events per transaction is introduced >= CodecV7,
+	// with one transaction carrying multiple blobs,
+	// each CommitBatch event corresponds to a blob containing block range data.
+	// To correctly process these events, we need to:
+	// 1. Parsing the associated blob data to extract the block range for each event
+	// 2. Tracking the parent batch hash for each processed CommitBatch event, to:
+	//   - Validate the batch hash, since parent batch hash is needed to calculate the batch hash
+	//   - Derive the index of the current batch by the number of parent batch hashes tracked
+	// In commitBatches and commitAndFinalizeBatch, the parent batch hash is passed in calldata,
+	// so that we can use it to get the first batch's parent batch hash, and derive the rest.
+	// The index map serves this purpose with:
+	// Key:   commit transaction hash
+	// Value: parent batch hashes (in order) for each processed CommitBatch event in the transaction
+	txBlobIndexMap := make(map[common.Hash][]common.Hash)
+
+	// Cache for the previous transaction to avoid duplicate fetches
+	var lastTxHash common.Hash
+	var lastTx *types.Transaction
+
+	var l1BatchEvents []*orm.BatchEvent
+	for _, vlog := range logs {
+		switch vlog.Topics[0] {
+		case backendabi.L1CommitBatchEventSig:
+			event := backendabi.L1CommitBatchEvent{}
+			if err := utils.UnpackLog(backendabi.IScrollChainABI, &event, "CommitBatch", vlog); err != nil {
+				log.Error("Failed to unpack CommitBatch event", "err", err)
+				return nil, err
+			}
+
+			// Get transaction, reuse if it's the same as previous
+			var commitTx *types.Transaction
+			if lastTxHash == vlog.TxHash && lastTx != nil {
+				commitTx = lastTx
+			} else {
+				log.Debug("Fetching commit batch transaction", "txHash", vlog.TxHash.String())
+
+				// Create 10-second timeout context for transaction fetch
+				txCtx, txCancel := context.WithTimeout(ctx, 10*time.Second)
+				fetchedTx, isPending, err := client.TransactionByHash(txCtx, vlog.TxHash)
+				txCancel()
+
+				if err != nil || isPending {
+					log.Error("Failed to get commit batch tx or the tx is still pending", "err", err, "isPending", isPending)
+					return nil, err
+				}
+				commitTx = fetchedTx
+				lastTxHash = vlog.TxHash
+				lastTx = commitTx
+			}
+
+			version, startBlock, endBlock, err := utils.GetBatchVersionAndBlockRangeFromCalldata(commitTx.Data())
+			if err != nil {
+				log.Error("Failed to get batch range from calldata", "hash", commitTx.Hash().String(), "height", vlog.BlockNumber)
+				return nil, err
+			}
+			if version >= 7 { // It's a batch with version >= 7.
+				codec, err := encoding.CodecFromVersion(encoding.CodecVersion(version))
+				if err != nil {
+					return nil, fmt.Errorf("unsupported codec version: %v, err: %w", version, err)
+				}
+
+				// we append the batch hash to the slice for the current commit transaction after processing the batch.
+				// that means the current index of the batch within the transaction is len(txBlobIndexMap[vlog.TxHash]).
+				currentIndex := len(txBlobIndexMap[vlog.TxHash])
+				if currentIndex >= len(commitTx.BlobHashes()) {
+					return nil, fmt.Errorf("commit transaction %s has %d blobs, but trying to access index %d (batch index %d)",
+						vlog.TxHash.String(), len(commitTx.BlobHashes()), currentIndex, event.BatchIndex.Uint64())
+				}
+				blobVersionedHash := commitTx.BlobHashes()[currentIndex]
+
+				// validate the batch hash
+				var parentBatchHash common.Hash
+				if currentIndex == 0 {
+					parentBatchHash, err = utils.GetParentBatchHashFromCalldata(commitTx.Data())
+					if err != nil {
+						return nil, fmt.Errorf("failed to get parent batch header from calldata, tx hash: %s, err: %w", vlog.TxHash.String(), err)
+					}
+				} else {
+					// here we need to subtract 1 from the current index to get the parent batch hash.
+					parentBatchHash = txBlobIndexMap[vlog.TxHash][currentIndex-1]
+				}
+				calculatedBatch, err := codec.NewDABatchFromParams(event.BatchIndex.Uint64(), blobVersionedHash, parentBatchHash)
+				if err != nil {
+					return nil, fmt.Errorf("failed to create new DA batch from params, batch index: %d, err: %w", event.BatchIndex.Uint64(), err)
+				}
+				if calculatedBatch.Hash() != event.BatchHash {
+					return nil, fmt.Errorf("batch hash mismatch for batch %d, expected: %s, got: %s", event.BatchIndex, event.BatchHash.String(), calculatedBatch.Hash().String())
+				}
+
+				log.Debug("Processing blob data", "blobVersionedHash", blobVersionedHash.String(), "batchIndex", event.BatchIndex.Uint64(), "currentIndex", currentIndex)
+
+				// Create 20-second timeout context for blob processing
+				blobCtx, blobCancel := context.WithTimeout(ctx, 20*time.Second)
+				blocks, err := e.getBatchBlockRangeFromBlob(blobCtx, codec, blobVersionedHash, blockTimestampsMap[vlog.BlockNumber])
+				blobCancel()
+
+				if err != nil {
+					return nil, fmt.Errorf("failed to process versioned blob, blobVersionedHash: %s, block number: %d, blob index: %d, err: %w",
+						blobVersionedHash.String(), vlog.BlockNumber, currentIndex, err)
+				}
+				if len(blocks) == 0 {
+					return nil, fmt.Errorf("no blocks found in the blob, blobVersionedHash: %s, block number: %d, blob index: %d",
+						blobVersionedHash.String(), vlog.BlockNumber, currentIndex)
+				}
+				startBlock = blocks[0].Number()
+				endBlock = blocks[len(blocks)-1].Number()
+
+				txBlobIndexMap[vlog.TxHash] = append(txBlobIndexMap[vlog.TxHash], event.BatchHash)
+			}
+			l1BatchEvents = append(l1BatchEvents, &orm.BatchEvent{
+				BatchStatus:      int(btypes.BatchStatusTypeCommitted),
+				BatchIndex:       event.BatchIndex.Uint64(),
+				BatchHash:        event.BatchHash.String(),
+				StartBlockNumber: startBlock,
+				EndBlockNumber:   endBlock,
+				L1BlockNumber:    vlog.BlockNumber,
+			})
+		case backendabi.L1RevertBatchV0EventSig:
+			event := backendabi.L1RevertBatchV0Event{}
+			if err := utils.UnpackLog(backendabi.IScrollChainABI, &event, "RevertBatch", vlog); err != nil {
+				log.Error("Failed to unpack RevertBatch event", "err", err)
+				return nil, err
+			}
+			l1BatchEvents = append(l1BatchEvents, &orm.BatchEvent{
+				BatchStatus:   int(btypes.BatchStatusTypeReverted),
+				BatchIndex:    event.BatchIndex.Uint64(),
+				BatchHash:     event.BatchHash.String(),
+				L1BlockNumber: vlog.BlockNumber,
+			})
+		case backendabi.L1RevertBatchV7EventSig:
+			event := backendabi.L1RevertBatchV7Event{}
+			if err := utils.UnpackLog(backendabi.IScrollChainABI, &event, "RevertBatch0", vlog); err != nil {
+				log.Error("Failed to unpack RevertBatch event", "err", err)
+				return nil, err
+			}
+			for i := event.StartBatchIndex.Uint64(); i <= event.FinishBatchIndex.Uint64(); i++ {
+				l1BatchEvents = append(l1BatchEvents, &orm.BatchEvent{
+					BatchStatus:   int(btypes.BatchStatusTypeReverted),
+					BatchIndex:    i,
+					L1BlockNumber: vlog.BlockNumber,
+				})
+			}
+		case backendabi.L1FinalizeBatchEventSig:
+			event := backendabi.L1FinalizeBatchEvent{}
+			if err := utils.UnpackLog(backendabi.IScrollChainABI, &event, "FinalizeBatch", vlog); err != nil {
+				log.Error("Failed to unpack FinalizeBatch event", "err", err)
+				return nil, err
+			}
+			l1BatchEvents = append(l1BatchEvents, &orm.BatchEvent{
+				BatchStatus:   int(btypes.BatchStatusTypeFinalized),
+				BatchIndex:    event.BatchIndex.Uint64(),
+				BatchHash:     event.BatchHash.String(),
+				L1BlockNumber: vlog.BlockNumber,
+			})
+		}
+	}
+	return l1BatchEvents, nil
+}
+
+// ParseL1MessageQueueEventLogs parses L1 watched message queue events.
+func (e *L1EventParser) ParseL1MessageQueueEventLogs(logs []types.Log, l1DepositMessages []*orm.CrossMessage) ([]*orm.MessageQueueEvent, error) {
+	messageHashes := make(map[common.Hash]struct{})
+	for _, msg := range l1DepositMessages {
+		messageHashes[common.HexToHash(msg.MessageHash)] = struct{}{}
+	}
+
+	var l1MessageQueueEvents []*orm.MessageQueueEvent
+	for _, vlog := range logs {
+		switch vlog.Topics[0] {
+		case backendabi.L1QueueTransactionEventSig:
+			event := backendabi.L1QueueTransactionEvent{}
+			if err := utils.UnpackLog(backendabi.IL1MessageQueueABI, &event, "QueueTransaction", vlog); err != nil {
+				log.Error("Failed to unpack QueueTransaction event", "err", err)
+				return nil, err
+			}
+			messageHash := common.BytesToHash(crypto.Keccak256(event.Data))
+			// If the message hash is not found in the map, it's not a replayMessage or enforced tx (omitted); add it to the events.
+			if _, exists := messageHashes[messageHash]; !exists {
+				l1MessageQueueEvents = append(l1MessageQueueEvents, &orm.MessageQueueEvent{
+					EventType:   btypes.MessageQueueEventTypeQueueTransaction,
+					QueueIndex:  event.QueueIndex,
+					MessageHash: messageHash,
+					TxHash:      vlog.TxHash,
+				})
+			}
+		case backendabi.L1DequeueTransactionEventSig:
+			event := backendabi.L1DequeueTransactionEvent{}
+			if err := utils.UnpackLog(backendabi.IL1MessageQueueABI, &event, "DequeueTransaction", vlog); err != nil {
+				log.Error("Failed to unpack DequeueTransaction event", "err", err)
+				return nil, err
+			}
+			skippedIndices := utils.GetSkippedQueueIndices(event.StartIndex.Uint64(), event.SkippedBitmap)
+			for _, index := range skippedIndices {
+				l1MessageQueueEvents = append(l1MessageQueueEvents, &orm.MessageQueueEvent{
+					EventType:  btypes.MessageQueueEventTypeDequeueTransaction,
+					QueueIndex: index,
+				})
+			}
+		case backendabi.L1ResetDequeuedTransactionEventSig:
+			event := backendabi.L1ResetDequeuedTransactionEvent{}
+			if err := utils.UnpackLog(backendabi.IL1MessageQueueABI, &event, "ResetDequeuedTransaction", vlog); err != nil {
+				log.Error("Failed to unpack ResetDequeuedTransaction event", "err", err)
+				return nil, err
+			}
+			l1MessageQueueEvents = append(l1MessageQueueEvents, &orm.MessageQueueEvent{
+				EventType:  btypes.MessageQueueEventTypeResetDequeuedTransaction,
+				QueueIndex: event.StartIndex.Uint64(),
+			})
+		case backendabi.L1DropTransactionEventSig:
+			event := backendabi.L1DropTransactionEvent{}
+			if err := utils.UnpackLog(backendabi.IL1MessageQueueABI, &event, "DropTransaction", vlog); err != nil {
+				log.Error("Failed to unpack DropTransaction event", "err", err)
+				return nil, err
+			}
+			l1MessageQueueEvents = append(l1MessageQueueEvents, &orm.MessageQueueEvent{
+				EventType:  btypes.MessageQueueEventTypeDropTransaction,
+				QueueIndex: event.Index.Uint64(),
+				TxHash:     vlog.TxHash,
+			})
+		}
+	}
+	return l1MessageQueueEvents, nil
+}
+
+func getRealFromAddress(ctx context.Context, eventSender common.Address, eventMessage []byte, client *ethclient.Client, txHash common.Hash, gatewayRouterAddr string) (string, error) {
+	if eventSender != common.HexToAddress(gatewayRouterAddr) {
+		return eventSender.String(), nil
+	}
+
+	// deposit/withdraw ETH: EOA -> contract 1 -> ... -> contract n -> gateway router -> messenger.
+	if len(eventMessage) >= 32 {
+		addressBytes := eventMessage[32-common.AddressLength : 32]
+		var address common.Address
+		address.SetBytes(addressBytes)
+
+		return address.Hex(), nil
+	}
+
+	log.Warn("event message data too short to contain an address", "length", len(eventMessage))
+
+	// Legacy handling logic if length of message < 32, for backward compatibility before the next contract upgrade.
+	tx, isPending, rpcErr := client.TransactionByHash(ctx, txHash)
+	if rpcErr != nil || isPending {
+		log.Error("Failed to get transaction or the transaction is still pending", "rpcErr", rpcErr, "isPending", isPending)
+		return "", rpcErr
+	}
+	// Case 1: deposit/withdraw ETH: EOA -> multisig -> gateway router -> messenger.
+	if tx.To() != nil && (*tx.To()).String() != gatewayRouterAddr {
+		return (*tx.To()).String(), nil
+	}
+	// Case 2: deposit/withdraw ETH: EOA -> gateway router -> messenger.
+	signer := types.LatestSignerForChainID(new(big.Int).SetUint64(tx.ChainId().Uint64()))
+	sender, err := signer.Sender(tx)
+	if err != nil {
+		log.Error("Get sender failed", "chain id", tx.ChainId().Uint64(), "tx hash", tx.Hash().String(), "err", err)
+		return "", err
+	}
+	return sender.String(), nil
+}
+
+func (e *L1EventParser) getBatchBlockRangeFromBlob(ctx context.Context, codec encoding.Codec, blobVersionedHash common.Hash, l1BlockTime uint64) ([]encoding.DABlock, error) {
+	blob, err := e.blobClient.GetBlobByVersionedHashAndBlockTime(ctx, blobVersionedHash, l1BlockTime)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get blob %s: %w", blobVersionedHash.Hex(), err)
+	}
+	if blob == nil {
+		return nil, fmt.Errorf("blob %s not found", blobVersionedHash.Hex())
+	}
+
+	blobPayload, err := codec.DecodeBlob(blob)
+	if err != nil {
+		return nil, fmt.Errorf("blob %s decode error: %w", blobVersionedHash.Hex(), err)
+	}
+
+	blocks := blobPayload.Blocks()
+	if len(blocks) == 0 {
+		return nil, fmt.Errorf("empty blocks in blob %s", blobVersionedHash.Hex())
+	}
+
+	log.Debug("Successfully processed blob", "blobVersionedHash", blobVersionedHash.Hex(), "blocksCount", len(blocks))
+
+	return blocks, nil
+}

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

@@ -0,0 +1,381 @@
+package logic
+
+import (
+	"context"
+	"math/big"
+
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promauto"
+	"github.com/scroll-tech/go-ethereum"
+	"github.com/scroll-tech/go-ethereum/common"
+	"github.com/scroll-tech/go-ethereum/core/types"
+	"github.com/scroll-tech/go-ethereum/ethclient"
+	"github.com/scroll-tech/go-ethereum/log"
+	"github.com/scroll-tech/go-ethereum/rollup/da_syncer/blob_client"
+	"gorm.io/gorm"
+
+	backendabi "scroll-tech/bridge-history-api/abi"
+	"scroll-tech/bridge-history-api/internal/config"
+	"scroll-tech/bridge-history-api/internal/orm"
+	btypes "scroll-tech/bridge-history-api/internal/types"
+	"scroll-tech/bridge-history-api/internal/utils"
+)
+
+// L1ReorgSafeDepth represents the number of block confirmations considered safe against L1 chain reorganizations.
+// Reorganizations at this depth under normal cases are extremely unlikely.
+const L1ReorgSafeDepth = 64
+
+// L1FilterResult L1 fetcher result
+type L1FilterResult struct {
+	DepositMessages          []*orm.CrossMessage
+	RelayedMessages          []*orm.CrossMessage
+	BatchEvents              []*orm.BatchEvent
+	MessageQueueEvents       []*orm.MessageQueueEvent
+	RevertedTxs              []*orm.CrossMessage
+	BridgeBatchDepositEvents []*orm.BridgeBatchDepositEvent
+}
+
+// L1FetcherLogic the L1 fetcher logic
+type L1FetcherLogic struct {
+	cfg             *config.FetcherConfig
+	client          *ethclient.Client
+	addressList     []common.Address
+	gatewayList     []common.Address
+	parser          *L1EventParser
+	db              *gorm.DB
+	crossMessageOrm *orm.CrossMessage
+	batchEventOrm   *orm.BatchEvent
+
+	l1FetcherLogicFetchedTotal *prometheus.CounterVec
+}
+
+// NewL1FetcherLogic creates L1 fetcher logic
+func NewL1FetcherLogic(cfg *config.FetcherConfig, db *gorm.DB, client *ethclient.Client, blobClient blob_client.BlobClient) *L1FetcherLogic {
+	addressList := []common.Address{
+		common.HexToAddress(cfg.StandardERC20GatewayAddr),
+		common.HexToAddress(cfg.CustomERC20GatewayAddr),
+		common.HexToAddress(cfg.DAIGatewayAddr),
+
+		common.HexToAddress(cfg.ERC721GatewayAddr),
+		common.HexToAddress(cfg.ERC1155GatewayAddr),
+
+		common.HexToAddress(cfg.MessengerAddr),
+
+		common.HexToAddress(cfg.ScrollChainAddr),
+
+		common.HexToAddress(cfg.MessageQueueAddr),
+	}
+
+	gatewayList := []common.Address{
+		common.HexToAddress(cfg.StandardERC20GatewayAddr),
+		common.HexToAddress(cfg.CustomERC20GatewayAddr),
+		common.HexToAddress(cfg.DAIGatewayAddr),
+
+		common.HexToAddress(cfg.ERC721GatewayAddr),
+		common.HexToAddress(cfg.ERC1155GatewayAddr),
+
+		common.HexToAddress(cfg.MessengerAddr),
+
+		common.HexToAddress(cfg.GatewayRouterAddr),
+	}
+
+	// Optional gateways.
+	if common.HexToAddress(cfg.USDCGatewayAddr) != (common.Address{}) {
+		addressList = append(addressList, common.HexToAddress(cfg.USDCGatewayAddr))
+		gatewayList = append(gatewayList, common.HexToAddress(cfg.USDCGatewayAddr))
+	}
+
+	if common.HexToAddress(cfg.LIDOGatewayAddr) != (common.Address{}) {
+		addressList = append(addressList, common.HexToAddress(cfg.LIDOGatewayAddr))
+		gatewayList = append(gatewayList, common.HexToAddress(cfg.LIDOGatewayAddr))
+	}
+
+	if common.HexToAddress(cfg.PufferGatewayAddr) != (common.Address{}) {
+		addressList = append(addressList, common.HexToAddress(cfg.PufferGatewayAddr))
+		gatewayList = append(gatewayList, common.HexToAddress(cfg.PufferGatewayAddr))
+	}
+
+	if common.HexToAddress(cfg.BatchBridgeGatewayAddr) != (common.Address{}) {
+		addressList = append(addressList, common.HexToAddress(cfg.BatchBridgeGatewayAddr))
+		gatewayList = append(gatewayList, common.HexToAddress(cfg.BatchBridgeGatewayAddr))
+	}
+
+	if common.HexToAddress(cfg.ETHGatewayAddr) != (common.Address{}) {
+		addressList = append(addressList, common.HexToAddress(cfg.ETHGatewayAddr))
+		gatewayList = append(gatewayList, common.HexToAddress(cfg.ETHGatewayAddr))
+	}
+
+	if common.HexToAddress(cfg.WETHGatewayAddr) != (common.Address{}) {
+		addressList = append(addressList, common.HexToAddress(cfg.WETHGatewayAddr))
+		gatewayList = append(gatewayList, common.HexToAddress(cfg.WETHGatewayAddr))
+	}
+
+	if common.HexToAddress(cfg.GasTokenGatewayAddr) != (common.Address{}) {
+		addressList = append(addressList, common.HexToAddress(cfg.GasTokenGatewayAddr))
+		gatewayList = append(gatewayList, common.HexToAddress(cfg.GasTokenGatewayAddr))
+	}
+
+	if common.HexToAddress(cfg.WrappedTokenGatewayAddr) != (common.Address{}) {
+		addressList = append(addressList, common.HexToAddress(cfg.WrappedTokenGatewayAddr))
+		gatewayList = append(gatewayList, common.HexToAddress(cfg.WrappedTokenGatewayAddr))
+	}
+
+	if common.HexToAddress(cfg.MessageQueueV2Addr) != (common.Address{}) {
+		addressList = append(addressList, common.HexToAddress(cfg.MessageQueueV2Addr))
+	}
+
+	log.Info("L1 Fetcher configured with the following address list", "addresses", addressList, "gateways", gatewayList)
+
+	f := &L1FetcherLogic{
+		db:              db,
+		crossMessageOrm: orm.NewCrossMessage(db),
+		batchEventOrm:   orm.NewBatchEvent(db),
+		cfg:             cfg,
+		client:          client,
+		addressList:     addressList,
+		gatewayList:     gatewayList,
+		parser:          NewL1EventParser(cfg, client, blobClient),
+	}
+
+	reg := prometheus.DefaultRegisterer
+	f.l1FetcherLogicFetchedTotal = promauto.With(reg).NewCounterVec(prometheus.CounterOpts{
+		Name: "L1_fetcher_logic_fetched_total",
+		Help: "The total number of events or failed txs fetched in L1 fetcher logic.",
+	}, []string{"type"})
+
+	return f
+}
+
+func (f *L1FetcherLogic) getBlocksAndDetectReorg(ctx context.Context, from, to uint64, lastBlockHash common.Hash) (bool, uint64, common.Hash, []*types.Block, error) {
+	blocks, err := utils.GetBlocksInRange(ctx, f.client, from, to)
+	if err != nil {
+		log.Error("failed to get L1 blocks in range", "from", from, "to", to, "err", err)
+		return false, 0, common.Hash{}, nil, err
+	}
+
+	for _, block := range blocks {
+		if block.ParentHash() != lastBlockHash {
+			log.Warn("L1 reorg detected", "reorg height", block.NumberU64()-1, "expected hash", block.ParentHash().String(), "local hash", lastBlockHash.String())
+			var resyncHeight uint64
+			if block.NumberU64() > L1ReorgSafeDepth+1 {
+				resyncHeight = block.NumberU64() - L1ReorgSafeDepth - 1
+			}
+			header, err := f.client.HeaderByNumber(ctx, new(big.Int).SetUint64(resyncHeight))
+			if err != nil {
+				log.Error("failed to get L1 header by number", "block number", resyncHeight, "err", err)
+				return false, 0, common.Hash{}, nil, err
+			}
+			return true, resyncHeight, header.Hash(), nil, nil
+		}
+		lastBlockHash = block.Hash()
+	}
+
+	return false, 0, lastBlockHash, blocks, nil
+}
+
+func (f *L1FetcherLogic) getRevertedTxs(ctx context.Context, from, to uint64, blocks []*types.Block) ([]*orm.CrossMessage, error) {
+	var l1RevertedTxs []*orm.CrossMessage
+	for i := from; i <= to; i++ {
+		block := blocks[i-from]
+		for _, tx := range block.Transactions() {
+			// Gateways: L1 deposit.
+			// Messenger: L1 deposit retry (replayMessage), L1 deposit refund (dropMessage), L2 withdrawal's claim (relayMessageWithProof).
+			if !isTransactionToGateway(tx, f.gatewayList) {
+				continue
+			}
+
+			var receipt *types.Receipt
+			receipt, receiptErr := f.client.TransactionReceipt(ctx, tx.Hash())
+			if receiptErr != nil {
+				log.Error("Failed to get transaction receipt", "txHash", tx.Hash().String(), "err", receiptErr)
+				return nil, receiptErr
+			}
+
+			// Check if the transaction is failed
+			if receipt.Status != types.ReceiptStatusFailed {
+				continue
+			}
+
+			signer := types.LatestSignerForChainID(new(big.Int).SetUint64(tx.ChainId().Uint64()))
+			sender, senderErr := signer.Sender(tx)
+			if senderErr != nil {
+				log.Error("get sender failed", "chain id", tx.ChainId().Uint64(), "tx hash", tx.Hash().String(), "err", senderErr)
+				return nil, senderErr
+			}
+
+			l1RevertedTxs = append(l1RevertedTxs, &orm.CrossMessage{
+				L1TxHash:       tx.Hash().String(),
+				MessageType:    int(btypes.MessageTypeL1SentMessage),
+				Sender:         sender.String(),
+				Receiver:       (*tx.To()).String(),
+				L1BlockNumber:  receipt.BlockNumber.Uint64(),
+				BlockTimestamp: block.Time(),
+				TxStatus:       int(btypes.TxStatusTypeSentTxReverted),
+			})
+		}
+	}
+	return l1RevertedTxs, nil
+}
+
+func (f *L1FetcherLogic) l1FetcherLogs(ctx context.Context, from, to uint64) ([]types.Log, error) {
+	query := ethereum.FilterQuery{
+		FromBlock: new(big.Int).SetUint64(from), // inclusive
+		ToBlock:   new(big.Int).SetUint64(to),   // inclusive
+		Addresses: f.addressList,
+		Topics:    make([][]common.Hash, 1),
+	}
+
+	query.Topics[0] = make([]common.Hash, 17)
+	query.Topics[0][0] = backendabi.L1DepositETHSig
+	query.Topics[0][1] = backendabi.L1DepositERC20Sig
+	query.Topics[0][2] = backendabi.L1DepositERC721Sig
+	query.Topics[0][3] = backendabi.L1DepositERC1155Sig
+	query.Topics[0][4] = backendabi.L1SentMessageEventSig
+	query.Topics[0][5] = backendabi.L1RelayedMessageEventSig
+	query.Topics[0][6] = backendabi.L1FailedRelayedMessageEventSig
+	query.Topics[0][7] = backendabi.L1CommitBatchEventSig
+	query.Topics[0][8] = backendabi.L1RevertBatchV0EventSig
+	query.Topics[0][9] = backendabi.L1RevertBatchV7EventSig
+	query.Topics[0][10] = backendabi.L1FinalizeBatchEventSig
+	query.Topics[0][11] = backendabi.L1QueueTransactionEventSig
+	query.Topics[0][12] = backendabi.L1DequeueTransactionEventSig
+	query.Topics[0][13] = backendabi.L1DropTransactionEventSig
+	query.Topics[0][14] = backendabi.L1ResetDequeuedTransactionEventSig
+	query.Topics[0][15] = backendabi.L1BridgeBatchDepositSig
+	query.Topics[0][16] = backendabi.L1DepositWrappedTokenSig
+
+	eventLogs, err := f.client.FilterLogs(ctx, query)
+	if err != nil {
+		log.Error("failed to filter L1 event logs", "from", from, "to", to, "err", err)
+		return nil, err
+	}
+	return eventLogs, nil
+}
+
+// L1Fetcher L1 fetcher
+func (f *L1FetcherLogic) L1Fetcher(ctx context.Context, from, to uint64, lastBlockHash common.Hash) (bool, uint64, common.Hash, *L1FilterResult, error) {
+	log.Info("fetch and save L1 events", "from", from, "to", to)
+
+	isReorg, reorgHeight, blockHash, blocks, getErr := f.getBlocksAndDetectReorg(ctx, from, to, lastBlockHash)
+	if getErr != nil {
+		log.Error("L1Fetcher getBlocksAndDetectReorg failed", "from", from, "to", to, "error", getErr)
+		return false, 0, common.Hash{}, nil, getErr
+	}
+
+	if isReorg {
+		return isReorg, reorgHeight, blockHash, nil, nil
+	}
+
+	l1RevertedTxs, err := f.getRevertedTxs(ctx, from, to, blocks)
+	if err != nil {
+		log.Error("L1Fetcher getRevertedTxs failed", "from", from, "to", to, "error", err)
+		return false, 0, common.Hash{}, nil, err
+	}
+
+	// Map block number to block timestamp to avoid fetching block header multiple times to get block timestamp.
+	blockTimestampsMap := make(map[uint64]uint64)
+	for _, block := range blocks {
+		blockTimestampsMap[block.NumberU64()] = block.Time()
+	}
+
+	eventLogs, err := f.l1FetcherLogs(ctx, from, to)
+	if err != nil {
+		log.Error("L1Fetcher l1FetcherLogs failed", "from", from, "to", to, "error", err)
+		return false, 0, common.Hash{}, nil, err
+	}
+
+	l1DepositMessages, l1RelayedMessages, l1BridgeBatchDepositMessages, err := f.parser.ParseL1CrossChainEventLogs(ctx, eventLogs, blockTimestampsMap)
+	if err != nil {
+		log.Error("failed to parse L1 cross chain event logs", "from", from, "to", to, "err", err)
+		return false, 0, common.Hash{}, nil, err
+	}
+
+	l1BatchEvents, err := f.parser.ParseL1BatchEventLogs(ctx, eventLogs, f.client, blockTimestampsMap)
+	if err != nil {
+		log.Error("failed to parse L1 batch event logs", "from", from, "to", to, "err", err)
+		return false, 0, common.Hash{}, nil, err
+	}
+
+	l1MessageQueueEvents, err := f.parser.ParseL1MessageQueueEventLogs(eventLogs, l1DepositMessages)
+	if err != nil {
+		log.Error("failed to parse L1 message queue event logs", "from", from, "to", to, "err", err)
+		return false, 0, common.Hash{}, nil, err
+	}
+
+	res := L1FilterResult{
+		DepositMessages:          l1DepositMessages,
+		RelayedMessages:          l1RelayedMessages,
+		BatchEvents:              l1BatchEvents,
+		MessageQueueEvents:       l1MessageQueueEvents,
+		RevertedTxs:              l1RevertedTxs,
+		BridgeBatchDepositEvents: l1BridgeBatchDepositMessages,
+	}
+
+	f.updateMetrics(res)
+
+	return false, 0, blockHash, &res, nil
+}
+
+func (f *L1FetcherLogic) updateMetrics(res L1FilterResult) {
+	f.l1FetcherLogicFetchedTotal.WithLabelValues("L1_failed_gateway_router_transaction").Add(float64(len(res.RevertedTxs)))
+
+	for _, depositMessage := range res.DepositMessages {
+		switch btypes.TokenType(depositMessage.TokenType) {
+		case btypes.TokenTypeETH:
+			f.l1FetcherLogicFetchedTotal.WithLabelValues("L1_deposit_eth").Add(1)
+		case btypes.TokenTypeERC20:
+			f.l1FetcherLogicFetchedTotal.WithLabelValues("L1_deposit_erc20").Add(1)
+		case btypes.TokenTypeERC721:
+			f.l1FetcherLogicFetchedTotal.WithLabelValues("L1_deposit_erc721").Add(1)
+		case btypes.TokenTypeERC1155:
+			f.l1FetcherLogicFetchedTotal.WithLabelValues("L1_deposit_erc1155").Add(1)
+		}
+	}
+
+	for _, relayedMessage := range res.RelayedMessages {
+		switch btypes.TxStatusType(relayedMessage.TxStatus) {
+		case btypes.TxStatusTypeRelayed:
+			f.l1FetcherLogicFetchedTotal.WithLabelValues("L1_relayed_message").Add(1)
+		case btypes.TxStatusTypeFailedRelayed:
+			f.l1FetcherLogicFetchedTotal.WithLabelValues("L1_failed_relayed_message").Add(1)
+		}
+		// Have not tracked L1 relayed message reverted transaction yet.
+		// 1. need to parse calldata of tx.
+		// 2. hard to track internal tx.
+	}
+
+	for _, batchEvent := range res.BatchEvents {
+		switch btypes.BatchStatusType(batchEvent.BatchStatus) {
+		case btypes.BatchStatusTypeCommitted:
+			f.l1FetcherLogicFetchedTotal.WithLabelValues("L1_commit_batch_event").Add(1)
+		case btypes.BatchStatusTypeReverted:
+			f.l1FetcherLogicFetchedTotal.WithLabelValues("L1_revert_batch_event").Add(1)
+		case btypes.BatchStatusTypeFinalized:
+			f.l1FetcherLogicFetchedTotal.WithLabelValues("L1_finalize_batch_event").Add(1)
+		}
+	}
+
+	for _, messageQueueEvent := range res.MessageQueueEvents {
+		switch messageQueueEvent.EventType {
+		case btypes.MessageQueueEventTypeQueueTransaction: // sendMessage is filtered out, only leaving replayMessage or appendEnforcedTransaction.
+			f.l1FetcherLogicFetchedTotal.WithLabelValues("L1_replay_message_or_enforced_transaction").Add(1)
+		case btypes.MessageQueueEventTypeDequeueTransaction:
+			f.l1FetcherLogicFetchedTotal.WithLabelValues("L1_skip_message").Add(1)
+		case btypes.MessageQueueEventTypeDropTransaction:
+			f.l1FetcherLogicFetchedTotal.WithLabelValues("L1_drop_message").Add(1)
+		// one ResetDequeuedTransaction event could indicate reset multiple skipped messages,
+		// this metric only counts the number of events, not the number of skipped messages.
+		case btypes.MessageQueueEventTypeResetDequeuedTransaction:
+			f.l1FetcherLogicFetchedTotal.WithLabelValues("L1_reset_skipped_messages").Add(1)
+		}
+	}
+
+	for _, bridgeBatchDepositEvent := range res.BridgeBatchDepositEvents {
+		switch btypes.TokenType(bridgeBatchDepositEvent.TokenType) {
+		case btypes.TokenTypeETH:
+			f.l1FetcherLogicFetchedTotal.WithLabelValues("L1_bridge_batch_deposit_eth").Add(1)
+		case btypes.TokenTypeERC20:
+			f.l1FetcherLogicFetchedTotal.WithLabelValues("L1_bridge_batch_deposit_erc20").Add(1)
+		}
+	}
+}

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

@@ -0,0 +1,247 @@
+package logic
+
+import (
+	"context"
+
+	"github.com/scroll-tech/go-ethereum/common"
+	"github.com/scroll-tech/go-ethereum/common/hexutil"
+	"github.com/scroll-tech/go-ethereum/core/types"
+	"github.com/scroll-tech/go-ethereum/ethclient"
+	"github.com/scroll-tech/go-ethereum/log"
+
+	backendabi "scroll-tech/bridge-history-api/abi"
+	"scroll-tech/bridge-history-api/internal/config"
+	"scroll-tech/bridge-history-api/internal/orm"
+	btypes "scroll-tech/bridge-history-api/internal/types"
+	"scroll-tech/bridge-history-api/internal/utils"
+)
+
+// L2EventParser the L2 event parser
+type L2EventParser struct {
+	cfg    *config.FetcherConfig
+	client *ethclient.Client
+}
+
+// NewL2EventParser creates the L2 event parser
+func NewL2EventParser(cfg *config.FetcherConfig, client *ethclient.Client) *L2EventParser {
+	return &L2EventParser{
+		cfg:    cfg,
+		client: client,
+	}
+}
+
+// ParseL2EventLogs parses L2 watchedevents
+func (e *L2EventParser) ParseL2EventLogs(ctx context.Context, logs []types.Log, blockTimestampsMap map[uint64]uint64) ([]*orm.CrossMessage, []*orm.CrossMessage, []*orm.BridgeBatchDepositEvent, error) {
+	l2WithdrawMessages, l2RelayedMessages, err := e.ParseL2SingleCrossChainEventLogs(ctx, logs, blockTimestampsMap)
+	if err != nil {
+		return nil, nil, nil, err
+	}
+
+	l2BridgeBatchDepositMessages, err := e.ParseL2BridgeBatchDepositCrossChainEventLogs(logs, blockTimestampsMap)
+	if err != nil {
+		return nil, nil, nil, err
+	}
+	return l2WithdrawMessages, l2RelayedMessages, l2BridgeBatchDepositMessages, nil
+}
+
+// ParseL2BridgeBatchDepositCrossChainEventLogs parses L2 watched bridge batch deposit events
+func (e *L2EventParser) ParseL2BridgeBatchDepositCrossChainEventLogs(logs []types.Log, blockTimestampsMap map[uint64]uint64) ([]*orm.BridgeBatchDepositEvent, error) {
+	var l2BridgeBatchDepositEvents []*orm.BridgeBatchDepositEvent
+	for _, vlog := range logs {
+		switch vlog.Topics[0] {
+		case backendabi.L2BridgeBatchDistributeSig:
+			event := backendabi.L2BatchBridgeGatewayBatchDistribute{}
+			err := utils.UnpackLog(backendabi.L2BatchBridgeGatewayABI, &event, "BatchDistribute", vlog)
+			if err != nil {
+				log.Error("Failed to unpack BatchDistribute event", "err", err)
+				return nil, err
+			}
+
+			var tokenType btypes.TokenType
+			if event.L1Token == common.HexToAddress("0") {
+				tokenType = btypes.TokenTypeETH
+			} else {
+				tokenType = btypes.TokenTypeERC20
+			}
+
+			l2BridgeBatchDepositEvents = append(l2BridgeBatchDepositEvents, &orm.BridgeBatchDepositEvent{
+				TokenType:      int(tokenType),
+				BatchIndex:     event.BatchIndex.Uint64(),
+				L2TokenAddress: event.L2Token.String(),
+				L2BlockNumber:  vlog.BlockNumber,
+				L2TxHash:       vlog.TxHash.String(),
+				TxStatus:       int(btypes.TxStatusBridgeBatchDistribute),
+				BlockTimestamp: blockTimestampsMap[vlog.BlockNumber],
+			})
+		case backendabi.L2BridgeBatchDistributeFailedSig:
+			event := backendabi.L2BatchBridgeGatewayDistributeFailed{}
+			err := utils.UnpackLog(backendabi.L2BatchBridgeGatewayABI, &event, "DistributeFailed", vlog)
+			if err != nil {
+				log.Error("Failed to unpack DistributeFailed event", "err", err)
+				return nil, err
+			}
+			l2BridgeBatchDepositEvents = append(l2BridgeBatchDepositEvents, &orm.BridgeBatchDepositEvent{
+				BatchIndex:     event.BatchIndex.Uint64(),
+				L2TokenAddress: event.L2Token.String(),
+				L2BlockNumber:  vlog.BlockNumber,
+				L2TxHash:       vlog.TxHash.String(),
+				TxStatus:       int(btypes.TxStatusBridgeBatchDistributeFailed),
+				BlockTimestamp: blockTimestampsMap[vlog.BlockNumber],
+				Sender:         event.Receiver.String(),
+			})
+		}
+	}
+	return l2BridgeBatchDepositEvents, nil
+}
+
+// ParseL2SingleCrossChainEventLogs parses L2 watched events
+func (e *L2EventParser) ParseL2SingleCrossChainEventLogs(ctx context.Context, logs []types.Log, blockTimestampsMap map[uint64]uint64) ([]*orm.CrossMessage, []*orm.CrossMessage, error) {
+	var l2WithdrawMessages []*orm.CrossMessage
+	var l2RelayedMessages []*orm.CrossMessage
+	for _, vlog := range logs {
+		switch vlog.Topics[0] {
+		case backendabi.L2WithdrawETHSig:
+			event := backendabi.ETHMessageEvent{}
+			err := utils.UnpackLog(backendabi.IL2ETHGatewayABI, &event, "WithdrawETH", vlog)
+			if err != nil {
+				log.Error("Failed to unpack WithdrawETH event", "err", err)
+				return nil, nil, err
+			}
+			lastMessage := l2WithdrawMessages[len(l2WithdrawMessages)-1]
+			lastMessage.Sender = event.From.String()
+			lastMessage.Receiver = event.To.String()
+			lastMessage.TokenType = int(btypes.TokenTypeETH)
+			lastMessage.TokenAmounts = event.Amount.String()
+		case backendabi.L2WithdrawERC20Sig:
+			event := backendabi.ERC20MessageEvent{}
+			err := utils.UnpackLog(backendabi.IL2ERC20GatewayABI, &event, "WithdrawERC20", vlog)
+			if err != nil {
+				log.Error("Failed to unpack WithdrawERC20 event", "err", err)
+				return nil, nil, err
+			}
+			lastMessage := l2WithdrawMessages[len(l2WithdrawMessages)-1]
+			lastMessage.Sender = event.From.String()
+			lastMessage.Receiver = event.To.String()
+			lastMessage.TokenType = int(btypes.TokenTypeERC20)
+			lastMessage.L1TokenAddress = event.L1Token.String()
+			lastMessage.L2TokenAddress = event.L2Token.String()
+			lastMessage.TokenAmounts = event.Amount.String()
+		case backendabi.L2WithdrawERC721Sig:
+			event := backendabi.ERC721MessageEvent{}
+			err := utils.UnpackLog(backendabi.IL2ERC721GatewayABI, &event, "WithdrawERC721", vlog)
+			if err != nil {
+				log.Error("Failed to unpack WithdrawERC721 event", "err", err)
+				return nil, nil, err
+			}
+			lastMessage := l2WithdrawMessages[len(l2WithdrawMessages)-1]
+			lastMessage.Sender = event.From.String()
+			lastMessage.Receiver = event.To.String()
+			lastMessage.TokenType = int(btypes.TokenTypeERC721)
+			lastMessage.L1TokenAddress = event.L1Token.String()
+			lastMessage.L2TokenAddress = event.L2Token.String()
+			lastMessage.TokenIDs = event.TokenID.String()
+		case backendabi.L2BatchWithdrawERC721Sig:
+			event := backendabi.BatchERC721MessageEvent{}
+			err := utils.UnpackLog(backendabi.IL2ERC721GatewayABI, &event, "BatchWithdrawERC721", vlog)
+			if err != nil {
+				log.Error("Failed to unpack BatchWithdrawERC721 event", "err", err)
+				return nil, nil, err
+			}
+			lastMessage := l2WithdrawMessages[len(l2WithdrawMessages)-1]
+			lastMessage.Sender = event.From.String()
+			lastMessage.Receiver = event.To.String()
+			lastMessage.TokenType = int(btypes.TokenTypeERC721)
+			lastMessage.L1TokenAddress = event.L1Token.String()
+			lastMessage.L2TokenAddress = event.L2Token.String()
+			lastMessage.TokenIDs = utils.ConvertBigIntArrayToString(event.TokenIDs)
+		case backendabi.L2WithdrawERC1155Sig:
+			event := backendabi.ERC1155MessageEvent{}
+			err := utils.UnpackLog(backendabi.IL2ERC1155GatewayABI, &event, "WithdrawERC1155", vlog)
+			if err != nil {
+				log.Error("Failed to unpack WithdrawERC1155 event", "err", err)
+				return nil, nil, err
+			}
+			lastMessage := l2WithdrawMessages[len(l2WithdrawMessages)-1]
+			lastMessage.Sender = event.From.String()
+			lastMessage.Receiver = event.To.String()
+			lastMessage.TokenType = int(btypes.TokenTypeERC1155)
+			lastMessage.L1TokenAddress = event.L1Token.String()
+			lastMessage.L2TokenAddress = event.L2Token.String()
+			lastMessage.TokenIDs = event.TokenID.String()
+			lastMessage.TokenAmounts = event.Amount.String()
+		case backendabi.L2BatchWithdrawERC1155Sig:
+			event := backendabi.BatchERC1155MessageEvent{}
+			err := utils.UnpackLog(backendabi.IL2ERC1155GatewayABI, &event, "BatchWithdrawERC1155", vlog)
+			if err != nil {
+				log.Error("Failed to unpack BatchWithdrawERC1155 event", "err", err)
+				return nil, nil, err
+			}
+			lastMessage := l2WithdrawMessages[len(l2WithdrawMessages)-1]
+			lastMessage.Sender = event.From.String()
+			lastMessage.Receiver = event.To.String()
+			lastMessage.TokenType = int(btypes.TokenTypeERC1155)
+			lastMessage.L1TokenAddress = event.L1Token.String()
+			lastMessage.L2TokenAddress = event.L2Token.String()
+			lastMessage.TokenIDs = utils.ConvertBigIntArrayToString(event.TokenIDs)
+			lastMessage.TokenAmounts = utils.ConvertBigIntArrayToString(event.TokenAmounts)
+		case backendabi.L2SentMessageEventSig:
+			event := backendabi.L2SentMessageEvent{}
+			err := utils.UnpackLog(backendabi.IL2ScrollMessengerABI, &event, "SentMessage", vlog)
+			if err != nil {
+				log.Error("Failed to unpack SentMessage event", "err", err)
+				return nil, nil, err
+			}
+			from, err := getRealFromAddress(ctx, event.Sender, event.Message, e.client, vlog.TxHash, e.cfg.GatewayRouterAddr)
+			if err != nil {
+				log.Error("Failed to get real 'from' address", "err", err)
+				return nil, nil, err
+			}
+			l2WithdrawMessages = append(l2WithdrawMessages, &orm.CrossMessage{
+				MessageHash:    utils.ComputeMessageHash(event.Sender, event.Target, event.Value, event.MessageNonce, event.Message).String(),
+				Sender:         from,
+				Receiver:       event.Target.String(),
+				TokenType:      int(btypes.TokenTypeETH),
+				L2TxHash:       vlog.TxHash.String(),
+				TokenAmounts:   event.Value.String(),
+				MessageFrom:    event.Sender.String(),
+				MessageTo:      event.Target.String(),
+				MessageValue:   event.Value.String(),
+				MessageNonce:   event.MessageNonce.Uint64(),
+				MessageData:    hexutil.Encode(event.Message),
+				MessageType:    int(btypes.MessageTypeL2SentMessage),
+				TxStatus:       int(btypes.TxStatusTypeSent),
+				BlockTimestamp: blockTimestampsMap[vlog.BlockNumber],
+				L2BlockNumber:  vlog.BlockNumber,
+			})
+		case backendabi.L2RelayedMessageEventSig:
+			event := backendabi.L2RelayedMessageEvent{}
+			err := utils.UnpackLog(backendabi.IL2ScrollMessengerABI, &event, "RelayedMessage", vlog)
+			if err != nil {
+				log.Error("Failed to unpack RelayedMessage event", "err", err)
+				return nil, nil, err
+			}
+			l2RelayedMessages = append(l2RelayedMessages, &orm.CrossMessage{
+				MessageHash:   event.MessageHash.String(),
+				L2BlockNumber: vlog.BlockNumber,
+				L2TxHash:      vlog.TxHash.String(),
+				TxStatus:      int(btypes.TxStatusTypeRelayed),
+				MessageType:   int(btypes.MessageTypeL1SentMessage),
+			})
+		case backendabi.L2FailedRelayedMessageEventSig:
+			event := backendabi.L2RelayedMessageEvent{}
+			err := utils.UnpackLog(backendabi.IL2ScrollMessengerABI, &event, "FailedRelayedMessage", vlog)
+			if err != nil {
+				log.Error("Failed to unpack FailedRelayedMessage event", "err", err)
+				return nil, nil, err
+			}
+			l2RelayedMessages = append(l2RelayedMessages, &orm.CrossMessage{
+				MessageHash:   event.MessageHash.String(),
+				L2BlockNumber: vlog.BlockNumber,
+				L2TxHash:      vlog.TxHash.String(),
+				TxStatus:      int(btypes.TxStatusTypeFailedRelayed),
+				MessageType:   int(btypes.MessageTypeL1SentMessage),
+			})
+		}
+	}
+	return l2WithdrawMessages, l2RelayedMessages, nil
+}

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

@@ -0,0 +1,337 @@
+package logic
+
+import (
+	"context"
+	"math/big"
+
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promauto"
+	"github.com/scroll-tech/go-ethereum"
+	"github.com/scroll-tech/go-ethereum/common"
+	"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"
+	"gorm.io/gorm"
+
+	backendabi "scroll-tech/bridge-history-api/abi"
+	"scroll-tech/bridge-history-api/internal/config"
+	"scroll-tech/bridge-history-api/internal/orm"
+	btypes "scroll-tech/bridge-history-api/internal/types"
+	"scroll-tech/bridge-history-api/internal/utils"
+)
+
+// L2ReorgSafeDepth represents the number of block confirmations considered safe against L2 chain reorganizations.
+// Reorganizations at this depth under normal cases are extremely unlikely.
+const L2ReorgSafeDepth = 256
+
+// L2FilterResult the L2 filter result
+type L2FilterResult struct {
+	WithdrawMessages          []*orm.CrossMessage
+	RelayedMessages           []*orm.CrossMessage // relayed, failed relayed, relay tx reverted.
+	OtherRevertedTxs          []*orm.CrossMessage // reverted txs except relay tx reverted.
+	BridgeBatchDepositMessage []*orm.BridgeBatchDepositEvent
+}
+
+// L2FetcherLogic the L2 fetcher logic
+type L2FetcherLogic struct {
+	cfg             *config.FetcherConfig
+	client          *ethclient.Client
+	addressList     []common.Address
+	gatewayList     []common.Address
+	parser          *L2EventParser
+	db              *gorm.DB
+	crossMessageOrm *orm.CrossMessage
+	batchEventOrm   *orm.BatchEvent
+
+	l2FetcherLogicFetchedTotal *prometheus.CounterVec
+}
+
+// NewL2FetcherLogic create L2 fetcher logic
+func NewL2FetcherLogic(cfg *config.FetcherConfig, db *gorm.DB, client *ethclient.Client) *L2FetcherLogic {
+	addressList := []common.Address{
+		common.HexToAddress(cfg.ETHGatewayAddr),
+
+		common.HexToAddress(cfg.StandardERC20GatewayAddr),
+		common.HexToAddress(cfg.CustomERC20GatewayAddr),
+		common.HexToAddress(cfg.DAIGatewayAddr),
+
+		common.HexToAddress(cfg.ERC721GatewayAddr),
+		common.HexToAddress(cfg.ERC1155GatewayAddr),
+
+		common.HexToAddress(cfg.MessengerAddr),
+	}
+
+	gatewayList := []common.Address{
+		common.HexToAddress(cfg.ETHGatewayAddr),
+
+		common.HexToAddress(cfg.StandardERC20GatewayAddr),
+		common.HexToAddress(cfg.CustomERC20GatewayAddr),
+		common.HexToAddress(cfg.DAIGatewayAddr),
+
+		common.HexToAddress(cfg.ERC721GatewayAddr),
+		common.HexToAddress(cfg.ERC1155GatewayAddr),
+
+		common.HexToAddress(cfg.MessengerAddr),
+
+		common.HexToAddress(cfg.GatewayRouterAddr),
+	}
+
+	// Optional gateways.
+	if common.HexToAddress(cfg.USDCGatewayAddr) != (common.Address{}) {
+		addressList = append(addressList, common.HexToAddress(cfg.USDCGatewayAddr))
+		gatewayList = append(gatewayList, common.HexToAddress(cfg.USDCGatewayAddr))
+	}
+
+	if common.HexToAddress(cfg.LIDOGatewayAddr) != (common.Address{}) {
+		addressList = append(addressList, common.HexToAddress(cfg.LIDOGatewayAddr))
+		gatewayList = append(gatewayList, common.HexToAddress(cfg.LIDOGatewayAddr))
+	}
+
+	if common.HexToAddress(cfg.PufferGatewayAddr) != (common.Address{}) {
+		addressList = append(addressList, common.HexToAddress(cfg.PufferGatewayAddr))
+		gatewayList = append(gatewayList, common.HexToAddress(cfg.PufferGatewayAddr))
+	}
+
+	if common.HexToAddress(cfg.BatchBridgeGatewayAddr) != (common.Address{}) {
+		addressList = append(addressList, common.HexToAddress(cfg.BatchBridgeGatewayAddr))
+		gatewayList = append(gatewayList, common.HexToAddress(cfg.BatchBridgeGatewayAddr))
+	}
+
+	if common.HexToAddress(cfg.WETHGatewayAddr) != (common.Address{}) {
+		addressList = append(addressList, common.HexToAddress(cfg.WETHGatewayAddr))
+		gatewayList = append(gatewayList, common.HexToAddress(cfg.WETHGatewayAddr))
+	}
+
+	log.Info("L2 Fetcher configured with the following address list", "addresses", addressList, "gateways", gatewayList)
+
+	f := &L2FetcherLogic{
+		db:              db,
+		crossMessageOrm: orm.NewCrossMessage(db),
+		batchEventOrm:   orm.NewBatchEvent(db),
+		cfg:             cfg,
+		client:          client,
+		addressList:     addressList,
+		gatewayList:     gatewayList,
+		parser:          NewL2EventParser(cfg, client),
+	}
+
+	reg := prometheus.DefaultRegisterer
+	f.l2FetcherLogicFetchedTotal = promauto.With(reg).NewCounterVec(prometheus.CounterOpts{
+		Name: "L2_fetcher_logic_fetched_total",
+		Help: "The total number of events or failed txs fetched in L2 fetcher logic.",
+	}, []string{"type"})
+
+	return f
+}
+
+func (f *L2FetcherLogic) getBlocksAndDetectReorg(ctx context.Context, from, to uint64, lastBlockHash common.Hash) (bool, uint64, common.Hash, []*types.Block, error) {
+	blocks, err := utils.GetBlocksInRange(ctx, f.client, from, to)
+	if err != nil {
+		log.Error("failed to get L2 blocks in range", "from", from, "to", to, "err", err)
+		return false, 0, common.Hash{}, nil, err
+	}
+
+	for _, block := range blocks {
+		if block.ParentHash() != lastBlockHash {
+			log.Warn("L2 reorg detected", "reorg height", block.NumberU64()-1, "expected hash", block.ParentHash().String(), "local hash", lastBlockHash.String())
+			var resyncHeight uint64
+			if block.NumberU64() > L2ReorgSafeDepth+1 {
+				resyncHeight = block.NumberU64() - L2ReorgSafeDepth - 1
+			}
+			header, err := f.client.HeaderByNumber(ctx, new(big.Int).SetUint64(resyncHeight))
+			if err != nil {
+				log.Error("failed to get L2 header by number", "block number", resyncHeight, "err", err)
+				return false, 0, common.Hash{}, nil, err
+			}
+			return true, resyncHeight, header.Hash(), nil, nil
+		}
+		lastBlockHash = block.Hash()
+	}
+
+	return false, 0, lastBlockHash, blocks, nil
+}
+
+func (f *L2FetcherLogic) getRevertedTxs(ctx context.Context, from, to uint64, blocks []*types.Block) (map[uint64]uint64, []*orm.CrossMessage, []*orm.CrossMessage, error) {
+	var l2RevertedUserTxs []*orm.CrossMessage
+	var l2RevertedRelayedMessageTxs []*orm.CrossMessage
+	blockTimestampsMap := make(map[uint64]uint64)
+
+	for i := from; i <= to; i++ {
+		block := blocks[i-from]
+		blockTimestampsMap[block.NumberU64()] = block.Time()
+
+		for _, tx := range block.Transactions() {
+			if tx.IsL1MessageTx() {
+				receipt, receiptErr := f.client.TransactionReceipt(ctx, tx.Hash())
+				if receiptErr != nil {
+					log.Error("Failed to get transaction receipt", "txHash", tx.Hash().String(), "err", receiptErr)
+					return nil, nil, nil, receiptErr
+				}
+
+				// Check if the transaction is failed
+				if receipt.Status == types.ReceiptStatusFailed {
+					l2RevertedRelayedMessageTxs = append(l2RevertedRelayedMessageTxs, &orm.CrossMessage{
+						MessageHash:   common.BytesToHash(crypto.Keccak256(tx.AsL1MessageTx().Data)).String(),
+						L2TxHash:      tx.Hash().String(),
+						TxStatus:      int(btypes.TxStatusTypeRelayTxReverted),
+						L2BlockNumber: receipt.BlockNumber.Uint64(),
+						MessageType:   int(btypes.MessageTypeL1SentMessage),
+					})
+				}
+				continue
+			}
+
+			// Gateways: L2 withdrawal.
+			if !isTransactionToGateway(tx, f.gatewayList) {
+				continue
+			}
+
+			receipt, receiptErr := f.client.TransactionReceipt(ctx, tx.Hash())
+			if receiptErr != nil {
+				log.Error("Failed to get transaction receipt", "txHash", tx.Hash().String(), "err", receiptErr)
+				return nil, nil, nil, receiptErr
+			}
+
+			// Check if the transaction is failed
+			if receipt.Status == types.ReceiptStatusFailed {
+				signer := types.LatestSignerForChainID(new(big.Int).SetUint64(tx.ChainId().Uint64()))
+				sender, signerErr := signer.Sender(tx)
+				if signerErr != nil {
+					log.Error("get sender failed", "chain id", tx.ChainId().Uint64(), "tx hash", tx.Hash().String(), "err", signerErr)
+					return nil, nil, nil, signerErr
+				}
+
+				l2RevertedUserTxs = append(l2RevertedUserTxs, &orm.CrossMessage{
+					L2TxHash:       tx.Hash().String(),
+					MessageType:    int(btypes.MessageTypeL2SentMessage),
+					Sender:         sender.String(),
+					Receiver:       (*tx.To()).String(),
+					L2BlockNumber:  receipt.BlockNumber.Uint64(),
+					BlockTimestamp: block.Time(),
+					TxStatus:       int(btypes.TxStatusTypeSentTxReverted),
+				})
+			}
+		}
+	}
+	return blockTimestampsMap, l2RevertedUserTxs, l2RevertedRelayedMessageTxs, nil
+}
+
+func (f *L2FetcherLogic) l2FetcherLogs(ctx context.Context, from, to uint64) ([]types.Log, error) {
+	query := ethereum.FilterQuery{
+		FromBlock: new(big.Int).SetUint64(from), // inclusive
+		ToBlock:   new(big.Int).SetUint64(to),   // inclusive
+		Addresses: f.addressList,
+		Topics:    make([][]common.Hash, 1),
+	}
+	query.Topics[0] = make([]common.Hash, 9)
+	query.Topics[0][0] = backendabi.L2WithdrawETHSig
+	query.Topics[0][1] = backendabi.L2WithdrawERC20Sig
+	query.Topics[0][2] = backendabi.L2WithdrawERC721Sig
+	query.Topics[0][3] = backendabi.L2WithdrawERC1155Sig
+	query.Topics[0][4] = backendabi.L2SentMessageEventSig
+	query.Topics[0][5] = backendabi.L2RelayedMessageEventSig
+	query.Topics[0][6] = backendabi.L2FailedRelayedMessageEventSig
+	query.Topics[0][7] = backendabi.L2BridgeBatchDistributeSig
+	query.Topics[0][8] = backendabi.L2BridgeBatchDistributeFailedSig
+
+	eventLogs, err := f.client.FilterLogs(ctx, query)
+	if err != nil {
+		log.Error("Failed to filter L2 event logs", "from", from, "to", to, "err", err)
+		return nil, err
+	}
+	return eventLogs, nil
+}
+
+// L2Fetcher L2 fetcher
+func (f *L2FetcherLogic) L2Fetcher(ctx context.Context, from, to uint64, lastBlockHash common.Hash) (bool, uint64, common.Hash, *L2FilterResult, error) {
+	log.Info("fetch and save L2 events", "from", from, "to", to)
+
+	isReorg, reorgHeight, blockHash, blocks, getErr := f.getBlocksAndDetectReorg(ctx, from, to, lastBlockHash)
+	if getErr != nil {
+		log.Error("L2Fetcher getBlocksAndDetectReorg failed", "from", from, "to", to, "error", getErr)
+		return false, 0, common.Hash{}, nil, getErr
+	}
+
+	if isReorg {
+		return isReorg, reorgHeight, blockHash, nil, nil
+	}
+
+	blockTimestampsMap, revertedUserTxs, revertedRelayMsgs, routerErr := f.getRevertedTxs(ctx, from, to, blocks)
+	if routerErr != nil {
+		log.Error("L2Fetcher getRevertedTxs failed", "from", from, "to", to, "error", routerErr)
+		return false, 0, common.Hash{}, nil, routerErr
+	}
+
+	eventLogs, err := f.l2FetcherLogs(ctx, from, to)
+	if err != nil {
+		log.Error("L2Fetcher l2FetcherLogs failed", "from", from, "to", to, "error", err)
+		return false, 0, common.Hash{}, nil, err
+	}
+
+	l2WithdrawMessages, l2RelayedMessages, l2BridgeBatchDepositMessages, err := f.parser.ParseL2EventLogs(ctx, eventLogs, blockTimestampsMap)
+	if err != nil {
+		log.Error("failed to parse L2 event logs", "from", from, "to", to, "err", err)
+		return false, 0, common.Hash{}, nil, err
+	}
+
+	res := L2FilterResult{
+		WithdrawMessages:          l2WithdrawMessages,
+		RelayedMessages:           append(l2RelayedMessages, revertedRelayMsgs...),
+		OtherRevertedTxs:          revertedUserTxs,
+		BridgeBatchDepositMessage: l2BridgeBatchDepositMessages,
+	}
+
+	f.updateMetrics(res)
+
+	return false, 0, blockHash, &res, nil
+}
+
+func (f *L2FetcherLogic) updateMetrics(res L2FilterResult) {
+	f.l2FetcherLogicFetchedTotal.WithLabelValues("L2_failed_gateway_router_transaction").Add(float64(len(res.OtherRevertedTxs)))
+
+	for _, withdrawMessage := range res.WithdrawMessages {
+		switch btypes.TokenType(withdrawMessage.TokenType) {
+		case btypes.TokenTypeETH:
+			f.l2FetcherLogicFetchedTotal.WithLabelValues("L2_withdraw_eth").Add(1)
+		case btypes.TokenTypeERC20:
+			f.l2FetcherLogicFetchedTotal.WithLabelValues("L2_withdraw_erc20").Add(1)
+		case btypes.TokenTypeERC721:
+			f.l2FetcherLogicFetchedTotal.WithLabelValues("L2_withdraw_erc721").Add(1)
+		case btypes.TokenTypeERC1155:
+			f.l2FetcherLogicFetchedTotal.WithLabelValues("L2_withdraw_erc1155").Add(1)
+		}
+	}
+
+	for _, relayedMessage := range res.RelayedMessages {
+		switch btypes.TxStatusType(relayedMessage.TxStatus) {
+		case btypes.TxStatusTypeRelayed:
+			f.l2FetcherLogicFetchedTotal.WithLabelValues("L2_relayed_message").Add(1)
+		case btypes.TxStatusTypeFailedRelayed:
+			f.l2FetcherLogicFetchedTotal.WithLabelValues("L2_failed_relayed_message").Add(1)
+		case btypes.TxStatusTypeRelayTxReverted:
+			f.l2FetcherLogicFetchedTotal.WithLabelValues("L2_reverted_relayed_message_transaction").Add(1)
+		}
+	}
+
+	for _, bridgeBatchDepositMessage := range res.BridgeBatchDepositMessage {
+		switch btypes.TxStatusType(bridgeBatchDepositMessage.TxStatus) {
+		case btypes.TxStatusBridgeBatchDistribute:
+			f.l2FetcherLogicFetchedTotal.WithLabelValues("L2_bridge_batch_distribute_message").Add(1)
+		case btypes.TxStatusBridgeBatchDistributeFailed:
+			f.l2FetcherLogicFetchedTotal.WithLabelValues("L2_bridge_batch_distribute_failed_message").Add(1)
+		}
+	}
+}
+
+func isTransactionToGateway(tx *types.Transaction, gatewayList []common.Address) bool {
+	if tx.To() == nil {
+		return false
+	}
+	for _, gateway := range gatewayList {
+		if *tx.To() == gateway {
+			return true
+		}
+	}
+	return false
+}

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

@@ -0,0 +1,146 @@
+package orm
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"time"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+
+	btypes "scroll-tech/bridge-history-api/internal/types"
+)
+
+// BatchEvent represents a batch event.
+type BatchEvent struct {
+	db *gorm.DB `gorm:"column:-"`
+
+	ID               uint64     `json:"id" gorm:"column:id;primary_key"`
+	L1BlockNumber    uint64     `json:"l1_block_number" gorm:"column:l1_block_number"`
+	BatchStatus      int        `json:"batch_status" gorm:"column:batch_status"`
+	BatchIndex       uint64     `json:"batch_index" gorm:"column:batch_index"`
+	BatchHash        string     `json:"batch_hash" gorm:"column:batch_hash"`
+	StartBlockNumber uint64     `json:"start_block_number" gorm:"column:start_block_number"`
+	EndBlockNumber   uint64     `json:"end_block_number" gorm:"column:end_block_number"`
+	UpdateStatus     int        `json:"update_status" gorm:"column:update_status"`
+	CreatedAt        time.Time  `json:"created_at" gorm:"column:created_at"`
+	UpdatedAt        time.Time  `json:"updated_at" gorm:"column:updated_at"`
+	DeletedAt        *time.Time `json:"deleted_at" gorm:"column:deleted_at"`
+}
+
+// TableName returns the table name for the BatchEvent model.
+func (*BatchEvent) TableName() string {
+	return "batch_event_v2"
+}
+
+// NewBatchEvent returns a new instance of BatchEvent.
+func NewBatchEvent(db *gorm.DB) *BatchEvent {
+	return &BatchEvent{db: db}
+}
+
+// GetBatchEventSyncedHeightInDB returns the maximum l1_block_number from the batch_event_v2 table.
+func (c *BatchEvent) GetBatchEventSyncedHeightInDB(ctx context.Context) (uint64, error) {
+	var batch BatchEvent
+	db := c.db.WithContext(ctx)
+	db = db.Model(&BatchEvent{})
+	db = db.Order("l1_block_number desc")
+	if err := db.First(&batch).Error; err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return 0, nil
+		}
+		return 0, fmt.Errorf("failed to get batch synced height in db, error: %w", err)
+	}
+	return batch.L1BlockNumber, nil
+}
+
+// GetLastUpdatedFinalizedBlockHeight returns the last updated finalized block height in db.
+func (c *BatchEvent) GetLastUpdatedFinalizedBlockHeight(ctx context.Context) (uint64, error) {
+	var batch BatchEvent
+	db := c.db.WithContext(ctx)
+	db = db.Model(&BatchEvent{})
+	db = db.Where("batch_status = ?", btypes.BatchStatusTypeFinalized)
+	db = db.Where("update_status = ?", btypes.UpdateStatusTypeUpdated)
+	db = db.Order("batch_index desc")
+	if err := db.First(&batch).Error; err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			// No finalized batch found, return genesis batch's end block number.
+			return 0, nil
+		}
+		return 0, fmt.Errorf("failed to get last updated finalized block height, error: %w", err)
+	}
+	return batch.EndBlockNumber, nil
+}
+
+// GetUnupdatedFinalizedBatchesLEBlockHeight returns the finalized batches with end block <= given block height in db.
+func (c *BatchEvent) GetUnupdatedFinalizedBatchesLEBlockHeight(ctx context.Context, blockHeight uint64) ([]*BatchEvent, error) {
+	var batches []*BatchEvent
+	db := c.db.WithContext(ctx)
+	db = db.Model(&BatchEvent{})
+	db = db.Where("end_block_number <= ?", blockHeight)
+	db = db.Where("batch_status = ?", btypes.BatchStatusTypeFinalized)
+	db = db.Where("update_status = ?", btypes.UpdateStatusTypeUnupdated)
+	db = db.Order("batch_index asc")
+	if err := db.Find(&batches).Error; err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+		return nil, fmt.Errorf("failed to get unupdated finalized batches >= block height, error: %w", err)
+	}
+	return batches, nil
+}
+
+// InsertOrUpdateBatchEvents inserts a new batch event or updates an existing one based on the BatchStatusType.
+func (c *BatchEvent) InsertOrUpdateBatchEvents(ctx context.Context, l1BatchEvents []*BatchEvent) error {
+	for _, l1BatchEvent := range l1BatchEvents {
+		db := c.db
+		db = db.WithContext(ctx)
+		db = db.Model(&BatchEvent{})
+		updateFields := make(map[string]interface{})
+		switch btypes.BatchStatusType(l1BatchEvent.BatchStatus) {
+		case btypes.BatchStatusTypeCommitted:
+			// Use the clause to either insert or ignore on conflict
+			db = db.Clauses(clause.OnConflict{
+				Columns:   []clause.Column{{Name: "batch_hash"}},
+				DoNothing: true,
+			})
+			if err := db.Create(l1BatchEvent).Error; err != nil {
+				return fmt.Errorf("failed to insert or ignore batch event, error: %w", err)
+			}
+		case btypes.BatchStatusTypeFinalized:
+			db = db.Where("batch_index = ?", l1BatchEvent.BatchIndex)
+			db = db.Where("batch_hash = ?", l1BatchEvent.BatchHash)
+			updateFields["batch_status"] = btypes.BatchStatusTypeFinalized
+			updateFields["l1_block_number"] = l1BatchEvent.L1BlockNumber
+			if err := db.Updates(updateFields).Error; err != nil {
+				return fmt.Errorf("failed to update batch event, error: %w", err)
+			}
+		case btypes.BatchStatusTypeReverted:
+			db = db.Where("batch_index = ?", l1BatchEvent.BatchIndex)
+			db = db.Where("batch_status != ?", btypes.BatchStatusTypeFinalized)
+			updateFields["batch_status"] = btypes.BatchStatusTypeReverted
+			if err := db.Updates(updateFields).Error; err != nil {
+				return fmt.Errorf("failed to update batch event, error: %w", err)
+			}
+			// Soft delete the batch event.
+			if err := db.Delete(l1BatchEvent).Error; err != nil {
+				return fmt.Errorf("failed to soft delete batch event, error: %w", err)
+			}
+		}
+	}
+	return nil
+}
+
+// UpdateBatchEventStatus updates the UpdateStatusType of a BatchEvent given its batch index.
+func (c *BatchEvent) UpdateBatchEventStatus(ctx context.Context, batchIndex uint64) error {
+	db := c.db.WithContext(ctx)
+	db = db.Model(&BatchEvent{})
+	db = db.Where("batch_index = ?", batchIndex)
+	updateFields := map[string]interface{}{
+		"update_status": btypes.UpdateStatusTypeUpdated,
+	}
+	if err := db.Updates(updateFields).Error; err != nil {
+		return fmt.Errorf("failed to update batch event status, batchIndex: %d, error: %w", batchIndex, err)
+	}
+	return nil
+}

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

@@ -0,0 +1,163 @@
+package orm
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"time"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+
+	"scroll-tech/bridge-history-api/internal/types"
+)
+
+// BridgeBatchDepositEvent represents the bridge batch deposit event.
+type BridgeBatchDepositEvent struct {
+	db *gorm.DB `gorm:"column:-"`
+
+	ID             uint64     `json:"id" gorm:"column:id;primary_key"`
+	TokenType      int        `json:"token_type" gorm:"column:token_type"`
+	Sender         string     `json:"sender" gorm:"column:sender"`
+	BatchIndex     uint64     `json:"batch_index" gorm:"column:batch_index"`
+	TokenAmount    string     `json:"token_amount" gorm:"column:token_amount"`
+	Fee            string     `json:"fee" gorm:"column:fee"`
+	L1TokenAddress string     `json:"l1_token_address" gorm:"column:l1_token_address"`
+	L2TokenAddress string     `json:"l2_token_address" gorm:"column:l2_token_address"`
+	L1BlockNumber  uint64     `json:"l1_block_number" gorm:"column:l1_block_number"`
+	L2BlockNumber  uint64     `json:"l2_block_number" gorm:"column:l2_block_number"`
+	L1TxHash       string     `json:"l1_tx_hash" gorm:"column:l1_tx_hash"`
+	L1LogIndex     uint       `json:"l1_log_index" gorm:"column:l1_log_index"`
+	L2TxHash       string     `json:"l2_tx_hash" gorm:"column:l2_tx_hash"`
+	TxStatus       int        `json:"tx_status" gorm:"column:tx_status"`
+	BlockTimestamp uint64     `json:"block_timestamp" gorm:"column:block_timestamp"`
+	CreatedAt      time.Time  `json:"created_at" gorm:"column:created_at"`
+	UpdatedAt      time.Time  `json:"updated_at" gorm:"column:updated_at"`
+	DeletedAt      *time.Time `json:"deleted_at" gorm:"column:deleted_at"`
+}
+
+// TableName returns the table name for the BridgeBatchDepositEvent model.
+func (*BridgeBatchDepositEvent) TableName() string {
+	return "bridge_batch_deposit_event_v2"
+}
+
+// NewBridgeBatchDepositEvent returns a new instance of BridgeBatchDepositEvent.
+func NewBridgeBatchDepositEvent(db *gorm.DB) *BridgeBatchDepositEvent {
+	return &BridgeBatchDepositEvent{db: db}
+}
+
+// GetTxsByAddress returns the txs by address
+func (c *BridgeBatchDepositEvent) GetTxsByAddress(ctx context.Context, sender string) ([]*BridgeBatchDepositEvent, error) {
+	var messages []*BridgeBatchDepositEvent
+	db := c.db.WithContext(ctx)
+	db = db.Model(&BridgeBatchDepositEvent{})
+	db = db.Where("sender = ?", sender)
+	db = db.Order("block_timestamp desc")
+	db = db.Limit(500)
+	if err := db.Find(&messages).Error; err != nil {
+		return nil, fmt.Errorf("failed to get all txs by sender address, sender: %v, error: %w", sender, err)
+	}
+	return messages, nil
+}
+
+// GetMessagesByTxHashes retrieves all BridgeBatchDepositEvent from the database that match the provided transaction hashes.
+func (c *BridgeBatchDepositEvent) GetMessagesByTxHashes(ctx context.Context, txHashes []string) ([]*BridgeBatchDepositEvent, error) {
+	var messages []*BridgeBatchDepositEvent
+	db := c.db.WithContext(ctx)
+	db = db.Model(&BridgeBatchDepositEvent{})
+	db = db.Where("l1_tx_hash in (?) or l2_tx_hash in (?)", txHashes, txHashes)
+	if err := db.Find(&messages).Error; err != nil {
+		return nil, fmt.Errorf("failed to GetMessagesByTxHashes by tx hashes, tx hashes: %v, error: %w", txHashes, err)
+	}
+	return messages, nil
+}
+
+// GetMessageL1SyncedHeightInDB returns the l1 latest bridge batch deposit message height from the database
+func (c *BridgeBatchDepositEvent) GetMessageL1SyncedHeightInDB(ctx context.Context) (uint64, error) {
+	var message BridgeBatchDepositEvent
+	db := c.db.WithContext(ctx)
+	db = db.Model(&BridgeBatchDepositEvent{})
+	db = db.Order("l1_block_number desc")
+
+	err := db.First(&message).Error
+	if err != nil && errors.Is(gorm.ErrRecordNotFound, err) {
+		return 0, nil
+	}
+
+	if err != nil {
+		return 0, fmt.Errorf("failed to get l1 latest processed height, error: %w", err)
+	}
+
+	return message.L1BlockNumber, nil
+}
+
+// GetMessageL2SyncedHeightInDB returns the l2 latest bridge batch deposit message height from the database
+func (c *BridgeBatchDepositEvent) GetMessageL2SyncedHeightInDB(ctx context.Context) (uint64, error) {
+	var message BridgeBatchDepositEvent
+	db := c.db.WithContext(ctx)
+	db = db.Model(&BridgeBatchDepositEvent{})
+	db = db.Order("l2_block_number desc")
+
+	err := db.First(&message).Error
+	if err != nil && errors.Is(gorm.ErrRecordNotFound, err) {
+		return 0, nil
+	}
+
+	if err != nil {
+		return 0, fmt.Errorf("failed to get l2 latest processed height, error: %w", err)
+	}
+
+	return message.L2BlockNumber, nil
+}
+
+// InsertOrUpdateL1BridgeBatchDepositEvent inserts or updates a new L1 BridgeBatchDepositEvent
+func (c *BridgeBatchDepositEvent) InsertOrUpdateL1BridgeBatchDepositEvent(ctx context.Context, l1BatchDepositEvents []*BridgeBatchDepositEvent) error {
+	if len(l1BatchDepositEvents) == 0 {
+		return nil
+	}
+
+	db := c.db
+	db = db.WithContext(ctx)
+	db = db.Model(&BridgeBatchDepositEvent{})
+	db = db.Clauses(clause.OnConflict{
+		Columns:   []clause.Column{{Name: "l1_tx_hash"}, {Name: "l1_log_index"}},
+		DoUpdates: clause.AssignmentColumns([]string{"token_amount", "fee", "l1_block_number", "l1_token_address", "tx_status", "block_timestamp"}),
+	})
+	if err := db.Create(l1BatchDepositEvents).Error; err != nil {
+		return fmt.Errorf("failed to insert message, error: %w", err)
+	}
+	return nil
+}
+
+// UpdateBatchEventStatus updates the tx_status of BridgeBatchDepositEvent given batch index
+func (c *BridgeBatchDepositEvent) UpdateBatchEventStatus(ctx context.Context, distributeMessage *BridgeBatchDepositEvent) error {
+	db := c.db.WithContext(ctx)
+	db = db.Model(&BridgeBatchDepositEvent{})
+	db = db.Where("batch_index = ?", distributeMessage.BatchIndex)
+	db = db.Where("token_type = ?", distributeMessage.TokenType)
+	updateFields := map[string]interface{}{
+		"l2_token_address": distributeMessage.L2TokenAddress,
+		"l2_block_number":  distributeMessage.L2BlockNumber,
+		"l2_tx_hash":       distributeMessage.L2TxHash,
+		"tx_status":        types.TxStatusBridgeBatchDistribute,
+	}
+	if err := db.Updates(updateFields).Error; err != nil {
+		return fmt.Errorf("failed to UpdateBatchEventStatus, batchIndex: %d, error: %w", distributeMessage.BatchIndex, err)
+	}
+	return nil
+}
+
+// UpdateDistributeFailedStatus updates the tx_status of BridgeBatchDepositEvent given batch index and senders
+func (c *BridgeBatchDepositEvent) UpdateDistributeFailedStatus(ctx context.Context, batchIndex uint64, senders []string) error {
+	db := c.db.WithContext(ctx)
+	db = db.Model(&BridgeBatchDepositEvent{})
+	db = db.Where("batch_index = ?", batchIndex)
+	db = db.Where("sender in (?)", senders)
+	updateFields := map[string]interface{}{
+		"tx_status": types.TxStatusBridgeBatchDistributeFailed,
+	}
+	if err := db.Updates(updateFields).Error; err != nil {
+		return fmt.Errorf("failed to UpdateDistributeFailedStatus, batchIndex: %d, senders:%v, error: %w", batchIndex, senders, err)
+	}
+	return nil
+}

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

@@ -0,0 +1,501 @@
+package orm
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/scroll-tech/go-ethereum/common"
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+
+	"scroll-tech/bridge-history-api/internal/types"
+
+	btypes "scroll-tech/bridge-history-api/internal/types"
+)
+
+// MessageQueueEvent struct represents the details of a batch event.
+type MessageQueueEvent struct {
+	EventType  btypes.MessageQueueEventType
+	QueueIndex uint64
+
+	// Track replay tx hash and refund tx hash.
+	TxHash common.Hash
+
+	// QueueTransaction only in replayMessage, to track which message is replayed.
+	MessageHash common.Hash
+}
+
+// CrossMessage represents a cross message.
+type CrossMessage struct {
+	db *gorm.DB `gorm:"column:-"`
+
+	ID             uint64     `json:"id" gorm:"column:id;primary_key"`
+	MessageType    int        `json:"message_type" gorm:"column:message_type"`
+	RollupStatus   int        `json:"rollup_status" gorm:"column:rollup_status"`
+	TxStatus       int        `json:"tx_status" gorm:"column:tx_status"`
+	TokenType      int        `json:"token_type" gorm:"column:token_type"`
+	Sender         string     `json:"sender" gorm:"column:sender"`
+	Receiver       string     `json:"receiver" gorm:"column:receiver"`
+	MessageHash    string     `json:"message_hash" gorm:"column:message_hash"`
+	L1TxHash       string     `json:"l1_tx_hash" gorm:"column:l1_tx_hash"` // initial tx hash, if MessageType is MessageTypeL1SentMessage.
+	L1ReplayTxHash string     `json:"l1_replay_tx_hash" gorm:"column:l1_replay_tx_hash"`
+	L1RefundTxHash string     `json:"l1_refund_tx_hash" gorm:"column:l1_refund_tx_hash"`
+	L2TxHash       string     `json:"l2_tx_hash" gorm:"column:l2_tx_hash"` // initial tx hash, if MessageType is MessageTypeL2SentMessage.
+	L1BlockNumber  uint64     `json:"l1_block_number" gorm:"column:l1_block_number"`
+	L2BlockNumber  uint64     `json:"l2_block_number" gorm:"column:l2_block_number"`
+	L1TokenAddress string     `json:"l1_token_address" gorm:"column:l1_token_address"`
+	L2TokenAddress string     `json:"l2_token_address" gorm:"column:l2_token_address"`
+	TokenIDs       string     `json:"token_ids" gorm:"column:token_ids"`
+	TokenAmounts   string     `json:"token_amounts" gorm:"column:token_amounts"`
+	BlockTimestamp uint64     `json:"block_timestamp" gorm:"column:block_timestamp"`
+	MessageFrom    string     `json:"message_from" gorm:"column:message_from"`
+	MessageTo      string     `json:"message_to" gorm:"column:message_to"`
+	MessageValue   string     `json:"message_value" gorm:"column:message_value"`
+	MessageNonce   uint64     `json:"message_nonce" gorm:"column:message_nonce"`
+	MessageData    string     `json:"message_data" gorm:"column:message_data"`
+	MerkleProof    []byte     `json:"merkle_proof" gorm:"column:merkle_proof"`
+	BatchIndex     uint64     `json:"batch_index" gorm:"column:batch_index"`
+	CreatedAt      time.Time  `json:"created_at" gorm:"column:created_at"`
+	UpdatedAt      time.Time  `json:"updated_at" gorm:"column:updated_at"`
+	DeletedAt      *time.Time `json:"deleted_at" gorm:"column:deleted_at"`
+}
+
+// TableName returns the table name for the CrossMessage model.
+func (*CrossMessage) TableName() string {
+	return "cross_message_v2"
+}
+
+// NewCrossMessage returns a new instance of CrossMessage.
+func NewCrossMessage(db *gorm.DB) *CrossMessage {
+	return &CrossMessage{db: db}
+}
+
+// GetMessageSyncedHeightInDB returns the latest synced cross message height from the database for a given message type.
+func (c *CrossMessage) GetMessageSyncedHeightInDB(ctx context.Context, messageType btypes.MessageType) (uint64, error) {
+	var message CrossMessage
+	db := c.db.WithContext(ctx)
+	db = db.Model(&CrossMessage{})
+	db = db.Where("message_type = ?", messageType)
+	switch {
+	case messageType == btypes.MessageTypeL1SentMessage:
+		db = db.Order("l1_block_number desc")
+	case messageType == btypes.MessageTypeL2SentMessage:
+		db = db.Order("l2_block_number desc")
+	}
+	if err := db.First(&message).Error; err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return 0, nil
+		}
+		return 0, fmt.Errorf("failed to get latest processed height, type: %v, error: %w", messageType, err)
+	}
+	switch {
+	case messageType == btypes.MessageTypeL1SentMessage:
+		return message.L1BlockNumber, nil
+	case messageType == btypes.MessageTypeL2SentMessage:
+		return message.L2BlockNumber, nil
+	default:
+		return 0, fmt.Errorf("invalid message type: %v", messageType)
+	}
+}
+
+// GetL2LatestFinalizedWithdrawal returns the latest finalized L2 withdrawal from the database.
+func (c *CrossMessage) GetL2LatestFinalizedWithdrawal(ctx context.Context) (*CrossMessage, error) {
+	var message CrossMessage
+	db := c.db.WithContext(ctx)
+	db = db.Model(&CrossMessage{})
+	db = db.Where("message_type = ?", btypes.MessageTypeL2SentMessage)
+	db = db.Where("rollup_status = ?", btypes.RollupStatusTypeFinalized)
+	db = db.Order("message_nonce desc")
+	if err := db.First(&message).Error; err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+		return nil, fmt.Errorf("failed to get latest L2 finalized sent message event, error: %w", err)
+	}
+	return &message, nil
+}
+
+// GetL2WithdrawalsByBlockRange returns the L2 withdrawals by block range from the database.
+func (c *CrossMessage) GetL2WithdrawalsByBlockRange(ctx context.Context, startBlock, endBlock uint64) ([]*CrossMessage, error) {
+	var messages []*CrossMessage
+	db := c.db.WithContext(ctx)
+	db = db.Model(&CrossMessage{})
+	db = db.Where("l2_block_number >= ?", startBlock)
+	db = db.Where("l2_block_number <= ?", endBlock)
+	db = db.Where("tx_status != ?", types.TxStatusTypeSentTxReverted)
+	db = db.Where("message_type = ?", btypes.MessageTypeL2SentMessage)
+	db = db.Order("message_nonce asc")
+	if err := db.Find(&messages).Error; err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+		return nil, fmt.Errorf("failed to get L2 withdrawals by block range, error: %v", err)
+	}
+	return messages, nil
+}
+
+// GetMessagesByTxHashes retrieves all cross messages from the database that match the provided transaction hashes.
+func (c *CrossMessage) GetMessagesByTxHashes(ctx context.Context, txHashes []string) ([]*CrossMessage, error) {
+	var messages []*CrossMessage
+	db := c.db.WithContext(ctx)
+	db = db.Model(&CrossMessage{})
+	db = db.Where("l1_tx_hash in (?) or l2_tx_hash in (?)", txHashes, txHashes)
+	if err := db.Find(&messages).Error; err != nil {
+		return nil, fmt.Errorf("failed to get L2 messages by tx hashes, tx hashes: %v, error: %w", txHashes, err)
+	}
+	return messages, nil
+}
+
+// GetL2UnclaimedWithdrawalsByAddress retrieves all L2 unclaimed withdrawal messages for a given sender address.
+func (c *CrossMessage) GetL2UnclaimedWithdrawalsByAddress(ctx context.Context, sender string) ([]*CrossMessage, error) {
+	var messages []*CrossMessage
+	db := c.db.WithContext(ctx)
+	db = db.Model(&CrossMessage{})
+	db = db.Where("message_type = ?", btypes.MessageTypeL2SentMessage)
+	db = db.Where("tx_status in (?)", []types.TxStatusType{types.TxStatusTypeSent, types.TxStatusTypeFailedRelayed, types.TxStatusTypeRelayTxReverted})
+	db = db.Where("sender = ?", sender)
+	db = db.Order("block_timestamp desc")
+	db = db.Limit(500)
+	if err := db.Find(&messages).Error; err != nil {
+		return nil, fmt.Errorf("failed to get L2 claimable withdrawal messages by sender address, sender: %v, error: %w", sender, err)
+	}
+	return messages, nil
+}
+
+// GetL2WithdrawalsByAddress retrieves all L2 claimable withdrawal messages for a given sender address.
+func (c *CrossMessage) GetL2WithdrawalsByAddress(ctx context.Context, sender string) ([]*CrossMessage, error) {
+	var messages []*CrossMessage
+	db := c.db.WithContext(ctx)
+	db = db.Model(&CrossMessage{})
+	db = db.Where("message_type = ?", btypes.MessageTypeL2SentMessage)
+	db = db.Where("sender = ?", sender)
+	db = db.Order("block_timestamp desc")
+	db = db.Limit(500)
+	if err := db.Find(&messages).Error; err != nil {
+		return nil, fmt.Errorf("failed to get L2 withdrawal messages by sender address, sender: %v, error: %w", sender, err)
+	}
+	return messages, nil
+}
+
+// GetTxsByAddress retrieves all txs for a given sender address.
+func (c *CrossMessage) GetTxsByAddress(ctx context.Context, sender string) ([]*CrossMessage, error) {
+	var messages []*CrossMessage
+	db := c.db.WithContext(ctx)
+	db = db.Model(&CrossMessage{})
+	db = db.Where("sender = ?", sender)
+	db = db.Order("block_timestamp desc")
+	db = db.Limit(500)
+	if err := db.Find(&messages).Error; err != nil {
+		return nil, fmt.Errorf("failed to get all txs by sender address, sender: %v, error: %w", sender, err)
+	}
+	return messages, nil
+}
+
+// UpdateL1MessageQueueEventsInfo updates the information about L1 message queue events in the database.
+func (c *CrossMessage) UpdateL1MessageQueueEventsInfo(ctx context.Context, l1MessageQueueEvents []*MessageQueueEvent) error {
+	// update tx statuses.
+	for _, l1MessageQueueEvent := range l1MessageQueueEvents {
+		db := c.db
+		db = db.WithContext(ctx)
+		db = db.Model(&CrossMessage{})
+		txStatusUpdateFields := make(map[string]interface{})
+		switch l1MessageQueueEvent.EventType {
+		case btypes.MessageQueueEventTypeQueueTransaction:
+			continue
+		case btypes.MessageQueueEventTypeDequeueTransaction:
+			// do not over-write terminal statuses.
+			db = db.Where("tx_status != ?", types.TxStatusTypeRelayed)
+			db = db.Where("tx_status != ?", types.TxStatusTypeDropped)
+			db = db.Where("message_nonce = ?", l1MessageQueueEvent.QueueIndex)
+			db = db.Where("message_type = ?", btypes.MessageTypeL1SentMessage)
+			txStatusUpdateFields["tx_status"] = types.TxStatusTypeSkipped
+		case btypes.MessageQueueEventTypeDropTransaction:
+			// do not over-write terminal statuses.
+			db = db.Where("tx_status != ?", types.TxStatusTypeRelayed)
+			db = db.Where("tx_status != ?", types.TxStatusTypeDropped)
+			db = db.Where("message_nonce = ?", l1MessageQueueEvent.QueueIndex)
+			db = db.Where("message_type = ?", btypes.MessageTypeL1SentMessage)
+			txStatusUpdateFields["tx_status"] = types.TxStatusTypeDropped
+		case btypes.MessageQueueEventTypeResetDequeuedTransaction:
+			db = db.Where("tx_status = ?", types.TxStatusTypeSkipped)
+			// reset skipped messages that the nonce is greater than or equal to the queue index.
+			db = db.Where("message_nonce >= ?", l1MessageQueueEvent.QueueIndex)
+			db = db.Where("message_type = ?", btypes.MessageTypeL1SentMessage)
+			txStatusUpdateFields["tx_status"] = types.TxStatusTypeSent
+		}
+		if err := db.Updates(txStatusUpdateFields).Error; err != nil {
+			return fmt.Errorf("failed to update tx statuses of L1 message queue events, update fields: %v, error: %w", txStatusUpdateFields, err)
+		}
+	}
+
+	// update tx hashes of replay and refund.
+	for _, l1MessageQueueEvent := range l1MessageQueueEvents {
+		db := c.db
+		db = db.WithContext(ctx)
+		db = db.Model(&CrossMessage{})
+		txHashUpdateFields := make(map[string]interface{})
+		switch l1MessageQueueEvent.EventType {
+		case btypes.MessageQueueEventTypeDequeueTransaction, btypes.MessageQueueEventTypeResetDequeuedTransaction:
+			continue
+		case btypes.MessageQueueEventTypeQueueTransaction:
+			// only replayMessages or enforced txs (whose message hashes would not be found), sendMessages have been filtered out.
+			// replayMessage case:
+			// First SentMessage in L1: https://sepolia.etherscan.io/tx/0xbee4b631312448fcc2caac86e4dccf0a2ae0a88acd6c5fd8764d39d746e472eb
+			// Transaction reverted in L2: https://sepolia.scrollscan.com/tx/0xde6ef307a7da255888aad7a4c40a6b8c886e46a8a05883070bbf18b736cbfb8c
+			// replayMessage: https://sepolia.etherscan.io/tx/0xa5392891232bb32d98fcdbaca0d91b4d22ef2755380d07d982eebd47b147ce28
+			//
+			// Note: update l1_tx_hash if the user calls replayMessage, cannot use queue index here,
+			// because in replayMessage, queue index != message nonce.
+			// Ref: https://github.com/scroll-tech/scroll/blob/v4.3.44/contracts/src/L1/L1ScrollMessenger.sol#L187-L190
+			db = db.Where("message_hash = ?", l1MessageQueueEvent.MessageHash.String())
+			txHashUpdateFields["l1_replay_tx_hash"] = l1MessageQueueEvent.TxHash.String()
+		case btypes.MessageQueueEventTypeDropTransaction:
+			db = db.Where("message_nonce = ?", l1MessageQueueEvent.QueueIndex)
+			db = db.Where("message_type = ?", btypes.MessageTypeL1SentMessage)
+			txHashUpdateFields["l1_refund_tx_hash"] = l1MessageQueueEvent.TxHash.String()
+		}
+		if err := db.Updates(txHashUpdateFields).Error; err != nil {
+			return fmt.Errorf("failed to update tx hashes of replay and refund in L1 message queue events info, update fields: %v, error: %w", txHashUpdateFields, err)
+		}
+	}
+	return nil
+}
+
+// UpdateBatchStatusOfL2Withdrawals updates batch status of L2 withdrawals.
+func (c *CrossMessage) UpdateBatchStatusOfL2Withdrawals(ctx context.Context, startBlockNumber, endBlockNumber, batchIndex uint64) error {
+	db := c.db.WithContext(ctx)
+	db = db.Model(&CrossMessage{})
+	db = db.Where("message_type = ?", btypes.MessageTypeL2SentMessage)
+	db = db.Where("l2_block_number >= ?", startBlockNumber)
+	db = db.Where("l2_block_number <= ?", endBlockNumber)
+	updateFields := make(map[string]interface{})
+	updateFields["batch_index"] = batchIndex
+	updateFields["rollup_status"] = btypes.RollupStatusTypeFinalized
+	if err := db.Updates(updateFields).Error; err != nil {
+		return fmt.Errorf("failed to update batch status of L2 sent messages, start: %v, end: %v, index: %v, error: %w", startBlockNumber, endBlockNumber, batchIndex, err)
+	}
+	return nil
+}
+
+// UpdateBatchIndexRollupStatusMerkleProofOfL2Messages updates the batch_index, rollup_status, and merkle_proof fields for a list of L2 cross messages.
+func (c *CrossMessage) UpdateBatchIndexRollupStatusMerkleProofOfL2Messages(ctx context.Context, messages []*CrossMessage) error {
+	if len(messages) == 0 {
+		return nil
+	}
+	for _, message := range messages {
+		updateFields := map[string]interface{}{
+			"batch_index":   message.BatchIndex,
+			"rollup_status": message.RollupStatus,
+			"merkle_proof":  message.MerkleProof,
+		}
+		db := c.db.WithContext(ctx)
+		db = db.Model(&CrossMessage{})
+		db = db.Where("message_hash = ?", message.MessageHash)
+		if err := db.Updates(updateFields).Error; err != nil {
+			return fmt.Errorf("failed to update L2 message with message_hash %s, error: %w", message.MessageHash, err)
+		}
+	}
+	return nil
+}
+
+// InsertOrUpdateL1Messages inserts or updates a list of L1 cross messages into the database.
+func (c *CrossMessage) InsertOrUpdateL1Messages(ctx context.Context, messages []*CrossMessage) error {
+	if len(messages) == 0 {
+		return nil
+	}
+	db := c.db
+	db = db.WithContext(ctx)
+	db = db.Model(&CrossMessage{})
+	// 'tx_status' column is not explicitly assigned during the update to prevent a later status from being overwritten back to "sent".
+	db = db.Clauses(clause.OnConflict{
+		Columns:   []clause.Column{{Name: "message_hash"}},
+		DoUpdates: clause.AssignmentColumns([]string{"sender", "receiver", "token_type", "l1_block_number", "l1_tx_hash", "l1_token_address", "l2_token_address", "token_ids", "token_amounts", "message_type", "block_timestamp", "message_nonce"}),
+	})
+	if err := db.Create(messages).Error; err != nil {
+		return fmt.Errorf("failed to insert message, error: %w", err)
+	}
+	return nil
+}
+
+// InsertOrUpdateL2Messages inserts or updates a list of L2 cross messages into the database.
+func (c *CrossMessage) InsertOrUpdateL2Messages(ctx context.Context, messages []*CrossMessage) error {
+	if len(messages) == 0 {
+		return nil
+	}
+	db := c.db
+	db = db.WithContext(ctx)
+	db = db.Model(&CrossMessage{})
+	// 'tx_status' column is not explicitly assigned during the update to prevent a later status from being overwritten back to "sent".
+	db = db.Clauses(clause.OnConflict{
+		Columns:   []clause.Column{{Name: "message_hash"}},
+		DoUpdates: clause.AssignmentColumns([]string{"sender", "receiver", "token_type", "l2_block_number", "l2_tx_hash", "l1_token_address", "l2_token_address", "token_ids", "token_amounts", "message_type", "block_timestamp", "message_from", "message_to", "message_value", "message_data", "message_nonce"}),
+	})
+	if err := db.Create(messages).Error; err != nil {
+		return fmt.Errorf("failed to insert message, error: %w", err)
+	}
+	return nil
+}
+
+// InsertFailedL2GatewayTxs inserts a list of transactions that failed to interact with the L2 gateways into the database.
+// To resolve unique index confliction, L2 tx hash is used as the MessageHash.
+// The OnConflict clause is used to prevent inserting same failed transactions multiple times.
+func (c *CrossMessage) InsertFailedL2GatewayTxs(ctx context.Context, messages []*CrossMessage) error {
+	if len(messages) == 0 {
+		return nil
+	}
+
+	for _, message := range messages {
+		message.MessageHash = message.L2TxHash
+	}
+
+	db := c.db
+	db = db.WithContext(ctx)
+	db = db.Model(&CrossMessage{})
+	db = db.Clauses(clause.OnConflict{
+		Columns:   []clause.Column{{Name: "message_hash"}},
+		DoNothing: true,
+	})
+
+	if err := db.Create(&messages).Error; err != nil {
+		return fmt.Errorf("failed to insert failed gateway router txs, error: %w", err)
+	}
+	return nil
+}
+
+// InsertFailedL1GatewayTxs inserts a list of transactions that failed to interact with the L1 gateways into the database.
+// To resolve unique index confliction, L1 tx hash is used as the MessageHash.
+// The OnConflict clause is used to prevent inserting same failed transactions multiple times.
+func (c *CrossMessage) InsertFailedL1GatewayTxs(ctx context.Context, messages []*CrossMessage) error {
+	if len(messages) == 0 {
+		return nil
+	}
+
+	for _, message := range messages {
+		message.MessageHash = message.L1TxHash
+	}
+
+	db := c.db
+	db = db.WithContext(ctx)
+	db = db.Model(&CrossMessage{})
+	db = db.Clauses(clause.OnConflict{
+		Columns:   []clause.Column{{Name: "message_hash"}},
+		DoNothing: true,
+	})
+
+	if err := db.Create(&messages).Error; err != nil {
+		return fmt.Errorf("failed to insert failed gateway router txs, error: %w", err)
+	}
+	return nil
+}
+
+// InsertOrUpdateL2RelayedMessagesOfL1Deposits inserts or updates the database with a list of L2 relayed messages related to L1 deposits.
+func (c *CrossMessage) InsertOrUpdateL2RelayedMessagesOfL1Deposits(ctx context.Context, l2RelayedMessages []*CrossMessage) error {
+	if len(l2RelayedMessages) == 0 {
+		return nil
+	}
+	// Deduplicate messages, for each message_hash, retaining message with the highest block number.
+	// This is necessary as a single message, like a FailedRelayedMessage or a reverted relayed transaction,
+	// may be relayed multiple times within certain block ranges, potentially leading to the error:
+	// "ERROR: ON CONFLICT DO UPDATE command cannot affect row a second time (SQLSTATE 21000)".
+	// This happens if we attempt to insert multiple records with the same message_hash in a single db.Create operation.
+	// For example, see these transactions where the same message was relayed twice within certain block ranges:
+	// Reverted tx 1: https://sepolia.scrollscan.com/tx/0xcd6979277c3bc747445273a5e58ef1e9692fbe101d88cfefbbb69d3aef3193c0
+	// Reverted tx 2: https://sepolia.scrollscan.com/tx/0x43e28ed7cb71107c18c5d8ebbdb4a1d9cac73e60391d14d41e92985028faa337
+	// Another example:
+	// FailedRelayedMessage 1: https://sepolia.scrollscan.com/tx/0xfadb147fb211e5096446c5cac3ae0a8a705d2ece6c47c65135c8874f84638f17
+	// FailedRelayedMessage 2: https://sepolia.scrollscan.com/tx/0x6cb149b61afd07bf2e17561a59ebebde41e343b6610290c97515b2f862160b42
+	mergedL2RelayedMessages := make(map[string]*CrossMessage)
+	for _, message := range l2RelayedMessages {
+		if existing, found := mergedL2RelayedMessages[message.MessageHash]; found {
+			if types.TxStatusType(message.TxStatus) == types.TxStatusTypeRelayed || message.L2BlockNumber > existing.L2BlockNumber {
+				mergedL2RelayedMessages[message.MessageHash] = message
+			}
+		} else {
+			mergedL2RelayedMessages[message.MessageHash] = message
+		}
+	}
+	uniqueL2RelayedMessages := make([]*CrossMessage, 0, len(mergedL2RelayedMessages))
+	for _, msg := range mergedL2RelayedMessages {
+		uniqueL2RelayedMessages = append(uniqueL2RelayedMessages, msg)
+	}
+	// Do not update tx status of successfully relayed messages,
+	// because if a message is handled, the later relayed message tx would be reverted.
+	// ref: https://github.com/scroll-tech/scroll/blob/v4.3.44/contracts/src/L2/L2ScrollMessenger.sol#L102
+	// e.g.,
+	// Successfully relayed: https://sepolia.scrollscan.com/tx/0x4eb7cb07ba76956259c0079819a34a146f8a93dd891dc94812e9b3d66b056ec7#eventlog
+	// Reverted tx 1 (Reason: Message was already successfully executed): https://sepolia.scrollscan.com/tx/0x1973cafa14eb40734df30da7bfd4d9aceb53f8f26e09d96198c16d0e2e4a95fd
+	// Reverted tx 2 (Reason: Message was already successfully executed): https://sepolia.scrollscan.com/tx/0x02fc3a28684a590aead2482022f56281539085bd3d273ac8dedc1ceccb2bc554
+	db := c.db.WithContext(ctx)
+	db = db.Model(&CrossMessage{})
+	db = db.Clauses(clause.OnConflict{
+		Columns:   []clause.Column{{Name: "message_hash"}},
+		DoUpdates: clause.AssignmentColumns([]string{"message_type", "l2_block_number", "l2_tx_hash", "tx_status"}),
+		Where: clause.Where{
+			Exprs: []clause.Expression{
+				clause.And(
+					// do not over-write terminal statuses.
+					clause.Neq{Column: "cross_message_v2.tx_status", Value: types.TxStatusTypeRelayed},
+					clause.Neq{Column: "cross_message_v2.tx_status", Value: types.TxStatusTypeDropped},
+				),
+			},
+		},
+	})
+	if err := db.Create(uniqueL2RelayedMessages).Error; err != nil {
+		return fmt.Errorf("failed to update L2 reverted relayed message of L1 deposit, error: %w", err)
+	}
+	return nil
+}
+
+// InsertOrUpdateL1RelayedMessagesOfL2Withdrawals inserts or updates the database with a list of L1 relayed messages related to L2 withdrawals.
+func (c *CrossMessage) InsertOrUpdateL1RelayedMessagesOfL2Withdrawals(ctx context.Context, l1RelayedMessages []*CrossMessage) error {
+	if len(l1RelayedMessages) == 0 {
+		return nil
+	}
+	// Deduplicate messages, for each message_hash, retaining message with the highest block number.
+	// This is necessary as a single message, like a FailedRelayedMessage or a reverted relayed transaction,
+	// may be relayed multiple times within certain block ranges, potentially leading to the error:
+	// "ERROR: ON CONFLICT DO UPDATE command cannot affect row a second time (SQLSTATE 21000)".
+	// This happens if we attempt to insert multiple records with the same message_hash in a single db.Create operation.
+	// For example, see these transactions where the same message was relayed twice within certain block ranges:
+	// FailedRelayedMessage 1: https://sepolia.etherscan.io/tx/0x28b3212cda6ca0f3790f362a780257bbe2b37417ccf75a4eca6c3a08294c8f1b#eventlog
+	// FailedRelayedMessage 2: https://sepolia.etherscan.io/tx/0xc8a8254825dd2cab5caef58cfd8d88c077ceadadc78f2340214a86cf8ab88543#eventlog
+	// Another example (relayed success, then relayed again):
+	// Relay Message, and success: https://sepolia.etherscan.io/tx/0xcfdf2f5446719e3e123a8aa06e4d6b3809c3850a13adf875755c8b1e423aa448#eventlog
+	// Relay Message again, and reverted: https://sepolia.etherscan.io/tx/0xb1fcae7546f3de4cfd0b4d679f4075adb4eb69578b12e2b5673f5f24b1836578
+	mergedL1RelayedMessages := make(map[string]*CrossMessage)
+	for _, message := range l1RelayedMessages {
+		if existing, found := mergedL1RelayedMessages[message.MessageHash]; found {
+			if types.TxStatusType(message.TxStatus) == types.TxStatusTypeRelayed || message.L1BlockNumber > existing.L1BlockNumber {
+				mergedL1RelayedMessages[message.MessageHash] = message
+			}
+		} else {
+			mergedL1RelayedMessages[message.MessageHash] = message
+		}
+	}
+	uniqueL1RelayedMessages := make([]*CrossMessage, 0, len(mergedL1RelayedMessages))
+	for _, msg := range mergedL1RelayedMessages {
+		uniqueL1RelayedMessages = append(uniqueL1RelayedMessages, msg)
+	}
+	db := c.db
+	db = db.WithContext(ctx)
+	db = db.Model(&CrossMessage{})
+	db = db.Clauses(clause.OnConflict{
+		Columns:   []clause.Column{{Name: "message_hash"}},
+		DoUpdates: clause.AssignmentColumns([]string{"message_type", "l1_block_number", "l1_tx_hash", "tx_status"}),
+		Where: clause.Where{
+			Exprs: []clause.Expression{
+				clause.And(
+					// do not over-write terminal statuses.
+					clause.Neq{Column: "cross_message_v2.tx_status", Value: types.TxStatusTypeRelayed},
+					clause.Neq{Column: "cross_message_v2.tx_status", Value: types.TxStatusTypeDropped},
+				),
+			},
+		},
+	})
+	if err := db.Create(uniqueL1RelayedMessages).Error; err != nil {
+		return fmt.Errorf("failed to update L1 relayed message of L2 withdrawal, error: %w", err)
+	}
+	return nil
+}

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

@@ -18,7 +18,7 @@ const MigrationsDir string = "migrations"
 func init() {
 	goose.SetBaseFS(embedMigrations)
 	goose.SetSequential(true)
-	goose.SetTableName("bridge_history_migrations")
+	goose.SetTableName("bridge_historyv2_migrations")
 
 	verbose, _ := strconv.ParseBool(os.Getenv("LOG_SQL_MIGRATIONS"))
 	goose.SetVerbose(verbose)

bridge-history-api/internal/orm/migrate/migrations/00001_cross_message_v2.sql

@@ -0,0 +1,57 @@
+-- +goose Up
+-- +goose StatementBegin
+CREATE TABLE cross_message_v2
+(
+    id                  BIGSERIAL    PRIMARY KEY,
+    message_type        SMALLINT     NOT NULL,
+    tx_status           SMALLINT     NOT NULL,
+    rollup_status       SMALLINT     NOT NULL,
+    token_type          SMALLINT     NOT NULL,
+    sender              VARCHAR      NOT NULL,
+    receiver            VARCHAR      NOT NULL,
+
+    message_hash        VARCHAR      DEFAULT NULL, -- NULL for failed txs
+    l1_tx_hash          VARCHAR      DEFAULT NULL,
+    l1_replay_tx_hash   VARCHAR      DEFAULT NULL,
+    l1_refund_tx_hash   VARCHAR      DEFAULT NULL,
+    l2_tx_hash          VARCHAR      DEFAULT NULL,
+    l1_block_number     BIGINT       DEFAULT NULL,
+    l2_block_number     BIGINT       DEFAULT NULL,
+    l1_token_address    VARCHAR      DEFAULT NULL,
+    l2_token_address    VARCHAR      DEFAULT NULL,
+    token_ids           VARCHAR      DEFAULT NULL,
+    token_amounts       VARCHAR      NOT NULL,
+    block_timestamp     BIGINT       NOT NULL,     -- timestamp to sort L1 Deposit & L2 Withdraw events altogether
+
+--- claim info
+    message_from        VARCHAR      DEFAULT NULL,
+    message_to          VARCHAR      DEFAULT NULL,
+    message_value       VARCHAR      DEFAULT NULL,
+    message_nonce       BIGINT       DEFAULT NULL,
+    message_data        VARCHAR      DEFAULT NULL,
+    merkle_proof        BYTEA        DEFAULT NULL,
+    batch_index         BIGINT       DEFAULT NULL,
+
+-- metadata
+    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 IF NOT EXISTS idx_cm_message_hash ON cross_message_v2 (message_hash);
+CREATE INDEX IF NOT EXISTS idx_cm_message_type_l1_block_number ON cross_message_v2 (message_type, l1_block_number DESC);
+CREATE INDEX IF NOT EXISTS idx_cm_message_type_l2_block_number ON cross_message_v2 (message_type, l2_block_number DESC);
+CREATE INDEX IF NOT EXISTS idx_cm_message_type_rollup_status_message_nonce ON cross_message_v2 (message_type, rollup_status, message_nonce DESC);
+CREATE INDEX IF NOT EXISTS idx_cm_message_type_message_nonce_tx_status_l2_block_number ON cross_message_v2 (message_type, message_nonce, tx_status, l2_block_number);
+CREATE INDEX IF NOT EXISTS idx_cm_l1_tx_hash ON cross_message_v2 (l1_tx_hash);
+CREATE INDEX IF NOT EXISTS idx_cm_l2_tx_hash ON cross_message_v2 (l2_tx_hash);
+CREATE INDEX IF NOT EXISTS idx_cm_message_type_tx_status_sender_block_timestamp ON cross_message_v2 (message_type, tx_status, sender, block_timestamp DESC);
+CREATE INDEX IF NOT EXISTS idx_cm_message_type_sender_block_timestamp ON cross_message_v2 (message_type, sender, block_timestamp DESC);
+CREATE INDEX IF NOT EXISTS idx_cm_sender_block_timestamp ON cross_message_v2 (sender, block_timestamp DESC);
+
+-- +goose StatementEnd
+
+-- +goose Down
+-- +goose StatementBegin
+DROP TABLE IF EXISTS cross_message_v2;
+-- +goose StatementEnd

bridge-history-api/internal/orm/migrate/migrations/00002_batch_event_v2.sql

@@ -0,0 +1,29 @@
+-- +goose Up
+-- +goose StatementBegin
+CREATE TABLE batch_event_v2
+(
+    id                  BIGSERIAL     PRIMARY KEY,
+    l1_block_number     BIGINT        NOT NULL,
+    batch_status        SMALLINT      NOT NULL,
+    batch_index         BIGINT        NOT NULL,
+    batch_hash          VARCHAR       NOT NULL,
+    start_block_number  BIGINT        NOT NULL,
+    end_block_number    BIGINT        NOT NULL,
+    update_status       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 IF NOT EXISTS unique_idx_be_batch_hash ON batch_event_v2 (batch_hash);
+CREATE INDEX IF NOT EXISTS idx_be_l1_block_number ON batch_event_v2 (l1_block_number);
+CREATE INDEX IF NOT EXISTS idx_be_batch_index ON batch_event_v2 (batch_index);
+CREATE INDEX IF NOT EXISTS idx_be_batch_index_batch_hash ON batch_event_v2 (batch_index, batch_hash);
+CREATE INDEX IF NOT EXISTS idx_be_end_block_number_update_status_batch_status_batch_index ON batch_event_v2 (end_block_number, update_status, batch_status, batch_index);
+
+-- +goose StatementEnd
+
+-- +goose Down
+-- +goose StatementBegin
+DROP TABLE IF EXISTS batch_event_v2;
+-- +goose StatementEnd

bridge-history-api/internal/orm/migrate/migrations/00003_bridge_batch_deposit_event_v2.sql

@@ -0,0 +1,38 @@
+-- +goose Up
+-- +goose StatementBegin
+CREATE TABLE bridge_batch_deposit_event_v2
+(
+    id                  BIGSERIAL     PRIMARY KEY,
+    token_type          SMALLINT      NOT NULL,
+    sender              VARCHAR       NOT NULL,
+    batch_index         BIGINT        DEFAULT NULL,
+    token_amount        VARCHAR       NOT NULL,
+    fee                 VARCHAR       NOT NULL,
+    l1_token_address    VARCHAR       DEFAULT NULL,
+    l2_token_address    VARCHAR       DEFAULT NULL,
+    l1_block_number     BIGINT        DEFAULT NULL,
+    l2_block_number     BIGINT        DEFAULT NULL,
+    l1_tx_hash          VARCHAR       DEFAULT NULL,
+    l1_log_index        INTEGER       DEFAULT NULL,
+    l2_tx_hash          VARCHAR       DEFAULT NULL,
+    tx_status           SMALLINT      NOT NULL,
+    block_timestamp     BIGINT        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 idx_l1hash_l1logindex ON bridge_batch_deposit_event_v2 (l1_tx_hash, l1_log_index);
+CREATE INDEX IF NOT EXISTS idx_bbde_batchidx_sender ON bridge_batch_deposit_event_v2 (batch_index, sender);
+CREATE INDEX IF NOT EXISTS idx_bbde_l1_block_number ON bridge_batch_deposit_event_v2 (l1_block_number DESC);
+CREATE INDEX IF NOT EXISTS idx_bbde_l2_block_number ON bridge_batch_deposit_event_v2 (l2_block_number DESC);
+CREATE INDEX IF NOT EXISTS idx_bbde_l1_tx_hash ON bridge_batch_deposit_event_v2 (l1_tx_hash DESC);
+CREATE INDEX IF NOT EXISTS idx_bbde_l2_tx_hash ON bridge_batch_deposit_event_v2 (l2_tx_hash DESC);
+CREATE INDEX IF NOT EXISTS idx_bbde_sender_block_timestamp ON bridge_batch_deposit_event_v2 (sender, block_timestamp DESC);
+
+-- +goose StatementEnd
+
+-- +goose Down
+-- +goose StatementBegin
+DROP TABLE IF EXISTS bridge_batch_deposit_event_v2;
+-- +goose StatementEnd

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

@@ -0,0 +1,35 @@
+package route
+
+import (
+	"time"
+
+	"github.com/gin-contrib/cors"
+	"github.com/gin-gonic/gin"
+	"github.com/prometheus/client_golang/prometheus"
+
+	"scroll-tech/common/observability"
+
+	"scroll-tech/bridge-history-api/internal/config"
+	"scroll-tech/bridge-history-api/internal/controller/api"
+)
+
+// Route routes the APIs
+func Route(router *gin.Engine, conf *config.Config, reg prometheus.Registerer) {
+	router.Use(cors.New(cors.Config{
+		AllowOrigins:     []string{"*"},
+		AllowMethods:     []string{"GET", "POST"},
+		AllowHeaders:     []string{"Origin", "Content-Type", "Authorization"},
+		AllowCredentials: true,
+		MaxAge:           12 * time.Hour,
+	}))
+
+	observability.Use(router, "bridge_history_api", reg)
+
+	r := router.Group("api/")
+
+	r.GET("/txs", api.TxsByAddressCtl.GetTxsByAddress)
+	r.GET("/l2/withdrawals", api.L2WithdrawalsByAddressCtl.GetL2WithdrawalsByAddress)
+	r.GET("/l2/unclaimed/withdrawals", api.L2UnclaimedWithdrawalsByAddressCtl.GetL2UnclaimedWithdrawalsByAddress)
+
+	r.POST("/txsbyhashes", api.TxsByHashesCtl.PostQueryTxsByHashes)
+}

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

@@ -0,0 +1,94 @@
+package types
+
+// TxStatusType represents the status of a transaction.
+type TxStatusType int
+
+// Constants for TxStatusType.
+const (
+	// TxStatusTypeSent is one of the initial statuses for cross-chain messages.
+	// It is used as the default value to prevent overwriting the transaction status in scenarios where the message status might change
+	// from a later status (e.g., relayed) back to "sent".
+	// Example flow (L1 -> L2 message, and L1 fetcher is slower than L2 fetcher):
+	// 1. The relayed message is first tracked and processed, setting tx_status to TxStatusTypeRelayed.
+	// 2. The sent message is later processed (same cross-chain message), the tx_status should not over-write TxStatusTypeRelayed.
+	TxStatusTypeSent           TxStatusType = iota
+	TxStatusTypeSentTxReverted              // Not track message hash, thus will not be processed again anymore.
+	TxStatusTypeRelayed                     // Terminal status.
+	// TxStatusTypeFailedRelayed Retry: this often occurs due to an out of gas (OOG) issue if the transaction was initiated via the frontend.
+	TxStatusTypeFailedRelayed
+	// TxStatusTypeRelayTxReverted Retry: this often occurs due to an out of gas (OOG) issue if the transaction was initiated via the frontend.
+	TxStatusTypeRelayTxReverted
+	TxStatusTypeSkipped
+	TxStatusTypeDropped // Terminal status.
+
+	// TxStatusBridgeBatchDeposit use deposit token to bridge batch deposit contract
+	TxStatusBridgeBatchDeposit
+	// TxStatusBridgeBatchDistribute bridge batch deposit contract distribute tokens to user success
+	TxStatusBridgeBatchDistribute
+	// TxStatusBridgeBatchDistributeFailed bridge batch deposit contract distribute tokens to user failed
+	TxStatusBridgeBatchDistributeFailed
+)
+
+// TokenType represents the type of token.
+type TokenType int
+
+// Constants for TokenType.
+const (
+	TokenTypeUnknown TokenType = iota
+	TokenTypeETH
+	TokenTypeERC20
+	TokenTypeERC721
+	TokenTypeERC1155
+)
+
+// MessageType represents the type of message.
+type MessageType int
+
+// Constants for MessageType.
+const (
+	MessageTypeUnknown MessageType = iota
+	MessageTypeL1SentMessage
+	MessageTypeL2SentMessage
+	MessageTypeL1BatchDeposit
+)
+
+// RollupStatusType represents the status of a rollup.
+type RollupStatusType int
+
+// Constants for RollupStatusType.
+const (
+	RollupStatusTypeUnknown   RollupStatusType = iota
+	RollupStatusTypeFinalized                  // only batch finalized status is used.
+)
+
+// MessageQueueEventType represents the type of message queue event.
+type MessageQueueEventType int
+
+// Constants for MessageQueueEventType.
+const (
+	MessageQueueEventTypeUnknown MessageQueueEventType = iota
+	MessageQueueEventTypeQueueTransaction
+	MessageQueueEventTypeDequeueTransaction
+	MessageQueueEventTypeDropTransaction
+	MessageQueueEventTypeResetDequeuedTransaction
+)
+
+// BatchStatusType represents the type of batch status.
+type BatchStatusType int
+
+// Constants for BatchStatusType.
+const (
+	BatchStatusTypeUnknown BatchStatusType = iota
+	BatchStatusTypeCommitted
+	BatchStatusTypeReverted
+	BatchStatusTypeFinalized
+)
+
+// UpdateStatusType represents the whether batch info is updated in message table.
+type UpdateStatusType int
+
+// Constants for UpdateStatusType.
+const (
+	UpdateStatusTypeUnupdated UpdateStatusType = iota
+	UpdateStatusTypeUpdated
+)

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

@@ -0,0 +1,131 @@
+package types
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+)
+
+const (
+	// Success indicates that the operation was successful.
+	Success = 0
+	// InternalServerError represents a fatal error occurring on the server.
+	InternalServerError = 500
+	// ErrParameterInvalidNo represents an error when the parameters are invalid.
+	ErrParameterInvalidNo = 40001
+	// ErrGetL2ClaimableWithdrawalsError represents an error when trying to get L2 claimable withdrawal transactions.
+	ErrGetL2ClaimableWithdrawalsError = 40002
+	// ErrGetL2WithdrawalsError represents an error when trying to get L2 withdrawal transactions by address.
+	ErrGetL2WithdrawalsError = 40003
+	// ErrGetTxsError represents an error when trying to get transactions by address.
+	ErrGetTxsError = 40004
+	// ErrGetTxsByHashError represents an error when trying to get transactions by hash list.
+	ErrGetTxsByHashError = 40005
+)
+
+// QueryByAddressRequest the request parameter of address api
+type QueryByAddressRequest struct {
+	Address  string `form:"address" binding:"required"`
+	Page     uint64 `form:"page" binding:"required,min=1"`
+	PageSize uint64 `form:"page_size" binding:"required,min=1,max=100"`
+}
+
+// QueryByHashRequest the request parameter of hash api
+type QueryByHashRequest struct {
+	Txs []string `json:"txs" binding:"required,min=1,max=100"`
+}
+
+// ResultData contains return txs and total
+type ResultData struct {
+	Results []*TxHistoryInfo `json:"results"`
+	Total   uint64           `json:"total"`
+}
+
+// Response the response schema
+type Response struct {
+	ErrCode int         `json:"errcode"`
+	ErrMsg  string      `json:"errmsg"`
+	Data    interface{} `json:"data"`
+}
+
+// CounterpartChainTx is the schema of counterpart chain tx info
+type CounterpartChainTx struct {
+	Hash        string `json:"hash"`
+	BlockNumber uint64 `json:"block_number"`
+}
+
+// ClaimInfo is the schema of tx claim info
+type ClaimInfo struct {
+	From      string         `json:"from"`
+	To        string         `json:"to"`
+	Value     string         `json:"value"`
+	Nonce     string         `json:"nonce"`
+	Message   string         `json:"message"`
+	Proof     L2MessageProof `json:"proof"`
+	Claimable bool           `json:"claimable"`
+}
+
+// L2MessageProof is the schema of L2 message proof
+type L2MessageProof struct {
+	BatchIndex  string `json:"batch_index"`
+	MerkleProof string `json:"merkle_proof"`
+}
+
+// TxHistoryInfo the schema of tx history infos
+type TxHistoryInfo struct {
+	Hash               string              `json:"hash"`
+	ReplayTxHash       string              `json:"replay_tx_hash"`
+	RefundTxHash       string              `json:"refund_tx_hash"`
+	MessageHash        string              `json:"message_hash"`
+	TokenType          TokenType           `json:"token_type"`    // 0: unknown, 1: eth, 2: erc20, 3: erc721, 4: erc1155
+	TokenIDs           []string            `json:"token_ids"`     // only for erc721 and erc1155
+	TokenAmounts       []string            `json:"token_amounts"` // for eth and erc20, the length is 1, for erc721 and erc1155, the length could be > 1
+	MessageType        MessageType         `json:"message_type"`  // 0: unknown, 1: layer 1 message, 2: layer 2 message
+	L1TokenAddress     string              `json:"l1_token_address"`
+	L2TokenAddress     string              `json:"l2_token_address"`
+	BlockNumber        uint64              `json:"block_number"`
+	TxStatus           TxStatusType        `json:"tx_status"` // 0: sent, 1: sent failed, 2: relayed, 3: failed relayed, 4: relayed reverted, 5: skipped, 6: dropped
+	CounterpartChainTx *CounterpartChainTx `json:"counterpart_chain_tx"`
+	ClaimInfo          *ClaimInfo          `json:"claim_info"`
+	BlockTimestamp     uint64              `json:"block_timestamp"`
+	BatchDepositFee    string              `json:"batch_deposit_fee"` // only for bridge batch deposit
+}
+
+// RenderJSON renders response with json
+func RenderJSON(ctx *gin.Context, errCode int, err error, data interface{}) {
+	var errMsg string
+	if err != nil {
+		errMsg = err.Error()
+	}
+	renderData := Response{
+		ErrCode: errCode,
+		ErrMsg:  errMsg,
+		Data:    data,
+	}
+	ctx.JSON(http.StatusOK, renderData)
+}
+
+// RenderSuccess renders success response with json
+func RenderSuccess(ctx *gin.Context, data interface{}) {
+	RenderJSON(ctx, Success, nil, data)
+}
+
+// RenderFailure renders failure response with json
+func RenderFailure(ctx *gin.Context, errCode int, err error) {
+	RenderJSON(ctx, errCode, err, nil)
+}
+
+// RenderFatal renders fatal response with json
+func RenderFatal(ctx *gin.Context, err error) {
+	var errMsg string
+	if err != nil {
+		errMsg = err.Error()
+	}
+	renderData := Response{
+		ErrCode: InternalServerError,
+		ErrMsg:  errMsg,
+		Data:    nil,
+	}
+	ctx.Set("errcode", InternalServerError)
+	ctx.JSON(http.StatusInternalServerError, renderData)
+}

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

@@ -0,0 +1,250 @@
+package utils
+
+import (
+	"context"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"math/big"
+	"strings"
+
+	"github.com/scroll-tech/go-ethereum/accounts/abi"
+	"github.com/scroll-tech/go-ethereum/common"
+	"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"
+	"golang.org/x/sync/errgroup"
+
+	backendabi "scroll-tech/bridge-history-api/abi"
+)
+
+// Keccak2 compute the keccack256 of two concatenations of bytes32
+func Keccak2(a common.Hash, b common.Hash) common.Hash {
+	return common.BytesToHash(crypto.Keccak256(append(a.Bytes()[:], b.Bytes()[:]...)))
+}
+
+// GetBlockNumber get the current block number minus the confirmations
+func GetBlockNumber(ctx context.Context, client *ethclient.Client, confirmations uint64) (uint64, error) {
+	number, err := client.BlockNumber(ctx)
+	if err != nil || number <= confirmations {
+		return 0, err
+	}
+	number = number - confirmations
+	return number, nil
+}
+
+// UnpackLog unpacks a retrieved log into the provided output structure.
+// @todo: add unit test.
+func UnpackLog(c *abi.ABI, out interface{}, event string, log types.Log) error {
+	if log.Topics[0] != c.Events[event].ID {
+		return errors.New("event signature mismatch")
+	}
+	if len(log.Data) > 0 {
+		if err := c.UnpackIntoInterface(out, event, log.Data); err != nil {
+			return err
+		}
+	}
+	var indexed abi.Arguments
+	for _, arg := range c.Events[event].Inputs {
+		if arg.Indexed {
+			indexed = append(indexed, arg)
+		}
+	}
+	return abi.ParseTopics(out, indexed, log.Topics[1:])
+}
+
+// ComputeMessageHash compute the message hash
+func ComputeMessageHash(
+	sender common.Address,
+	target common.Address,
+	value *big.Int,
+	messageNonce *big.Int,
+	message []byte,
+) common.Hash {
+	data, _ := backendabi.IL2ScrollMessengerABI.Pack("relayMessage", sender, target, value, messageNonce, message)
+	return common.BytesToHash(crypto.Keccak256(data))
+}
+
+// GetBatchVersionAndBlockRangeFromCalldata find the block range from calldata, both inclusive.
+func GetBatchVersionAndBlockRangeFromCalldata(txData []byte) (uint8, uint64, uint64, error) {
+	const methodIDLength = 4
+	if len(txData) < methodIDLength {
+		return 0, 0, 0, fmt.Errorf("transaction data is too short, length of tx data: %v, minimum length required: %v", len(txData), methodIDLength)
+	}
+	method, err := backendabi.IScrollChainABI.MethodById(txData[:methodIDLength])
+	if err != nil {
+		return 0, 0, 0, fmt.Errorf("failed to get method by ID, ID: %v, err: %w", txData[:methodIDLength], err)
+	}
+	values, err := method.Inputs.Unpack(txData[methodIDLength:])
+	if err != nil {
+		return 0, 0, 0, fmt.Errorf("failed to unpack transaction data using ABI, tx data: %v, err: %w", txData, err)
+	}
+
+	var chunks [][]byte
+	var version uint8
+
+	if method.Name == "importGenesisBatch" {
+		return 0, 0, 0, nil
+	} else if method.Name == "commitBatch" {
+		type commitBatchArgs struct {
+			Version                uint8
+			ParentBatchHeader      []byte
+			Chunks                 [][]byte
+			SkippedL1MessageBitmap []byte
+		}
+
+		var args commitBatchArgs
+		if err = method.Inputs.Copy(&args, values); err != nil {
+			return 0, 0, 0, fmt.Errorf("failed to decode calldata into commitBatch args, values: %+v, err: %w", values, err)
+		}
+
+		chunks = args.Chunks
+		version = args.Version
+	} else if method.Name == "commitBatchWithBlobProof" {
+		type commitBatchWithBlobProofArgs struct {
+			Version                uint8
+			ParentBatchHeader      []byte
+			Chunks                 [][]byte
+			SkippedL1MessageBitmap []byte
+			BlobDataProof          []byte
+		}
+
+		var args commitBatchWithBlobProofArgs
+		if err = method.Inputs.Copy(&args, values); err != nil {
+			return 0, 0, 0, fmt.Errorf("failed to decode calldata into commitBatchWithBlobProofArgs args, values: %+v, err: %w", values, err)
+		}
+
+		chunks = args.Chunks
+		version = args.Version
+	} else if method.Name == "commitBatches" || method.Name == "commitAndFinalizeBatch" {
+		if len(values) < 3 {
+			return 0, 0, 0, fmt.Errorf("insufficient arguments for %s, expected 3, got %d", method.Name, len(values))
+		}
+
+		var ok bool
+		version, ok = values[0].(uint8)
+		if !ok {
+			return 0, 0, 0, fmt.Errorf("invalid version type: %T", values[0])
+		}
+		return version, 0, 0, nil
+	}
+
+	var startBlock uint64
+	var finishBlock uint64
+
+	// decode blocks from chunk and assume that there's no empty chunk
+	// |   1 byte   | 60 bytes | ... | 60 bytes |
+	// | num blocks |  block 1 | ... |  block n |
+	if len(chunks) == 0 {
+		return 0, 0, 0, errors.New("invalid chunks")
+	}
+	chunk := chunks[0]
+	block := chunk[1:61] // first block in chunk
+	startBlock = binary.BigEndian.Uint64(block[0:8])
+
+	chunk = chunks[len(chunks)-1]
+	lastBlockIndex := int(chunk[0]) - 1
+	block = chunk[1+lastBlockIndex*60 : 1+lastBlockIndex*60+60] // last block in chunk
+	finishBlock = binary.BigEndian.Uint64(block[0:8])
+
+	return version, startBlock, finishBlock, err
+}
+
+// GetParentBatchHashFromCalldata gets the parent batch hash from calldata.
+// It only supports commitBatches and commitAndFinalizeBatch, which only accept batches >= v7.
+func GetParentBatchHashFromCalldata(txData []byte) (common.Hash, error) {
+	const methodIDLength = 4
+	if len(txData) < methodIDLength {
+		return common.Hash{}, fmt.Errorf("transaction data is too short, length of tx data: %v, minimum length required: %v", len(txData), methodIDLength)
+	}
+	method, err := backendabi.IScrollChainABI.MethodById(txData[:methodIDLength])
+	if err != nil {
+		return common.Hash{}, fmt.Errorf("failed to get method by ID, ID: %v, err: %w", txData[:methodIDLength], err)
+	}
+	values, err := method.Inputs.Unpack(txData[methodIDLength:])
+	if err != nil {
+		return common.Hash{}, fmt.Errorf("failed to unpack transaction data using ABI, tx data: %v, err: %w", txData, err)
+	}
+
+	if method.Name == "commitBatches" || method.Name == "commitAndFinalizeBatch" {
+		if len(values) < 3 {
+			return common.Hash{}, fmt.Errorf("insufficient arguments for %s, expected 3, got %d", method.Name, len(values))
+		}
+		parentBatchHash, ok := values[1].([32]byte)
+		if !ok {
+			return common.Hash{}, fmt.Errorf("invalid parentBatchHash type: %T", values[1])
+		}
+		return common.BytesToHash(parentBatchHash[:]), nil
+	}
+	return common.Hash{}, fmt.Errorf("method %s does not support parent batch header", method.Name)
+}
+
+// GetBlocksInRange gets a batch of blocks for a block range [start, end] inclusive.
+func GetBlocksInRange(ctx context.Context, cli *ethclient.Client, start, end uint64) ([]*types.Block, error) {
+	var (
+		eg          errgroup.Group
+		blocks      = make([]*types.Block, end-start+1)
+		concurrency = 32
+		sem         = make(chan struct{}, concurrency)
+	)
+
+	for i := start; i <= end; i++ {
+		sem <- struct{}{} // Acquire a slot in the semaphore
+		blockNum := int64(i)
+		index := i - start
+		eg.Go(func() error {
+			defer func() { <-sem }() // Release the slot when done
+			block, err := cli.BlockByNumber(ctx, big.NewInt(blockNum))
+			if err != nil {
+				log.Error("Failed to fetch block number", "number", blockNum, "error", err)
+				return err
+			}
+			blocks[index] = block
+			return nil
+		})
+	}
+
+	if err := eg.Wait(); err != nil {
+		log.Error("Error waiting for block fetching routines", "error", err)
+		return nil, err
+	}
+	return blocks, nil
+}
+
+// ConvertBigIntArrayToString convert the big int array to string
+func ConvertBigIntArrayToString(array []*big.Int) string {
+	stringArray := make([]string, len(array))
+	for i, num := range array {
+		stringArray[i] = num.String()
+	}
+
+	result := strings.Join(stringArray, ", ")
+	return result
+}
+
+// ConvertStringToStringArray takes a string with values separated by commas and returns a slice of strings
+func ConvertStringToStringArray(s string) []string {
+	if s == "" {
+		return []string{}
+	}
+	stringParts := strings.Split(s, ",")
+	for i, part := range stringParts {
+		stringParts[i] = strings.TrimSpace(part)
+	}
+	return stringParts
+}
+
+// GetSkippedQueueIndices gets the skipped queue indices
+func GetSkippedQueueIndices(startIndex uint64, skippedBitmap *big.Int) []uint64 {
+	var indices []uint64
+	for i := 0; i < 256; i++ {
+		index := startIndex + uint64(i)
+		bit := new(big.Int).Rsh(skippedBitmap, uint(i))
+		if bit.Bit(0) == 0 {
+			continue
+		}
+		indices = append(indices, index)
+	}
+	return indices
+}

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

@@ -1,12 +1,10 @@
-package messageproof
+package utils
 
 import (
-	"github.com/ethereum/go-ethereum/common"
-
-	"bridge-history-api/utils"
+	"github.com/scroll-tech/go-ethereum/common"
 )
 
-// MaxHeight is the maixium possible height of withdraw trie
+// MaxHeight is the maximum possible height of withdrawal trie
 const MaxHeight = 40
 
 // WithdrawTrie is an append only merkle trie
@@ -27,7 +25,7 @@ func NewWithdrawTrie() *WithdrawTrie {
 
 	zeroes[0] = common.Hash{}
 	for i := 1; i < MaxHeight; i++ {
-		zeroes[i] = utils.Keccak2(zeroes[i-1], zeroes[i-1])
+		zeroes[i] = Keccak2(zeroes[i-1], zeroes[i-1])
 	}
 
 	return &WithdrawTrie{
@@ -40,14 +38,15 @@ func NewWithdrawTrie() *WithdrawTrie {
 
 // Initialize will initialize the merkle trie with rightest leaf node
 func (w *WithdrawTrie) Initialize(currentMessageNonce uint64, msgHash common.Hash, proofBytes []byte) {
-	proof := DecodeBytesToMerkleProof(proofBytes)
-	branches := RecoverBranchFromProof(proof, currentMessageNonce, msgHash)
+	proof := decodeBytesToMerkleProof(proofBytes)
+	branches := recoverBranchFromProof(proof, currentMessageNonce, msgHash)
 	w.height = len(proof)
 	w.branches = branches
 	w.NextMessageNonce = currentMessageNonce + 1
 }
 
 // AppendMessages appends a list of new messages as leaf nodes to the rightest of the tree and returns the proofs for all messages.
+// The function correctly returns the proofs for the entire tree after all messages have been inserted, not the individual proofs after each insertion.
 func (w *WithdrawTrie) AppendMessages(hashes []common.Hash) [][]byte {
 	length := len(hashes)
 	if length == 0 {
@@ -87,7 +86,7 @@ func (w *WithdrawTrie) AppendMessages(hashes []common.Hash) [][]byte {
 			cache[h][maxIndex^1] = w.zeroes[h]
 		}
 		for i := minIndex; i <= maxIndex; i += 2 {
-			cache[h+1][i>>1] = utils.Keccak2(cache[h][i], cache[h][i^1])
+			cache[h+1][i>>1] = Keccak2(cache[h][i], cache[h][i^1])
 		}
 		minIndex >>= 1
 		maxIndex >>= 1
@@ -95,7 +94,7 @@ func (w *WithdrawTrie) AppendMessages(hashes []common.Hash) [][]byte {
 
 	// update branches using hashes one by one
 	for i := 0; i < length; i++ {
-		proof := UpdateBranchWithNewMessage(w.zeroes, w.branches, w.NextMessageNonce, hashes[i])
+		proof := updateBranchWithNewMessage(w.zeroes, w.branches, w.NextMessageNonce, hashes[i])
 		w.NextMessageNonce++
 		w.height = len(proof)
 	}
@@ -109,7 +108,7 @@ func (w *WithdrawTrie) AppendMessages(hashes []common.Hash) [][]byte {
 			merkleProof = append(merkleProof, cache[h][index^1])
 			index >>= 1
 		}
-		proofs[i] = EncodeMerkleProofToBytes(merkleProof)
+		proofs[i] = encodeMerkleProofToBytes(merkleProof)
 	}
 
 	return proofs
@@ -123,8 +122,8 @@ func (w *WithdrawTrie) MessageRoot() common.Hash {
 	return w.branches[w.height]
 }
 
-// DecodeBytesToMerkleProof transfer byte array to bytes32 array. The caller should make sure the length is matched.
-func DecodeBytesToMerkleProof(proofBytes []byte) []common.Hash {
+// decodeBytesToMerkleProof transfer byte array to bytes32 array. The caller should make sure the length is matched.
+func decodeBytesToMerkleProof(proofBytes []byte) []common.Hash {
 	proof := make([]common.Hash, len(proofBytes)/32)
 	for i := 0; i < len(proofBytes); i += 32 {
 		proof[i/32] = common.BytesToHash(proofBytes[i : i+32])
@@ -132,8 +131,8 @@ func DecodeBytesToMerkleProof(proofBytes []byte) []common.Hash {
 	return proof
 }
 
-// EncodeMerkleProofToBytes transfer byte32 array to byte array by concatenation.
-func EncodeMerkleProofToBytes(proof []common.Hash) []byte {
+// encodeMerkleProofToBytes transfer byte32 array to byte array by concatenation.
+func encodeMerkleProofToBytes(proof []common.Hash) []byte {
 	var proofBytes []byte
 	for i := 0; i < len(proof); i++ {
 		proofBytes = append(proofBytes, proof[i][:]...)
@@ -141,8 +140,8 @@ func EncodeMerkleProofToBytes(proof []common.Hash) []byte {
 	return proofBytes
 }
 
-// UpdateBranchWithNewMessage update the branches to latest with new message and return the merkle proof for the message.
-func UpdateBranchWithNewMessage(zeroes []common.Hash, branches []common.Hash, index uint64, msgHash common.Hash) []common.Hash {
+// updateBranchWithNewMessage update the branches to latest with new message and return the merkle proof for the message.
+func updateBranchWithNewMessage(zeroes []common.Hash, branches []common.Hash, index uint64, msgHash common.Hash) []common.Hash {
 	root := msgHash
 	var merkleProof []common.Hash
 	var height uint64
@@ -152,10 +151,10 @@ func UpdateBranchWithNewMessage(zeroes []common.Hash, branches []common.Hash, in
 			branches[height] = root
 			merkleProof = append(merkleProof, zeroes[height])
 			// it's a left child, the right child must be null
-			root = utils.Keccak2(root, zeroes[height])
+			root = Keccak2(root, zeroes[height])
 		} else {
 			// it's a right child, use previously computed hash
-			root = utils.Keccak2(branches[height], root)
+			root = Keccak2(branches[height], root)
 			merkleProof = append(merkleProof, branches[height])
 		}
 		index >>= 1
@@ -164,8 +163,8 @@ func UpdateBranchWithNewMessage(zeroes []common.Hash, branches []common.Hash, in
 	return merkleProof
 }
 
-// RecoverBranchFromProof will recover latest branches from merkle proof and message hash
-func RecoverBranchFromProof(proof []common.Hash, index uint64, msgHash common.Hash) []common.Hash {
+// recoverBranchFromProof will recover latest branches from merkle proof and message hash
+func recoverBranchFromProof(proof []common.Hash, index uint64, msgHash common.Hash) []common.Hash {
 	branches := make([]common.Hash, 64)
 	root := msgHash
 	var height uint64
@@ -173,11 +172,11 @@ func RecoverBranchFromProof(proof []common.Hash, index uint64, msgHash common.Ha
 		if index%2 == 0 {
 			branches[height] = root
 			// it's a left child, the right child must be null
-			root = utils.Keccak2(root, proof[height])
+			root = Keccak2(root, proof[height])
 		} else {
 			// it's a right child, use previously computed hash
 			branches[height] = proof[height]
-			root = utils.Keccak2(proof[height], root)
+			root = Keccak2(proof[height], root)
 		}
 		index >>= 1
 	}

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

@@ -1,13 +1,11 @@
-package messageproof
+package utils
 
 import (
 	"math/big"
 	"testing"
 
-	"github.com/ethereum/go-ethereum/common"
+	"github.com/scroll-tech/go-ethereum/common"
 	"github.com/stretchr/testify/assert"
-
-	"bridge-history-api/utils"
 )
 
 func TestUpdateBranchWithNewMessage(t *testing.T) {
@@ -15,32 +13,32 @@ func TestUpdateBranchWithNewMessage(t *testing.T) {
 	branches := make([]common.Hash, 64)
 	zeroes[0] = common.Hash{}
 	for i := 1; i < 64; i++ {
-		zeroes[i] = utils.Keccak2(zeroes[i-1], zeroes[i-1])
+		zeroes[i] = Keccak2(zeroes[i-1], zeroes[i-1])
 	}
 
-	UpdateBranchWithNewMessage(zeroes, branches, 0, common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000001"))
+	updateBranchWithNewMessage(zeroes, branches, 0, common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000001"))
 	if branches[0] != common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000001") {
 		t.Fatalf("Invalid root, want %s, got %s", "0x0000000000000000000000000000000000000000000000000000000000000001", branches[0].Hex())
 	}
 
-	UpdateBranchWithNewMessage(zeroes, branches, 1, common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000002"))
+	updateBranchWithNewMessage(zeroes, branches, 1, common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000002"))
 	if branches[1] != common.HexToHash("0xe90b7bceb6e7df5418fb78d8ee546e97c83a08bbccc01a0644d599ccd2a7c2e0") {
 		t.Fatalf("Invalid root, want %s, got %s", "0xe90b7bceb6e7df5418fb78d8ee546e97c83a08bbccc01a0644d599ccd2a7c2e0", branches[1].Hex())
 	}
 
-	UpdateBranchWithNewMessage(zeroes, branches, 2, common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000003"))
+	updateBranchWithNewMessage(zeroes, branches, 2, common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000003"))
 	if branches[2] != common.HexToHash("0x222ff5e0b5877792c2bc1670e2ccd0c2c97cd7bb1672a57d598db05092d3d72c") {
 		t.Fatalf("Invalid root, want %s, got %s", "0x222ff5e0b5877792c2bc1670e2ccd0c2c97cd7bb1672a57d598db05092d3d72c", branches[2].Hex())
 	}
 
-	UpdateBranchWithNewMessage(zeroes, branches, 3, common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000004"))
+	updateBranchWithNewMessage(zeroes, branches, 3, common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000004"))
 	if branches[2] != common.HexToHash("0xa9bb8c3f1f12e9aa903a50c47f314b57610a3ab32f2d463293f58836def38d36") {
 		t.Fatalf("Invalid root, want %s, got %s", "0xa9bb8c3f1f12e9aa903a50c47f314b57610a3ab32f2d463293f58836def38d36", branches[2].Hex())
 	}
 }
 
 func TestDecodeEncodeMerkleProof(t *testing.T) {
-	proof := DecodeBytesToMerkleProof(common.Hex2Bytes("2ebffc1a6671c51e30777a680904b103992630ec995b6e6ff76a04d5259d49012ebffc1a6671c51e30777a680904b103992630ec995b6e6ff76a04d5259d49022ebffc1a6671c51e30777a680904b103992630ec995b6e6ff76a04d5259d49032ebffc1a6671c51e30777a680904b103992630ec995b6e6ff76a04d5259d4904"))
+	proof := decodeBytesToMerkleProof(common.Hex2Bytes("2ebffc1a6671c51e30777a680904b103992630ec995b6e6ff76a04d5259d49012ebffc1a6671c51e30777a680904b103992630ec995b6e6ff76a04d5259d49022ebffc1a6671c51e30777a680904b103992630ec995b6e6ff76a04d5259d49032ebffc1a6671c51e30777a680904b103992630ec995b6e6ff76a04d5259d4904"))
 	if len(proof) != 4 {
 		t.Fatalf("proof length mismatch, want %d, got %d", 4, len(proof))
 	}
@@ -57,7 +55,7 @@ func TestDecodeEncodeMerkleProof(t *testing.T) {
 		t.Fatalf("proof[3] mismatch, want %s, got %s", "0x2ebffc1a6671c51e30777a680904b103992630ec995b6e6ff76a04d5259d4904", proof[0].Hex())
 	}
 
-	bytes := EncodeMerkleProofToBytes(proof)
+	bytes := encodeMerkleProofToBytes(proof)
 	if common.Bytes2Hex(bytes) != "2ebffc1a6671c51e30777a680904b103992630ec995b6e6ff76a04d5259d49012ebffc1a6671c51e30777a680904b103992630ec995b6e6ff76a04d5259d49022ebffc1a6671c51e30777a680904b103992630ec995b6e6ff76a04d5259d49032ebffc1a6671c51e30777a680904b103992630ec995b6e6ff76a04d5259d4904" {
 		t.Fatalf("wrong encoded bytes")
 	}
@@ -68,35 +66,35 @@ func TestRecoverBranchFromProof(t *testing.T) {
 	branches := make([]common.Hash, 64)
 	zeroes[0] = common.Hash{}
 	for i := 1; i < 64; i++ {
-		zeroes[i] = utils.Keccak2(zeroes[i-1], zeroes[i-1])
+		zeroes[i] = Keccak2(zeroes[i-1], zeroes[i-1])
 	}
 
-	proof := UpdateBranchWithNewMessage(zeroes, branches, 0, common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000001"))
-	tmpBranches := RecoverBranchFromProof(proof, 0, common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000001"))
+	proof := updateBranchWithNewMessage(zeroes, branches, 0, common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000001"))
+	tmpBranches := recoverBranchFromProof(proof, 0, common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000001"))
 	for i := 0; i < 64; i++ {
 		if tmpBranches[i] != branches[i] {
 			t.Fatalf("Invalid branch, want %s, got %s", branches[i].Hex(), tmpBranches[i].Hex())
 		}
 	}
 
-	proof = UpdateBranchWithNewMessage(zeroes, branches, 1, common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000002"))
-	tmpBranches = RecoverBranchFromProof(proof, 1, common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000002"))
+	proof = updateBranchWithNewMessage(zeroes, branches, 1, common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000002"))
+	tmpBranches = recoverBranchFromProof(proof, 1, common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000002"))
 	for i := 0; i < 64; i++ {
 		if tmpBranches[i] != branches[i] {
 			t.Fatalf("Invalid branch, want %s, got %s", branches[i].Hex(), tmpBranches[i].Hex())
 		}
 	}
 
-	proof = UpdateBranchWithNewMessage(zeroes, branches, 2, common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000003"))
-	tmpBranches = RecoverBranchFromProof(proof, 2, common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000003"))
+	proof = updateBranchWithNewMessage(zeroes, branches, 2, common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000003"))
+	tmpBranches = recoverBranchFromProof(proof, 2, common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000003"))
 	for i := 0; i < 64; i++ {
 		if tmpBranches[i] != branches[i] {
 			t.Fatalf("Invalid branch, want %s, got %s", branches[i].Hex(), tmpBranches[i].Hex())
 		}
 	}
 
-	proof = UpdateBranchWithNewMessage(zeroes, branches, 3, common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000004"))
-	tmpBranches = RecoverBranchFromProof(proof, 3, common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000004"))
+	proof = updateBranchWithNewMessage(zeroes, branches, 3, common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000004"))
+	tmpBranches = recoverBranchFromProof(proof, 3, common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000004"))
 	for i := 0; i < 64; i++ {
 		if tmpBranches[i] != branches[i] {
 			t.Fatalf("Invalid branch, want %s, got %s", branches[i].Hex(), tmpBranches[i].Hex())
@@ -125,7 +123,7 @@ func TestWithdrawTrieOneByOne(t *testing.T) {
 			})
 			assert.Equal(t, withdrawTrie.NextMessageNonce, uint64(i+1))
 			assert.Equal(t, expectedRoot.String(), withdrawTrie.MessageRoot().String())
-			proof := DecodeBytesToMerkleProof(proofBytes[0])
+			proof := decodeBytesToMerkleProof(proofBytes[0])
 			verifiedRoot := verifyMerkleProof(uint64(i), hash, proof)
 			assert.Equal(t, expectedRoot.String(), verifiedRoot.String())
 		}
@@ -166,7 +164,7 @@ func TestWithdrawTrieMultiple(t *testing.T) {
 
 			for i := initial; i <= finish; i++ {
 				hash := common.BigToHash(big.NewInt(int64(i + 1)))
-				proof := DecodeBytesToMerkleProof(proofBytes[i-initial])
+				proof := decodeBytesToMerkleProof(proofBytes[i-initial])
 				verifiedRoot := verifyMerkleProof(uint64(i), hash, proof)
 				assert.Equal(t, expectedRoots[finish].String(), verifiedRoot.String())
 			}
@@ -178,9 +176,9 @@ func verifyMerkleProof(index uint64, leaf common.Hash, proof []common.Hash) comm
 	root := leaf
 	for _, h := range proof {
 		if index%2 == 0 {
-			root = utils.Keccak2(root, h)
+			root = Keccak2(root, h)
 		} else {
-			root = utils.Keccak2(h, root)
+			root = Keccak2(h, root)
 		}
 		index >>= 1
 	}
@@ -200,13 +198,13 @@ func computeMerkleRoot(hashes []common.Hash) common.Hash {
 		var newHashes []common.Hash
 		for i := 0; i < len(hashes); i += 2 {
 			if i+1 < len(hashes) {
-				newHashes = append(newHashes, utils.Keccak2(hashes[i], hashes[i+1]))
+				newHashes = append(newHashes, Keccak2(hashes[i], hashes[i+1]))
 			} else {
-				newHashes = append(newHashes, utils.Keccak2(hashes[i], zeroHash))
+				newHashes = append(newHashes, Keccak2(hashes[i], zeroHash))
 			}
 		}
 		hashes = newHashes
-		zeroHash = utils.Keccak2(zeroHash, zeroHash)
+		zeroHash = Keccak2(zeroHash, zeroHash)
 	}
 	return hashes[0]
 }

bridge-history-api/model/request.go

@@ -1,13 +0,0 @@
-package model
-
-// QueryByAddressRequest the request parameter of address api
-type QueryByAddressRequest struct {
-	Address string `url:"address"`
-	Offset  int    `url:"offset"`
-	Limit   int    `url:"limit"`
-}
-
-// QueryByHashRequest the request parameter of hash api
-type QueryByHashRequest struct {
-	Txs []string `url:"txs"`
-}

bridge-history-api/model/response.go

@@ -1,21 +0,0 @@
-package model
-
-import "bridge-history-api/service"
-
-// Data the return struct of apis
-type Data struct {
-	Result []*service.TxHistoryInfo `json:"result"`
-	Total  uint64                   `json:"total"`
-}
-
-// QueryByAddressResponse the schema of address api response
-type QueryByAddressResponse struct {
-	Message string `json:"message"`
-	Data    *Data  `json:"data"`
-}
-
-// QueryByHashResponse the schema of hash api response
-type QueryByHashResponse struct {
-	Message string `json:"message"`
-	Data    *Data  `json:"data"`
-}

bridge-history-api/service/service.go

@@ -1,238 +0,0 @@
-package service
-
-import (
-	"strconv"
-	"time"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/log"
-
-	"bridge-history-api/db"
-	"bridge-history-api/db/orm"
-)
-
-// Finalized the schema of tx finalized infos
-type Finalized struct {
-	Hash           string     `json:"hash"`
-	Amount         string     `json:"amount"`
-	To             string     `json:"to"` // useless
-	IsL1           bool       `json:"isL1"`
-	BlockNumber    uint64     `json:"blockNumber"`
-	BlockTimestamp *time.Time `json:"blockTimestamp"` // uselesss
-}
-
-// UserClaimInfo the schema of tx claim infos
-type UserClaimInfo struct {
-	From       string `json:"from"`
-	To         string `json:"to"`
-	Value      string `json:"value"`
-	Nonce      string `json:"nonce"`
-	BatchHash  string `json:"batch_hash"`
-	Message    string `json:"message"`
-	Proof      string `json:"proof"`
-	BatchIndex string `json:"batch_index"`
-}
-
-// TxHistoryInfo the schema of tx history infos
-type TxHistoryInfo struct {
-	Hash           string         `json:"hash"`
-	Amount         string         `json:"amount"`
-	To             string         `json:"to"` // useless
-	IsL1           bool           `json:"isL1"`
-	BlockNumber    uint64         `json:"blockNumber"`
-	BlockTimestamp *time.Time     `json:"blockTimestamp"` // useless
-	FinalizeTx     *Finalized     `json:"finalizeTx"`
-	ClaimInfo      *UserClaimInfo `json:"claimInfo"`
-	CreatedAt      *time.Time     `json:"createdTime"`
-}
-
-// HistoryService example service.
-type HistoryService interface {
-	GetTxsByAddress(address common.Address, offset int64, limit int64) ([]*TxHistoryInfo, uint64, error)
-	GetTxsByHashes(hashes []string) ([]*TxHistoryInfo, error)
-	GetClaimableTxsByAddress(address common.Address, offset int64, limit int64) ([]*TxHistoryInfo, uint64, error)
-}
-
-// NewHistoryService returns a service backed with a "db"
-func NewHistoryService(db db.OrmFactory) HistoryService {
-	service := &historyBackend{db: db, prefix: "Scroll-Bridge-History-Server"}
-	return service
-}
-
-type historyBackend struct {
-	prefix string
-	db     db.OrmFactory
-}
-
-// GetCrossTxClaimInfo get UserClaimInfos by address
-func GetCrossTxClaimInfo(msgHash string, db db.OrmFactory) *UserClaimInfo {
-	l2sentMsg, err := db.GetL2SentMsgByHash(msgHash)
-	if err != nil {
-		log.Debug("GetCrossTxClaimInfo failed", "error", err)
-		return &UserClaimInfo{}
-	}
-	batch, err := db.GetRollupBatchByIndex(l2sentMsg.BatchIndex)
-	if err != nil {
-		log.Debug("GetCrossTxClaimInfo failed", "error", err)
-		return &UserClaimInfo{}
-	}
-	return &UserClaimInfo{
-		From:       l2sentMsg.Sender,
-		To:         l2sentMsg.Target,
-		Value:      l2sentMsg.Value,
-		Nonce:      strconv.FormatUint(l2sentMsg.Nonce, 10),
-		Message:    l2sentMsg.MsgData,
-		Proof:      "0x" + l2sentMsg.MsgProof,
-		BatchHash:  batch.BatchHash,
-		BatchIndex: strconv.FormatUint(l2sentMsg.BatchIndex, 10),
-	}
-
-}
-
-func updateCrossTxHash(msgHash string, txInfo *TxHistoryInfo, db db.OrmFactory) {
-	relayed, err := db.GetRelayedMsgByHash(msgHash)
-	if err != nil {
-		log.Error("updateCrossTxHash failed", "error", err)
-		return
-	}
-	if relayed == nil {
-		return
-	}
-	if relayed.Layer1Hash != "" {
-		txInfo.FinalizeTx.Hash = relayed.Layer1Hash
-		txInfo.FinalizeTx.BlockNumber = relayed.Height
-		return
-	}
-	if relayed.Layer2Hash != "" {
-		txInfo.FinalizeTx.Hash = relayed.Layer2Hash
-		txInfo.FinalizeTx.BlockNumber = relayed.Height
-		return
-	}
-
-}
-
-// GetClaimableTxsByAddress get all claimable txs under given address
-func (h *historyBackend) GetClaimableTxsByAddress(address common.Address, offset int64, limit int64) ([]*TxHistoryInfo, uint64, error) {
-	var txHistories []*TxHistoryInfo
-	total, err := h.db.GetClaimableL2SentMsgByAddressTotalNum(address.Hex())
-	if err != nil || total == 0 {
-		return txHistories, 0, err
-	}
-	results, err := h.db.GetClaimableL2SentMsgByAddressWithOffset(address.Hex(), offset, limit)
-	if err != nil || len(results) == 0 {
-		return txHistories, 0, err
-	}
-	var msgHashList []string
-	for _, result := range results {
-		msgHashList = append(msgHashList, result.MsgHash)
-	}
-	crossMsgs, err := h.db.GetL2CrossMsgByMsgHashList(msgHashList)
-	// crossMsgs can be empty, because they can be emitted by user directly call contract
-	if err != nil {
-		return txHistories, 0, err
-	}
-	crossMsgMap := make(map[string]*orm.CrossMsg)
-	for _, crossMsg := range crossMsgs {
-		crossMsgMap[crossMsg.MsgHash] = crossMsg
-	}
-	for _, result := range results {
-		txInfo := &TxHistoryInfo{
-			Hash:        result.TxHash,
-			IsL1:        false,
-			BlockNumber: result.Height,
-			FinalizeTx:  &Finalized{},
-			ClaimInfo:   GetCrossTxClaimInfo(result.MsgHash, h.db),
-		}
-		if crossMsg, exist := crossMsgMap[result.MsgHash]; exist {
-			txInfo.Amount = crossMsg.Amount
-			txInfo.To = crossMsg.Target
-			txInfo.BlockTimestamp = crossMsg.Timestamp
-			txInfo.CreatedAt = crossMsg.CreatedAt
-		}
-		txHistories = append(txHistories, txInfo)
-	}
-	return txHistories, total, err
-}
-
-// GetTxsByAddress get all txs under given address
-func (h *historyBackend) GetTxsByAddress(address common.Address, offset int64, limit int64) ([]*TxHistoryInfo, uint64, error) {
-	var txHistories []*TxHistoryInfo
-	total, err := h.db.GetTotalCrossMsgCountByAddress(address.String())
-	if err != nil || total == 0 {
-		return txHistories, 0, err
-	}
-	result, err := h.db.GetCrossMsgsByAddressWithOffset(address.String(), offset, limit)
-
-	if err != nil {
-		return nil, 0, err
-	}
-	for _, msg := range result {
-		txHistory := &TxHistoryInfo{
-			Hash:           msg.Layer1Hash + msg.Layer2Hash,
-			Amount:         msg.Amount,
-			To:             msg.Target,
-			IsL1:           msg.MsgType == int(orm.Layer1Msg),
-			BlockNumber:    msg.Height,
-			BlockTimestamp: msg.Timestamp,
-			CreatedAt:      msg.CreatedAt,
-			FinalizeTx: &Finalized{
-				Hash: "",
-			},
-			ClaimInfo: GetCrossTxClaimInfo(msg.MsgHash, h.db),
-		}
-		updateCrossTxHash(msg.MsgHash, txHistory, h.db)
-		txHistories = append(txHistories, txHistory)
-	}
-	return txHistories, total, nil
-}
-
-// GetTxsByHashes get tx infos under given tx hashes
-func (h *historyBackend) GetTxsByHashes(hashes []string) ([]*TxHistoryInfo, error) {
-	txHistories := make([]*TxHistoryInfo, 0)
-	for _, hash := range hashes {
-		l1result, err := h.db.GetL1CrossMsgByHash(common.HexToHash(hash))
-		if err != nil {
-			return nil, err
-		}
-		if l1result != nil {
-			txHistory := &TxHistoryInfo{
-				Hash:           l1result.Layer1Hash,
-				Amount:         l1result.Amount,
-				To:             l1result.Target,
-				IsL1:           true,
-				BlockNumber:    l1result.Height,
-				BlockTimestamp: l1result.Timestamp,
-				CreatedAt:      l1result.CreatedAt,
-				FinalizeTx: &Finalized{
-					Hash: "",
-				},
-			}
-			updateCrossTxHash(l1result.MsgHash, txHistory, h.db)
-			txHistories = append(txHistories, txHistory)
-			continue
-		}
-		l2result, err := h.db.GetL2CrossMsgByHash(common.HexToHash(hash))
-		if err != nil {
-			return nil, err
-		}
-		if l2result != nil {
-			txHistory := &TxHistoryInfo{
-				Hash:           l2result.Layer2Hash,
-				Amount:         l2result.Amount,
-				To:             l2result.Target,
-				IsL1:           false,
-				BlockNumber:    l2result.Height,
-				BlockTimestamp: l2result.Timestamp,
-				CreatedAt:      l2result.CreatedAt,
-				FinalizeTx: &Finalized{
-					Hash: "",
-				},
-				ClaimInfo: GetCrossTxClaimInfo(l2result.MsgHash, h.db),
-			}
-			updateCrossTxHash(l2result.MsgHash, txHistory, h.db)
-			txHistories = append(txHistories, txHistory)
-			continue
-		}
-	}
-	return txHistories, nil
-}

bridge-history-api/utils/flags.go

@@ -1,69 +0,0 @@
-package utils
-
-import (
-	"github.com/urfave/cli/v2"
-)
-
-var (
-	// CommonFlags is used for app common flags in different modules
-	CommonFlags = []cli.Flag{
-		&ConfigFileFlag,
-		&VerbosityFlag,
-		&LogFileFlag,
-		&LogJSONFormat,
-		&LogDebugFlag,
-		&MetricsEnabled,
-		&MetricsAddr,
-		&MetricsPort,
-	}
-	// ConfigFileFlag load json type config file.
-	ConfigFileFlag = cli.StringFlag{
-		Name:  "config",
-		Usage: "JSON configuration file",
-		Value: "./config.json",
-	}
-	// VerbosityFlag log level.
-	VerbosityFlag = cli.IntFlag{
-		Name:  "verbosity",
-		Usage: "Logging verbosity: 0=silent, 1=error, 2=warn, 3=info, 4=debug, 5=detail",
-		Value: 3,
-	}
-	// LogFileFlag decides where the logger output is sent. If this flag is left
-	// empty, it will log to stdout.
-	LogFileFlag = cli.StringFlag{
-		Name:  "log.file",
-		Usage: "Tells the module where to write log entries",
-	}
-	// LogJSONFormat decides the log format is json or not
-	LogJSONFormat = cli.BoolFlag{
-		Name:  "log.json",
-		Usage: "Tells the module whether log format is json or not",
-		Value: true,
-	}
-	// LogDebugFlag make log messages with call-site location
-	LogDebugFlag = cli.BoolFlag{
-		Name:  "log.debug",
-		Usage: "Prepends log messages with call-site location (file and line number)",
-	}
-	// MetricsEnabled enable metrics collection and reporting
-	MetricsEnabled = cli.BoolFlag{
-		Name:     "metrics",
-		Usage:    "Enable metrics collection and reporting",
-		Category: "METRICS",
-		Value:    false,
-	}
-	// MetricsAddr is listening address of Metrics reporting server
-	MetricsAddr = cli.StringFlag{
-		Name:     "metrics.addr",
-		Usage:    "Metrics reporting server listening address",
-		Category: "METRICS",
-		Value:    "127.0.0.1",
-	}
-	// MetricsPort is listening port of Metrics reporting server
-	MetricsPort = cli.IntFlag{
-		Name:     "metrics.port",
-		Usage:    "Metrics reporting server listening port",
-		Category: "METRICS",
-		Value:    6060,
-	}
-)

bridge-history-api/utils/logger.go

@@ -1,43 +0,0 @@
-package utils
-
-import (
-	"io"
-	"os"
-	"path/filepath"
-
-	"github.com/ethereum/go-ethereum/cmd/utils"
-	"github.com/ethereum/go-ethereum/log"
-	"github.com/mattn/go-colorable"
-	"github.com/mattn/go-isatty"
-	"github.com/urfave/cli/v2"
-)
-
-// LogSetup is for setup logger
-func LogSetup(ctx *cli.Context) error {
-	var ostream log.Handler
-	if logFile := ctx.String(LogFileFlag.Name); len(logFile) > 0 {
-		fp, err := os.OpenFile(filepath.Clean(logFile), os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0600)
-		if err != nil {
-			utils.Fatalf("Failed to open log file", "err", err)
-		}
-		if ctx.Bool(LogJSONFormat.Name) {
-			ostream = log.StreamHandler(io.Writer(fp), log.JSONFormat())
-		} else {
-			ostream = log.StreamHandler(io.Writer(fp), log.TerminalFormat(true))
-		}
-	} else {
-		output := io.Writer(os.Stderr)
-		usecolor := (isatty.IsTerminal(os.Stderr.Fd()) || isatty.IsCygwinTerminal(os.Stderr.Fd())) && os.Getenv("TERM") != "dumb"
-		if usecolor {
-			output = colorable.NewColorableStderr()
-		}
-		ostream = log.StreamHandler(output, log.TerminalFormat(usecolor))
-	}
-	// show the call file and line number
-	log.PrintOrigins(ctx.Bool(LogDebugFlag.Name))
-	glogger := log.NewGlogHandler(ostream)
-	// Set log level
-	glogger.Verbosity(log.Lvl(ctx.Int(VerbosityFlag.Name)))
-	log.Root().SetHandler(glogger)
-	return nil
-}

bridge-history-api/utils/parse_event.go

@@ -1,400 +0,0 @@
-package utils
-
-import (
-	"context"
-	"math/big"
-	"strings"
-
-	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/ethclient"
-	"github.com/ethereum/go-ethereum/log"
-
-	backendabi "bridge-history-api/abi"
-	"bridge-history-api/db/orm"
-)
-
-// CachedParsedTxCalldata store parsed batch infos
-type CachedParsedTxCalldata struct {
-	CallDataIndex uint64
-	BatchIndices  []uint64
-	StartBlocks   []uint64
-	EndBlocks     []uint64
-}
-
-// ParseBackendL1EventLogs parses L1 watched events
-func ParseBackendL1EventLogs(logs []types.Log) ([]*orm.CrossMsg, []*orm.RelayedMsg, error) {
-	// Need use contract abi to parse event Log
-	// Can only be tested after we have our contracts set up
-
-	var l1CrossMsg []*orm.CrossMsg
-	var relayedMsgs []*orm.RelayedMsg
-	var msgHash string
-	for _, vlog := range logs {
-		switch vlog.Topics[0] {
-		case backendabi.L1DepositETHSig:
-			event := backendabi.DepositETH{}
-			err := UnpackLog(backendabi.L1ETHGatewayABI, &event, "DepositETH", vlog)
-			if err != nil {
-				log.Warn("Failed to unpack DepositETH event", "err", err)
-				return l1CrossMsg, relayedMsgs, err
-			}
-			l1CrossMsg = append(l1CrossMsg, &orm.CrossMsg{
-				Height:     vlog.BlockNumber,
-				Sender:     event.From.String(),
-				Target:     event.To.String(),
-				Amount:     event.Amount.String(),
-				Asset:      int(orm.ETH),
-				Layer1Hash: vlog.TxHash.Hex(),
-				MsgHash:    msgHash,
-			})
-		case backendabi.L1DepositERC20Sig:
-			event := backendabi.ERC20MessageEvent{}
-			err := UnpackLog(backendabi.L1StandardERC20GatewayABI, &event, "DepositERC20", vlog)
-			if err != nil {
-				log.Warn("Failed to unpack DepositERC20 event", "err", err)
-				return l1CrossMsg, relayedMsgs, err
-			}
-			l1CrossMsg = append(l1CrossMsg, &orm.CrossMsg{
-				Height:      vlog.BlockNumber,
-				Sender:      event.From.String(),
-				Target:      event.To.String(),
-				Amount:      event.Amount.String(),
-				Asset:       int(orm.ERC20),
-				Layer1Hash:  vlog.TxHash.Hex(),
-				Layer1Token: event.L1Token.Hex(),
-				Layer2Token: event.L2Token.Hex(),
-				MsgHash:     msgHash,
-			})
-		case backendabi.L1DepositERC721Sig:
-			event := backendabi.ERC721MessageEvent{}
-			err := UnpackLog(backendabi.L1ERC721GatewayABI, &event, "DepositERC721", vlog)
-			if err != nil {
-				log.Warn("Failed to unpack DepositERC721 event", "err", err)
-				return l1CrossMsg, relayedMsgs, err
-			}
-			l1CrossMsg = append(l1CrossMsg, &orm.CrossMsg{
-				Height:      vlog.BlockNumber,
-				Sender:      event.From.String(),
-				Target:      event.To.String(),
-				Asset:       int(orm.ERC721),
-				Layer1Hash:  vlog.TxHash.Hex(),
-				Layer1Token: event.L1Token.Hex(),
-				Layer2Token: event.L2Token.Hex(),
-				TokenIDs:    event.TokenID.String(),
-				MsgHash:     msgHash,
-			})
-		case backendabi.L1DepositERC1155Sig:
-			event := backendabi.ERC1155MessageEvent{}
-			err := UnpackLog(backendabi.L1ERC1155GatewayABI, &event, "DepositERC1155", vlog)
-			if err != nil {
-				log.Warn("Failed to unpack DepositERC1155 event", "err", err)
-				return l1CrossMsg, relayedMsgs, err
-			}
-			l1CrossMsg = append(l1CrossMsg, &orm.CrossMsg{
-				Height:      vlog.BlockNumber,
-				Sender:      event.From.String(),
-				Target:      event.To.String(),
-				Asset:       int(orm.ERC1155),
-				Layer1Hash:  vlog.TxHash.Hex(),
-				Layer1Token: event.L1Token.Hex(),
-				Layer2Token: event.L2Token.Hex(),
-				TokenIDs:    event.TokenID.String(),
-				Amount:      event.Amount.String(),
-				MsgHash:     msgHash,
-			})
-		case backendabi.L1SentMessageEventSignature:
-			event := backendabi.L1SentMessageEvent{}
-			err := UnpackLog(backendabi.L1ScrollMessengerABI, &event, "SentMessage", vlog)
-			if err != nil {
-				log.Warn("Failed to unpack SentMessage event", "err", err)
-				return l1CrossMsg, relayedMsgs, err
-			}
-			// since every deposit event will emit after a sent event, so can use this msg_hash as next withdraw event's msg_hash
-			msgHash = ComputeMessageHash(event.Sender, event.Target, event.Value, event.MessageNonce, event.Message).Hex()
-		case backendabi.L1BatchDepositERC721Sig:
-			event := backendabi.BatchERC721MessageEvent{}
-			err := UnpackLog(backendabi.L1ERC721GatewayABI, &event, "BatchDepositERC721", vlog)
-			if err != nil {
-				log.Warn("Failed to unpack BatchDepositERC721 event", "err", err)
-				return l1CrossMsg, relayedMsgs, err
-			}
-			l1CrossMsg = append(l1CrossMsg, &orm.CrossMsg{
-				Height:      vlog.BlockNumber,
-				Sender:      event.From.String(),
-				Target:      event.To.String(),
-				Asset:       int(orm.ERC721),
-				Layer1Hash:  vlog.TxHash.Hex(),
-				Layer1Token: event.L1Token.Hex(),
-				Layer2Token: event.L2Token.Hex(),
-				TokenIDs:    convertBigIntArrayToString(event.TokenIDs),
-				MsgHash:     msgHash,
-			})
-		case backendabi.L1BatchDepositERC1155Sig:
-			event := backendabi.BatchERC1155MessageEvent{}
-			err := UnpackLog(backendabi.L1ERC1155GatewayABI, &event, "BatchDepositERC1155", vlog)
-			if err != nil {
-				log.Warn("Failed to unpack BatchDepositERC1155 event", "err", err)
-				return l1CrossMsg, relayedMsgs, err
-			}
-			l1CrossMsg = append(l1CrossMsg, &orm.CrossMsg{
-				Height:       vlog.BlockNumber,
-				Sender:       event.From.String(),
-				Target:       event.To.String(),
-				Asset:        int(orm.ERC1155),
-				Layer1Hash:   vlog.TxHash.Hex(),
-				Layer1Token:  event.L1Token.Hex(),
-				Layer2Token:  event.L2Token.Hex(),
-				TokenIDs:     convertBigIntArrayToString(event.TokenIDs),
-				TokenAmounts: convertBigIntArrayToString(event.TokenAmounts),
-				MsgHash:      msgHash,
-			})
-		case backendabi.L1RelayedMessageEventSignature:
-			event := backendabi.L1RelayedMessageEvent{}
-			err := UnpackLog(backendabi.L1ScrollMessengerABI, &event, "RelayedMessage", vlog)
-			if err != nil {
-				log.Warn("Failed to unpack RelayedMessage event", "err", err)
-				return l1CrossMsg, relayedMsgs, err
-			}
-			relayedMsgs = append(relayedMsgs, &orm.RelayedMsg{
-				MsgHash:    event.MessageHash.String(),
-				Height:     vlog.BlockNumber,
-				Layer1Hash: vlog.TxHash.Hex(),
-			})
-
-		}
-
-	}
-	return l1CrossMsg, relayedMsgs, nil
-}
-
-// ParseBackendL2EventLogs parses L2 watched events
-func ParseBackendL2EventLogs(logs []types.Log) ([]*orm.CrossMsg, []*orm.RelayedMsg, []*orm.L2SentMsg, error) {
-	// Need use contract abi to parse event Log
-	// Can only be tested after we have our contracts set up
-
-	var l2CrossMsg []*orm.CrossMsg
-	// this is use to confirm finalized l1 msg
-	var relayedMsgs []*orm.RelayedMsg
-	var l2SentMsgs []*orm.L2SentMsg
-	for _, vlog := range logs {
-		switch vlog.Topics[0] {
-		case backendabi.L2WithdrawETHSig:
-			event := backendabi.DepositETH{}
-			err := UnpackLog(backendabi.L2ETHGatewayABI, &event, "WithdrawETH", vlog)
-			if err != nil {
-				log.Warn("Failed to unpack WithdrawETH event", "err", err)
-				return l2CrossMsg, relayedMsgs, l2SentMsgs, err
-			}
-			l2SentMsgs[len(l2SentMsgs)-1].OriginalSender = event.From.Hex()
-			l2CrossMsg = append(l2CrossMsg, &orm.CrossMsg{
-				Height:     vlog.BlockNumber,
-				Sender:     event.From.String(),
-				Target:     event.To.String(),
-				Amount:     event.Amount.String(),
-				Asset:      int(orm.ETH),
-				Layer2Hash: vlog.TxHash.Hex(),
-				MsgHash:    l2SentMsgs[len(l2SentMsgs)-1].MsgHash,
-			})
-		case backendabi.L2WithdrawERC20Sig:
-			event := backendabi.ERC20MessageEvent{}
-			err := UnpackLog(backendabi.L2StandardERC20GatewayABI, &event, "WithdrawERC20", vlog)
-			if err != nil {
-				log.Warn("Failed to unpack WithdrawERC20 event", "err", err)
-				return l2CrossMsg, relayedMsgs, l2SentMsgs, err
-			}
-			l2SentMsgs[len(l2SentMsgs)-1].OriginalSender = event.From.Hex()
-			l2CrossMsg = append(l2CrossMsg, &orm.CrossMsg{
-				Height:      vlog.BlockNumber,
-				Sender:      event.From.String(),
-				Target:      event.To.String(),
-				Amount:      event.Amount.String(),
-				Asset:       int(orm.ERC20),
-				Layer2Hash:  vlog.TxHash.Hex(),
-				Layer1Token: event.L1Token.Hex(),
-				Layer2Token: event.L2Token.Hex(),
-				MsgHash:     l2SentMsgs[len(l2SentMsgs)-1].MsgHash,
-			})
-		case backendabi.L2WithdrawERC721Sig:
-			event := backendabi.ERC721MessageEvent{}
-			err := UnpackLog(backendabi.L2ERC721GatewayABI, &event, "WithdrawERC721", vlog)
-			if err != nil {
-				log.Warn("Failed to unpack WithdrawERC721 event", "err", err)
-				return l2CrossMsg, relayedMsgs, l2SentMsgs, err
-			}
-			l2SentMsgs[len(l2SentMsgs)-1].OriginalSender = event.From.Hex()
-			l2CrossMsg = append(l2CrossMsg, &orm.CrossMsg{
-				Height:      vlog.BlockNumber,
-				Sender:      event.From.String(),
-				Target:      event.To.String(),
-				Asset:       int(orm.ERC721),
-				Layer2Hash:  vlog.TxHash.Hex(),
-				Layer1Token: event.L1Token.Hex(),
-				Layer2Token: event.L2Token.Hex(),
-				TokenIDs:    event.TokenID.String(),
-				MsgHash:     l2SentMsgs[len(l2SentMsgs)-1].MsgHash,
-			})
-		case backendabi.L2WithdrawERC1155Sig:
-			event := backendabi.ERC1155MessageEvent{}
-			err := UnpackLog(backendabi.L2ERC1155GatewayABI, &event, "WithdrawERC1155", vlog)
-			if err != nil {
-				log.Warn("Failed to unpack WithdrawERC1155 event", "err", err)
-				return l2CrossMsg, relayedMsgs, l2SentMsgs, err
-			}
-			l2SentMsgs[len(l2SentMsgs)-1].OriginalSender = event.From.Hex()
-			l2CrossMsg = append(l2CrossMsg, &orm.CrossMsg{
-				Height:      vlog.BlockNumber,
-				Sender:      event.From.String(),
-				Target:      event.To.String(),
-				Asset:       int(orm.ERC1155),
-				Layer2Hash:  vlog.TxHash.Hex(),
-				Layer1Token: event.L1Token.Hex(),
-				Layer2Token: event.L2Token.Hex(),
-				TokenIDs:    event.TokenID.String(),
-				Amount:      event.Amount.String(),
-				MsgHash:     l2SentMsgs[len(l2SentMsgs)-1].MsgHash,
-			})
-		case backendabi.L2BatchWithdrawERC721Sig:
-			event := backendabi.BatchERC721MessageEvent{}
-			err := UnpackLog(backendabi.L2ERC721GatewayABI, &event, "BatchWithdrawERC721", vlog)
-			if err != nil {
-				log.Warn("Failed to unpack BatchWithdrawERC721 event", "err", err)
-				return l2CrossMsg, relayedMsgs, l2SentMsgs, err
-			}
-			l2SentMsgs[len(l2SentMsgs)-1].OriginalSender = event.From.Hex()
-			l2CrossMsg = append(l2CrossMsg, &orm.CrossMsg{
-				Height:      vlog.BlockNumber,
-				Sender:      event.From.String(),
-				Target:      event.To.String(),
-				Asset:       int(orm.ERC721),
-				Layer1Hash:  vlog.TxHash.Hex(),
-				Layer1Token: event.L1Token.Hex(),
-				Layer2Token: event.L2Token.Hex(),
-				TokenIDs:    convertBigIntArrayToString(event.TokenIDs),
-				MsgHash:     l2SentMsgs[len(l2SentMsgs)-1].MsgHash,
-			})
-		case backendabi.L2BatchWithdrawERC1155Sig:
-			event := backendabi.BatchERC1155MessageEvent{}
-			err := UnpackLog(backendabi.L2ERC1155GatewayABI, &event, "BatchWithdrawERC1155", vlog)
-			if err != nil {
-				log.Warn("Failed to unpack BatchWithdrawERC1155 event", "err", err)
-				return l2CrossMsg, relayedMsgs, l2SentMsgs, err
-			}
-			l2SentMsgs[len(l2SentMsgs)-1].OriginalSender = event.From.Hex()
-			l2CrossMsg = append(l2CrossMsg, &orm.CrossMsg{
-				Height:       vlog.BlockNumber,
-				Sender:       event.From.String(),
-				Target:       event.To.String(),
-				Asset:        int(orm.ERC1155),
-				Layer1Hash:   vlog.TxHash.Hex(),
-				Layer1Token:  event.L1Token.Hex(),
-				Layer2Token:  event.L2Token.Hex(),
-				TokenIDs:     convertBigIntArrayToString(event.TokenIDs),
-				TokenAmounts: convertBigIntArrayToString(event.TokenAmounts),
-				MsgHash:      l2SentMsgs[len(l2SentMsgs)-1].MsgHash,
-			})
-		case backendabi.L2SentMessageEventSignature:
-			event := backendabi.L2SentMessageEvent{}
-			err := UnpackLog(backendabi.L2ScrollMessengerABI, &event, "SentMessage", vlog)
-			if err != nil {
-				log.Warn("Failed to unpack SentMessage event", "err", err)
-				return l2CrossMsg, relayedMsgs, l2SentMsgs, err
-			}
-			// since every withdraw event will emit after a sent event, so can use this msg_hash as next withdraw event's msg_hash
-			msgHash := ComputeMessageHash(event.Sender, event.Target, event.Value, event.MessageNonce, event.Message)
-			l2SentMsgs = append(l2SentMsgs,
-				&orm.L2SentMsg{
-					Sender:  event.Sender.Hex(),
-					TxHash:  vlog.TxHash.Hex(),
-					Target:  event.Target.Hex(),
-					Value:   event.Value.String(),
-					MsgHash: msgHash.Hex(),
-					Height:  vlog.BlockNumber,
-					Nonce:   event.MessageNonce.Uint64(),
-					MsgData: hexutil.Encode(event.Message),
-				})
-		case backendabi.L2RelayedMessageEventSignature:
-			event := backendabi.L2RelayedMessageEvent{}
-			err := UnpackLog(backendabi.L2ScrollMessengerABI, &event, "RelayedMessage", vlog)
-			if err != nil {
-				log.Warn("Failed to unpack RelayedMessage event", "err", err)
-				return l2CrossMsg, relayedMsgs, l2SentMsgs, err
-			}
-			relayedMsgs = append(relayedMsgs, &orm.RelayedMsg{
-				MsgHash:    event.MessageHash.String(),
-				Height:     vlog.BlockNumber,
-				Layer2Hash: vlog.TxHash.Hex(),
-			})
-
-		}
-	}
-	return l2CrossMsg, relayedMsgs, l2SentMsgs, nil
-}
-
-// ParseBatchInfoFromScrollChain parses ScrollChain events
-func ParseBatchInfoFromScrollChain(ctx context.Context, client *ethclient.Client, logs []types.Log) ([]*orm.RollupBatch, error) {
-	var rollupBatches []*orm.RollupBatch
-	cache := make(map[string]CachedParsedTxCalldata)
-	for _, vlog := range logs {
-		switch vlog.Topics[0] {
-		case backendabi.L1CommitBatchEventSignature:
-			event := backendabi.L1CommitBatchEvent{}
-			err := UnpackLog(backendabi.ScrollChainABI, &event, "CommitBatch", vlog)
-			if err != nil {
-				log.Warn("Failed to unpack CommitBatch event", "err", err)
-				return rollupBatches, err
-			}
-			if _, ok := cache[vlog.TxHash.Hex()]; ok {
-				c := cache[vlog.TxHash.Hex()]
-				c.CallDataIndex++
-				rollupBatches = append(rollupBatches, &orm.RollupBatch{
-					CommitHeight:     vlog.BlockNumber,
-					BatchIndex:       c.BatchIndices[c.CallDataIndex],
-					BatchHash:        event.BatchHash.Hex(),
-					StartBlockNumber: c.StartBlocks[c.CallDataIndex],
-					EndBlockNumber:   c.EndBlocks[c.CallDataIndex],
-				})
-				cache[vlog.TxHash.Hex()] = c
-				continue
-			}
-
-			commitTx, isPending, err := client.TransactionByHash(ctx, vlog.TxHash)
-			if err != nil || isPending {
-				log.Warn("Failed to get commit Batch tx receipt or the tx is still pending", "err", err)
-				return rollupBatches, err
-			}
-			indices, startBlocks, endBlocks, err := GetBatchRangeFromCalldataV1(commitTx.Data())
-			if err != nil {
-				log.Warn("Failed to get batch range from calldata", "hash", commitTx.Hash().Hex(), "height", vlog.BlockNumber)
-				return rollupBatches, err
-			}
-			cache[vlog.TxHash.Hex()] = CachedParsedTxCalldata{
-				CallDataIndex: 0,
-				BatchIndices:  indices,
-				StartBlocks:   startBlocks,
-				EndBlocks:     endBlocks,
-			}
-			rollupBatches = append(rollupBatches, &orm.RollupBatch{
-				CommitHeight:     vlog.BlockNumber,
-				BatchIndex:       indices[0],
-				BatchHash:        event.BatchHash.Hex(),
-				StartBlockNumber: startBlocks[0],
-				EndBlockNumber:   endBlocks[0],
-			})
-
-		default:
-			continue
-		}
-	}
-	return rollupBatches, nil
-}
-
-func convertBigIntArrayToString(array []*big.Int) string {
-	stringArray := make([]string, len(array))
-	for i, num := range array {
-		stringArray[i] = num.String()
-	}
-
-	result := strings.Join(stringArray, ", ")
-	return result
-}