chore(libzkp): upgrade to v0.10.0l, fix keccak overflow (#1231)

Co-authored-by: HAOYUatHZ <37070449+HAOYUatHZ@users.noreply.github.com>
Co-authored-by: HAOYUatHZ <HAOYUatHZ@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

@@ -25,20 +25,20 @@ defaults:
     working-directory: 'bridge-history-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
+  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.21.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
@@ -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
     - name: Test
       run: |
-        go get ./...
         make test
     - name: Upload coverage reports to Codecov
       uses: codecov/codecov-action@v3
@@ -66,7 +65,7 @@ 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
     - name: Install goimports

.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@v3
+        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:
@@ -33,7 +35,7 @@ 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
     - name: Cache cargo
@@ -52,7 +54,7 @@ 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
     - name: Install goimports
@@ -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
     - 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.yml

@@ -43,10 +43,10 @@ jobs:
       - name: Setup LCOV
         uses: hrishikesh-kadam/setup-lcov@v1
 
-      - name: Install Node.js 14
+      - name: Install Node.js 18
         uses: actions/setup-node@v2
         with:
-          node-version: '14'
+          node-version: '18'
 
       - name: Get yarn cache directory path
         id: yarn-cache-dir-path
@@ -73,26 +73,24 @@ jobs:
         run: yarn install
 
       - name: Compile with foundry
-        run: forge build
+        run: forge build --evm-version cancun
 
       - name: Run foundry tests
-        run: forge test -vvv
+        run: forge test --evm-version cancun -vvv
 
       - name: Run foundry coverage
-        run : forge coverage --report lcov
+        run : forge coverage --evm-version cancun --report lcov
 
       - name : Prune coverage
-        run : lcov --remove ./lcov.info -o ./lcov.info.pruned 'src/mocks/*' 'src/test/*' 'scripts/*' 'node_modules/*' 'lib/*'
+        run : lcov --rc branch_coverage=1 --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
+      - name: Upload coverage reports to Codecov
+        uses: codecov/codecov-action@v3
+        env:
+          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
         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
+          files: contracts/lcov.info.pruned
+          flags: contracts
 
   hardhat:
     if: github.event.pull_request.draft == false
@@ -104,10 +102,10 @@ jobs:
         with:
           submodules: recursive
 
-      - name: Install Node.js 14
+      - name: Install Node.js 18
         uses: actions/setup-node@v2
         with:
-          node-version: '14'
+          node-version: '18'
 
       - name: Get yarn cache directory path
         id: yarn-cache-dir-path

.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'
 
@@ -37,7 +39,7 @@ jobs:
     - name: Install Go
       uses: actions/setup-go@v2
       with:
-        go-version: 1.19.x
+        go-version: 1.20.x
     - name: Checkout code
       uses: actions/checkout@v2
     - name: Lint
@@ -52,7 +54,7 @@ jobs:
     - name: Install Go
       uses: actions/setup-go@v2
       with:
-        go-version: 1.19.x
+        go-version: 1.20.x
     - name: Checkout code
       uses: actions/checkout@v2
     - name: Install goimports
@@ -93,15 +95,15 @@ jobs:
     - name: Install Go
       uses: actions/setup-go@v2
       with:
-        go-version: 1.18.x
+        go-version: 1.20.x
     - name: Checkout code
       uses: actions/checkout@v2
     - 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/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,7 +32,7 @@ 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
     - name: Lint
@@ -45,7 +47,7 @@ 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
     - name: Install goimports
@@ -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
     - 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.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,318 @@
+name: Docker
+
+on:
+  push:
+    tags:
+      - v**
+
+env:
+  AWS_REGION: us-west-2
+
+jobs:
+  event_watcher:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+      - 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: event-watcher
+        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: event-watcher
+          IMAGE_TAG: ${{ github.ref_name }}
+        with:
+          context: .
+          file: ./build/dockerfiles/event_watcher.Dockerfile
+          push: true
+          tags: |
+            ${{ secrets.DOCKERHUB_USERNAME }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            ${{ secrets.DOCKERHUB_USERNAME }}/${{ env.REPOSITORY }}:latest
+            ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:latest
+
+  gas_oracle:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+      - 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
+          push: true
+          tags: |
+            ${{ secrets.DOCKERHUB_USERNAME }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            ${{ secrets.DOCKERHUB_USERNAME }}/${{ env.REPOSITORY }}:latest
+            ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:latest
+
+  rollup_relayer:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+      - 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
+          push: true
+          tags: |
+            ${{ secrets.DOCKERHUB_USERNAME }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            ${{ secrets.DOCKERHUB_USERNAME }}/${{ env.REPOSITORY }}:latest
+            ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:latest
+
+  bridgehistoryapi-fetcher:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+      - 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
+          push: true
+          tags: |
+            ${{ secrets.DOCKERHUB_USERNAME }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            ${{ secrets.DOCKERHUB_USERNAME }}/${{ env.REPOSITORY }}:latest
+            ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:latest
+
+  bridgehistoryapi-api:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+      - 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
+          push: true
+          tags: |
+            ${{ secrets.DOCKERHUB_USERNAME }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            ${{ secrets.DOCKERHUB_USERNAME }}/${{ env.REPOSITORY }}:latest
+            ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:latest
+
+  coordinator-api:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+      - 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: |
+            ${{ secrets.DOCKERHUB_USERNAME }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            ${{ secrets.DOCKERHUB_USERNAME }}/${{ env.REPOSITORY }}:latest
+            ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:latest
+
+  coordinator-cron:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+      - 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
+          push: true
+          tags: |
+            ${{ secrets.DOCKERHUB_USERNAME }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            ${{ secrets.DOCKERHUB_USERNAME }}/${{ env.REPOSITORY }}:latest
+            ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:${{ env.IMAGE_TAG }}
+            ${{ env.ECR_REGISTRY }}/${{ env.REPOSITORY }}:latest

.github/workflows/integration.yml

@@ -22,21 +22,21 @@ 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
     - 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
     - name: Run integration tests
       run: |

.github/workflows/intermediate-docker.yml

@@ -7,7 +7,7 @@ on:
         description: 'Go version'
         required: true
         type: string
-        default: '1.19'
+        default: '1.20'
       RUST_VERSION:
         description: 'Rust toolchain version'
         required: true

.github/workflows/prover.yml

@@ -1,4 +1,4 @@
-name: Roller
+name: Prover
 
 on:
   push:
@@ -8,8 +8,8 @@ on:
       - develop
       - alpha
     paths:
-      - 'roller/**'
-      - '.github/workflows/roller.yml'
+      - 'prover/**'
+      - '.github/workflows/prover.yml'
   pull_request:
     types:
       - opened
@@ -17,18 +17,37 @@ on:
       - synchronize
       - ready_for_review
     paths:
-      - 'roller/**'
-      - '.github/workflows/roller.yml'
+      - 'prover/**'
+      - '.github/workflows/prover.yml'
 
 defaults:
   run:
-    working-directory: 'roller'
+    working-directory: 'prover'
 
 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.21.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: prover
+  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
@@ -37,7 +56,7 @@ 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
     - name: Cache cargo
@@ -46,14 +65,7 @@ jobs:
         workspaces: "common/libzkp/impl -> target"
     - name: Test
       run: |
-        make roller
-        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
+        make prover
   check:
     if: github.event.pull_request.draft == false
     runs-on: ubuntu-latest
@@ -61,7 +73,7 @@ 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
     - name: Lint
@@ -75,12 +87,12 @@ 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
     - name: Install goimports
       run: go install golang.org/x/tools/cmd/goimports
-    - run: goimports -local scroll-tech/roller/ -w .
+    - run: goimports -local scroll-tech/prover/ -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

.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
     - 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
     - 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,27 +83,27 @@ 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
     - 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 ./...
     - name: Upload coverage reports to Codecov
@@ -109,7 +111,7 @@ jobs:
       env:
         CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
       with:
-        flags: bridge
+        flags: rollup
   # docker-build:
   #   if: github.event.pull_request.draft == false
   #   runs-on: ubuntu-latest

.gitignore

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

.gitmodules

@@ -1,9 +1,6 @@
 [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

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. If you are looking to contribute to Scroll's Halo2 zkEVM circuits please refer to the [zkEVM circuits](https://github.com/scroll-tech/zkevm-circuits) repo. 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)

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,36 +1,49 @@
-.PHONY: check update dev_docker build_test_docker run_test_docker clean
+.PHONY: fmt dev_docker build_test_docker run_test_docker clean update
 
-ZKP_VERSION=release-1220
+L2GETH_TAG=scroll-v5.1.6
 
 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:
+	go work sync
+	cd $(PWD)/bridge-history-api/ && go get -u github.com/scroll-tech/go-ethereum@${L2GETH_TAG} && go mod tidy
+	cd $(PWD)/common/ && go get -u github.com/scroll-tech/go-ethereum@${L2GETH_TAG}&& go mod tidy
+	cd $(PWD)/coordinator/ && go get -u github.com/scroll-tech/go-ethereum@${L2GETH_TAG} && go mod tidy
+	cd $(PWD)/database/ && go get -u github.com/scroll-tech/go-ethereum@${L2GETH_TAG} && go mod tidy
+	cd $(PWD)/prover/ && go get -u github.com/scroll-tech/go-ethereum@${L2GETH_TAG}&& go mod tidy
+	cd $(PWD)/rollup/ && go get -u github.com/scroll-tech/go-ethereum@${L2GETH_TAG} && go mod tidy
+	cd $(PWD)/tests/integration-test/ && go get -u github.com/scroll-tech/go-ethereum@${L2GETH_TAG} && go mod tidy
 
 lint: ## The code's format and security checks.
-	make -C bridge lint
+	make -C rollup lint
 	make -C common lint
 	make -C coordinator lint
 	make -C database lint
-	make -C roller lint
+	make -C prover 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-v3.1.12 && 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-v3.1.12 && go mod tidy
-	cd $(PWD)/coordinator/ && go get -u github.com/scroll-tech/go-ethereum@scroll-v3.1.12 && go mod tidy
-	cd $(PWD)/database/ && go get -u github.com/scroll-tech/go-ethereum@scroll-v3.1.12 && go mod tidy
-	cd $(PWD)/roller/ && go get -u github.com/scroll-tech/go-ethereum@scroll-v3.1.12 && go mod tidy
-	goimports -local $(PWD)/bridge/ -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)/prover/ && go mod tidy
+	cd $(PWD)/rollup/ && go mod tidy
+	cd $(PWD)/tests/integration-test/ && go mod tidy
+
 	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 .
+	goimports -local $(PWD)/prover/ -w .
+	goimports -local $(PWD)/rollup/ -w .
+	goimports -local $(PWD)/tests/integration-test/ -w .
 
 dev_docker: ## build docker images for development/testing usages
+	docker pull postgres
 	docker build -t scroll_l1geth ./common/docker/l1geth/
 	docker build -t scroll_l2geth ./common/docker/l2geth/
 
@@ -38,18 +51,7 @@ 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
-
-
-test_zkp: ## Test zkp prove and verify, roller/prover generates the proof and coordinator/verifier verifies it
-	mkdir -p test_params
-	wget https://circuit-release.s3.us-west-2.amazonaws.com/circuit-release/${ZKP_VERSION}/test_params/params19 -O ./test_params/params19
-	wget https://circuit-release.s3.us-west-2.amazonaws.com/circuit-release/${ZKP_VERSION}/test_params/params26 -O ./test_params/params26
-	wget https://circuit-release.s3.us-west-2.amazonaws.com/circuit-release/${ZKP_VERSION}/test_seed -O test_seed
-	rm -rf ./roller/assets/test_params && mv test_params ./roller/assets/ && mv test_seed ./roller/assets/
-	cd ./roller && make test-gpu-prover
-	rm -rf ./coordinator/assets/test_params && mv ./roller/assets/test_params ./coordinator/assets/ && mv ./roller/assets/agg_proof ./coordinator/assets/
-	cd ./coordinator && make test-gpu-verifier
+	docker run -it --rm --name scroll_test_container --network=host -v /var/run/docker.sock:/var/run/docker.sock -v $(PWD):/go/src/app -e HOST_PATH=$(PWD) scroll_test_image
 
 clean: ## Empty out the bin folder
 	@rm -rf build/bin

README.md

@@ -1,9 +1,35 @@
 # 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)
+[![contracts](https://github.com/scroll-tech/scroll/actions/workflows/contracts.yml/badge.svg)](https://github.com/scroll-tech/scroll/actions/workflows/contracts.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="./src">l2geth</a>: Scroll execution node
+├── <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="./rpc-gateway">rpc-gateway</a>: RPC gateway external repo
+└── <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
++ Go 1.21
 + Rust (for version, see [rust-toolchain](./common/libzkp/impl/rust-toolchain))
 + Hardhat / Foundry
 + Docker
@@ -15,14 +41,14 @@ docker pull postgres
 make dev_docker
 ```
 
-## Testing Bridge & Coordinator
+## Testing Rollup & Coordinator
 
 ### For Non-Apple Silicon (M1/M2) Macs
 
 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/...
@@ -55,7 +81,7 @@ This command runs a Docker container named `scroll_test_container` from the `scr
 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 -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/...
@@ -63,6 +89,10 @@ 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/).
+You can find the unit tests in [`contracts/src/test/`](/contracts/src/test/), and integration tests in [`contracts/integration-test/`](/contracts/integration-test/).
 
-For more details on contracts, see [`/contracts`](/contracts).
+See [`contracts`](/contracts) for more details on the contracts.
+
+## License
+
+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
+	DOCKER_BUILDKIT=1 docker build -t scrolltech/bridgehistoryapi-api:${IMAGE_VERSION} ${REPO_ROOT_DIR}/ -f ${REPO_ROOT_DIR}/build/dockerfiles/bridgehistoryapi-api.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

bridge-history-api/README.md

@@ -1 +1,81 @@
 # 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]
+```

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 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/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,102 +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) {
-	ctx.WriteString("pong")
-}
-
-func setupQueryByAddressHandler(backend_app *mvc.Application) {
-	// Register Dependencies.
-	backend_app.Register(
-		database,
-		service.NewHistoryService,
-	)
-
-	// Register Controllers.
-	backend_app.Handle(new(controller.QueryAddressController))
-}
-
-func setupQueryByHashHandler(backend_app *mvc.Application) {
-	backend_app.Register(
-		database,
-		service.NewHistoryService,
-	)
-	backend_app.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 database.Close()
-	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)
-
-	// 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,125 +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/cross_msg"
-	"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)
-	if err != nil {
-		log.Crit("failed to connect to db", "config file", cfgFile, "error", err)
-	}
-
-	l1worker := &cross_msg.FetchEventWorker{F: cross_msg.L1FetchAndSaveEvents, G: cross_msg.GetLatestL1ProcessedHeight, Name: "L1 events fetch Worker"}
-
-	l2worker := &cross_msg.FetchEventWorker{F: cross_msg.L2FetchAndSaveEvents, G: cross_msg.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 := cross_msg.NewCrossMsgFetcher(subCtx, cfg.L1, db, l1client, l1worker, l1AddressList, cross_msg.L1ReorgHandling)
-	if err != nil {
-		log.Crit("failed to create l1 cross message fetcher", "error", err)
-	}
-
-	go l1crossMsgFetcher.Start()
-	defer l1crossMsgFetcher.Stop()
-
-	l2crossMsgFetcher, err := cross_msg.NewCrossMsgFetcher(subCtx, cfg.L2, db, l2client, l2worker, l2AddressList, cross_msg.L2ReorgHandling)
-	if err != nil {
-		log.Crit("failed to create l2 cross message fetcher", "error", err)
-	}
-
-	go l2crossMsgFetcher.Start()
-	defer l2crossMsgFetcher.Stop()
-
-	l1BlocktimeFetcher := cross_msg.NewBlocktimestampFetcher(subCtx, uint(cfg.L1.Confirmation), int(cfg.L1.BlockTime), l1client, db.UpdateL1Blocktimestamp, db.GetL1EarliestNoBlocktimestampHeight)
-	go l1BlocktimeFetcher.Start()
-	defer l1BlocktimeFetcher.Stop()
-
-	l2BlocktimeFetcher := cross_msg.NewBlocktimestampFetcher(subCtx, uint(cfg.L2.Confirmation), int(cfg.L2.BlockTime), l2client, db.UpdateL2Blocktimestamp, db.GetL2EarliestNoBlocktimestampHeight)
-	go l2BlocktimeFetcher.Start()
-	defer l2BlocktimeFetcher.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...)
@@ -60,7 +56,8 @@ func init() {
 					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,93 @@
+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 := fetcher.NewL1MessageFetcher(subCtx, cfg.L1, db, l1Client)
+	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 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/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,53 @@
+{
+	"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",
+		"ScrollChainAddr": "0xa13BAF47339d63B743e7Da8741db5456DAc1E556",
+		"GatewayRouterAddr": "0xF8B1378579659D8F7EE5f3C929c2f3E332E41Fd6",
+		"MessageQueueAddr": "0x0d7E906BD9cAFa154b048cFa766Cc1E54E39AF9B"
+	},
+	"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",
+		"GatewayRouterAddr": "0x4C0926FF5252A435FD19e10ED15e5a249Ba19d79"
+	},
+	"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,37 +0,0 @@
-{
-	"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,62 +0,0 @@
-package config
-
-import (
-	"encoding/json"
-	"os"
-	"path/filepath"
-)
-
-// 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"`
-}
-
-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"`
-}
-
-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"`
-}
-
-// 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,37 +0,0 @@
-package controller
-
-import (
-	"bridge-history-api/model"
-	"bridge-history-api/service"
-
-	"github.com/ethereum/go-ethereum/common"
-)
-
-type QueryAddressController struct {
-	Service service.HistoryService
-}
-
-type QueryHashController struct {
-	Service service.HistoryService
-}
-
-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
-}
-
-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/cross_msg/block_timestamp_fetcher.go

@@ -1,79 +0,0 @@
-package cross_msg
-
-import (
-	"context"
-	"math/big"
-	"time"
-
-	"github.com/ethereum/go-ethereum/ethclient"
-	"github.com/ethereum/go-ethereum/log"
-)
-
-type GetEarliestNoBlocktimestampHeightFunc func() (uint64, error)
-type UpdateBlocktimestampFunc func(height uint64, timestamp time.Time) error
-
-type BlocktimestampFetcher struct {
-	ctx                                   context.Context
-	confirmation                          uint
-	blockTimeInSec                        int
-	client                                *ethclient.Client
-	updateBlocktimestampFunc              UpdateBlocktimestampFunc
-	getEarliestNoBlocktimestampHeightFunc GetEarliestNoBlocktimestampHeightFunc
-}
-
-func NewBlocktimestampFetcher(ctx context.Context, confirmation uint, blockTimeInSec int, client *ethclient.Client, updateBlocktimestampFunc UpdateBlocktimestampFunc, getEarliestNoBlocktimestampHeightFunc GetEarliestNoBlocktimestampHeightFunc) *BlocktimestampFetcher {
-	return &BlocktimestampFetcher{
-		ctx:                                   ctx,
-		confirmation:                          confirmation,
-		blockTimeInSec:                        blockTimeInSec,
-		client:                                client,
-		getEarliestNoBlocktimestampHeightFunc: getEarliestNoBlocktimestampHeightFunc,
-		updateBlocktimestampFunc:              updateBlocktimestampFunc,
-	}
-}
-
-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+uint64(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 blocktimstamp 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
-					}
-				}
-			}
-		}
-	}()
-}
-
-func (b *BlocktimestampFetcher) Stop() {
-	log.Info("BlocktimestampFetcher Stop")
-	b.ctx.Done()
-}

bridge-history-api/cross_msg/cross_msg_fetcher.go

@@ -1,213 +0,0 @@
-package cross_msg
-
-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"
-)
-
-type CrossMsgFetcher 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{}
-}
-
-func NewCrossMsgFetcher(ctx context.Context, config *config.LayerConfig, db db.OrmFactory, client *ethclient.Client, worker *FetchEventWorker, addressList []common.Address, reorg ReorgHandling) (*CrossMsgFetcher, error) {
-	newMU := &sync.Mutex{}
-	crossMsgFetcher := &CrossMsgFetcher{
-		ctx:           ctx,
-		config:        config,
-		db:            db,
-		client:        client,
-		worker:        worker,
-		reorgHandling: reorg,
-		mu:            newMU,
-		addressList:   addressList,
-		cachedHeaders: make([]*types.Header, 0),
-		reorgStartCh:  make(chan struct{}),
-		reorgEndCh:    make(chan struct{}),
-	}
-	return crossMsgFetcher, nil
-}
-
-func (c *CrossMsgFetcher) Start() {
-	log.Info("CrossMsgFetcher 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(0)
-				c.mu.Unlock()
-			}
-		}
-	}()
-
-	go func() {
-		for {
-			select {
-			case <-c.ctx.Done():
-				headerTick.Stop()
-				return
-			case <-headerTick.C:
-				c.fetchMissingLatestHeaders()
-			}
-		}
-	}()
-}
-
-func (c *CrossMsgFetcher) Stop() {
-	c.db.Close()
-	log.Info("CrossMsgFetcher Stop")
-}
-
-// forwardFetchAndSaveMissingEvents will fetch all events from the latest processed height to the latest block number.
-func (c *CrossMsgFetcher) 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
-	}
-	processed_height, 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", processed_height)
-	if processed_height <= 0 || processed_height < int64(c.config.StartHeight) {
-		processed_height = int64(c.config.StartHeight)
-	} else {
-		processed_height += 1
-	}
-	for n := processed_height; n <= int64(number); n += FETCH_LIMIT {
-		iter_end := n + FETCH_LIMIT - 1
-		if iter_end > int64(number) {
-			iter_end = int64(number)
-		}
-		err := c.worker.F(c.ctx, c.client, c.db, n, iter_end, c.addressList)
-		if err != nil {
-			log.Error(fmt.Sprintf("%s: failed!", c.worker.Name), "err", err)
-			break
-		}
-	}
-}
-
-func (c *CrossMsgFetcher) 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(int64(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 happended too earlier than cached headers", "reorg height", header.Number)
-				num, err := utils.GetSafeBlockNumber(c.ctx, c.client, c.config.Confirmation)
-				if err != 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/cross_msg/fetch_missing_event.go

@@ -1,429 +0,0 @@
-package cross_msg
-
-import (
-	"context"
-	"math/big"
-
-	geth "github.com/ethereum/go-ethereum"
-	"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/jmoiron/sqlx"
-
-	backendabi "bridge-history-api/abi"
-	"bridge-history-api/db"
-	"bridge-history-api/db/orm"
-	"bridge-history-api/utils"
-)
-
-// Todo : read from config
-var (
-	// the number of blocks fetch per round
-	FETCH_LIMIT = 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)
-type UpdateXHash func(ctx context.Context)
-
-type FetchEventWorker struct {
-	F    FetchAndSave
-	G    GetLatestProcessed
-	Name string
-}
-
-type msgHashWrapper struct {
-	msgHash common.Hash
-	txHash  common.Hash
-}
-
-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
-	} else {
-		return relayedHeight, nil
-	}
-}
-
-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
-	}
-	if crossHeight > relayedHeight {
-		return crossHeight, nil
-	} else {
-		return relayedHeight, nil
-	}
-}
-
-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, msgHashes, relayedMsg, err := 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 {
-		dbTx.Rollback()
-		log.Crit("l1FetchAndSaveEvents: Failed to insert cross msg event logs", "err", err)
-	}
-
-	err = database.BatchInsertRelayedMsgDBTx(dbTx, relayedMsg)
-	if err != nil {
-		dbTx.Rollback()
-		log.Crit("l1FetchAndSaveEvents: Failed to insert relayed message event logs", "err", err)
-	}
-	err = updateL1CrossMsgMsgHash(ctx, dbTx, database, msgHashes)
-	if err != nil {
-		dbTx.Rollback()
-		log.Crit("l1FetchAndSaveEvents: Failed to update msgHash in L1 cross msg", "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
-		dbTx.Rollback()
-		log.Error("l1FetchAndSaveEvents: Failed to commit db transaction", "err", err)
-		return err
-	}
-
-	return nil
-}
-
-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, msgHashes, relayedMsg, err := 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 {
-		dbTx.Rollback()
-		log.Crit("l2FetchAndSaveEvents: Failed to insert cross msg event logs", "err", err)
-	}
-
-	err = database.BatchInsertRelayedMsgDBTx(dbTx, relayedMsg)
-	if err != nil {
-		dbTx.Rollback()
-		log.Crit("l2FetchAndSaveEvents: Failed to insert relayed message event logs", "err", err)
-	}
-	err = updateL2CrossMsgMsgHash(ctx, dbTx, database, msgHashes)
-	if err != nil {
-		dbTx.Rollback()
-		log.Crit("l2FetchAndSaveEvents: Failed to update msgHash in L2 cross msg", "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
-		dbTx.Rollback()
-		log.Error("l2FetchAndSaveEvents: Failed to commit db transaction", "err", err)
-		return err
-	}
-
-	return nil
-}
-
-func parseBackendL1EventLogs(logs []types.Log) ([]*orm.CrossMsg, []msgHashWrapper, []*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 msgHashes []msgHashWrapper
-	for _, vlog := range logs {
-		switch vlog.Topics[0] {
-		case backendabi.L1DepositETHSig:
-			event := backendabi.DepositETH{}
-			err := utils.UnpackLog(backendabi.L1ETHGatewayABI, &event, "DepositETH", vlog)
-			if err != nil {
-				log.Warn("Failed to unpack DepositETH event", "err", err)
-				return l1CrossMsg, msgHashes, 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(),
-			})
-		case backendabi.L1DepositERC20Sig:
-			event := backendabi.ERC20MessageEvent{}
-			err := utils.UnpackLog(backendabi.L1StandardERC20GatewayABI, &event, "DepositERC20", vlog)
-			if err != nil {
-				log.Warn("Failed to unpack DepositERC20 event", "err", err)
-				return l1CrossMsg, msgHashes, 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(),
-			})
-		case backendabi.L1DepositERC721Sig:
-			event := backendabi.ERC721MessageEvent{}
-			err := utils.UnpackLog(backendabi.L1ERC721GatewayABI, &event, "DepositERC721", vlog)
-			if err != nil {
-				log.Warn("Failed to unpack DepositERC721 event", "err", err)
-				return l1CrossMsg, msgHashes, 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(),
-				TokenID:     event.TokenID.Uint64(),
-			})
-		case backendabi.L1DepositERC1155Sig:
-			event := backendabi.ERC1155MessageEvent{}
-			err := utils.UnpackLog(backendabi.L1ERC1155GatewayABI, &event, "DepositERC1155", vlog)
-			if err != nil {
-				log.Warn("Failed to unpack DepositERC1155 event", "err", err)
-				return l1CrossMsg, msgHashes, 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(),
-				TokenID:     event.TokenID.Uint64(),
-				Amount:      event.Amount.String(),
-			})
-		case backendabi.L1SentMessageEventSignature:
-			event := backendabi.L1SentMessageEvent{}
-			err := utils.UnpackLog(backendabi.L1ScrollMessengerABI, &event, "SentMessage", vlog)
-			if err != nil {
-				log.Warn("Failed to unpack SentMessage event", "err", err)
-				return l1CrossMsg, msgHashes, relayedMsgs, err
-			}
-			msgHash := utils.ComputeMessageHash(event.Sender, event.Target, event.Value, event.MessageNonce, event.Message)
-			msgHashes = append(msgHashes, msgHashWrapper{
-				msgHash: msgHash,
-				txHash:  vlog.TxHash})
-		case backendabi.L1RelayedMessageEventSignature:
-			event := backendabi.L1RelayedMessageEvent{}
-			err := utils.UnpackLog(backendabi.L1ScrollMessengerABI, &event, "RelayedMessage", vlog)
-			if err != nil {
-				log.Warn("Failed to unpack RelayedMessage event", "err", err)
-				return l1CrossMsg, msgHashes, relayedMsgs, err
-			}
-			relayedMsgs = append(relayedMsgs, &orm.RelayedMsg{
-				MsgHash:    event.MessageHash.String(),
-				Height:     vlog.BlockNumber,
-				Layer1Hash: vlog.TxHash.Hex(),
-			})
-
-		}
-
-	}
-	return l1CrossMsg, msgHashes, relayedMsgs, nil
-}
-
-func parseBackendL2EventLogs(logs []types.Log) ([]*orm.CrossMsg, []msgHashWrapper, []*orm.RelayedMsg, error) {
-	// Need use contract abi to parse event Log
-	// Can only be tested after we have our contracts set up
-
-	var l2CrossMsg []*orm.CrossMsg
-	var relayedMsgs []*orm.RelayedMsg
-	var msgHashes []msgHashWrapper
-	for _, vlog := range logs {
-		switch vlog.Topics[0] {
-		case backendabi.L2WithdrawETHSig:
-			event := backendabi.DepositETH{}
-			err := utils.UnpackLog(backendabi.L2ETHGatewayABI, &event, "WithdrawETH", vlog)
-			if err != nil {
-				log.Warn("Failed to unpack WithdrawETH event", "err", err)
-				return l2CrossMsg, msgHashes, relayedMsgs, err
-			}
-			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(),
-			})
-		case backendabi.L2WithdrawERC20Sig:
-			event := backendabi.ERC20MessageEvent{}
-			err := utils.UnpackLog(backendabi.L2StandardERC20GatewayABI, &event, "WithdrawERC20", vlog)
-			if err != nil {
-				log.Warn("Failed to unpack WithdrawERC20 event", "err", err)
-				return l2CrossMsg, msgHashes, relayedMsgs, err
-			}
-			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(),
-			})
-		case backendabi.L2WithdrawERC721Sig:
-			event := backendabi.ERC721MessageEvent{}
-			err := utils.UnpackLog(backendabi.L2ERC721GatewayABI, &event, "WithdrawERC721", vlog)
-			if err != nil {
-				log.Warn("Failed to unpack WithdrawERC721 event", "err", err)
-				return l2CrossMsg, msgHashes, relayedMsgs, err
-			}
-			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(),
-				TokenID:     event.TokenID.Uint64(),
-			})
-		case backendabi.L2WithdrawERC1155Sig:
-			event := backendabi.ERC1155MessageEvent{}
-			err := utils.UnpackLog(backendabi.L2ERC1155GatewayABI, &event, "WithdrawERC1155", vlog)
-			if err != nil {
-				log.Warn("Failed to unpack WithdrawERC1155 event", "err", err)
-				return l2CrossMsg, msgHashes, relayedMsgs, err
-			}
-			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(),
-				TokenID:     event.TokenID.Uint64(),
-				Amount:      event.Amount.String(),
-			})
-		case backendabi.L2SentMessageEventSignature:
-			event := backendabi.L2SentMessageEvent{}
-			err := utils.UnpackLog(backendabi.L2ScrollMessengerABI, &event, "SentMessage", vlog)
-			if err != nil {
-				log.Warn("Failed to unpack SentMessage event", "err", err)
-				return l2CrossMsg, msgHashes, relayedMsgs, err
-			}
-			msgHash := utils.ComputeMessageHash(event.Sender, event.Target, event.Value, event.MessageNonce, event.Message)
-			msgHashes = append(msgHashes, msgHashWrapper{
-				msgHash: msgHash,
-				txHash:  vlog.TxHash})
-		case backendabi.L2RelayedMessageEventSignature:
-			event := backendabi.L2RelayedMessageEvent{}
-			err := utils.UnpackLog(backendabi.L2ScrollMessengerABI, &event, "RelayedMessage", vlog)
-			if err != nil {
-				log.Warn("Failed to unpack RelayedMessage event", "err", err)
-				return l2CrossMsg, msgHashes, relayedMsgs, err
-			}
-			relayedMsgs = append(relayedMsgs, &orm.RelayedMsg{
-				MsgHash:    event.MessageHash.String(),
-				Height:     vlog.BlockNumber,
-				Layer2Hash: vlog.TxHash.Hex(),
-			})
-
-		}
-
-	}
-	return l2CrossMsg, msgHashes, relayedMsgs, nil
-}
-
-func updateL1CrossMsgMsgHash(ctx context.Context, dbTx *sqlx.Tx, database db.OrmFactory, msgHashes []msgHashWrapper) error {
-	for _, msgHash := range msgHashes {
-		err := database.UpdateL1CrossMsgHashDBTx(ctx, dbTx, msgHash.txHash, msgHash.msgHash)
-		if err != nil {
-			log.Error("updateL1CrossMsgMsgHash: can not update layer1 cross msg MsgHash", "layer1 hash", msgHash.txHash, "err", err)
-			continue
-		}
-	}
-	return nil
-}
-
-func updateL2CrossMsgMsgHash(ctx context.Context, dbTx *sqlx.Tx, database db.OrmFactory, msgHashes []msgHashWrapper) error {
-	for _, msgHash := range msgHashes {
-		err := database.UpdateL2CrossMsgHashDBTx(ctx, dbTx, msgHash.txHash, msgHash.msgHash)
-		if err != nil {
-			log.Error("updateL2CrossMsgMsgHash: can not update layer2 cross msg MsgHash", "layer2 hash", msgHash.txHash, "err", err)
-			continue
-		}
-	}
-	return nil
-}

bridge-history-api/cross_msg/msg_fetcher_test.go

@@ -1,65 +0,0 @@
-package cross_msg_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/cross_msg"
-)
-
-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 := cross_msg.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(uint64(nonce.Uint64())),
-		}
-		headers[i] = header
-	}
-
-	return headers, nil
-}
-
-// TODO: add more test cases
-// func TestReorg(t *testing.T)

bridge-history-api/cross_msg/reorg_handle.go

@@ -1,104 +0,0 @@
-package cross_msg
-
-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"
-)
-
-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
-}
-
-func IsParentAndChild(parentHeader *types.Header, header *types.Header) bool {
-	return header.ParentHash == parentHeader.Hash()
-}
-
-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:]
-}
-
-func BackwardFindReorgBlock(ctx context.Context, headers []*types.Header, client *ethclient.Client, header *types.Header) (int, bool, []*types.Header) {
-	maxStep := len(headers)
-	backwardHeaderList := []*types.Header{header}
-	for iterRound := 0; iterRound < maxStep; iterRound++ {
-		header, err := client.HeaderByHash(ctx, header.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
-			}
-		}
-	}
-	return -1, false, nil
-}
-
-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 {
-		dbTx.Rollback()
-		log.Crit("delete l1 cross msg from height", "height", reorgHeight, "err", err)
-	}
-	err = db.DeleteL1RelayedHashAfterHeightDBTx(dbTx, reorgHeight)
-	if err != nil {
-		dbTx.Rollback()
-		log.Crit("delete l1 relayed hash from height", "height", reorgHeight, "err", err)
-	}
-	err = dbTx.Commit()
-	if err != nil {
-		dbTx.Rollback()
-		log.Error("commit tx failed", "err", err)
-		return err
-	}
-	return nil
-}
-
-func L2ReorgHandling(ctx context.Context, reorgHeight int64, db db.OrmFactory) error {
-	dbTx, err := db.Beginx()
-	if err != nil {
-		dbTx.Rollback()
-		log.Crit("begin db tx failed", "err", err)
-	}
-	err = db.DeleteL2CrossMsgFromHeightDBTx(dbTx, reorgHeight)
-	if err != nil {
-		dbTx.Rollback()
-		log.Crit("delete l2 cross msg from height", "height", reorgHeight, "err", err)
-	}
-	err = db.DeleteL2RelayedHashAfterHeightDBTx(dbTx, reorgHeight)
-	if err != nil {
-		dbTx.Rollback()
-		log.Crit("delete l2 relayed hash from height", "height", reorgHeight, "err", err)
-	}
-	err = dbTx.Commit()
-	if err != nil {
-		dbTx.Rollback()
-		log.Error("commit tx failed", "err", err)
-		return err
-	}
-	return nil
-}

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

@@ -1,73 +0,0 @@
--- +goose Up
--- +goose StatementBegin
-create table cross_message
-(
-    id              BIGSERIAL PRIMARY KEY,
-    msg_hash        VARCHAR NOT NULL DEFAULT '',
-    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 '',
-    token_id        BIGINT NOT NULL DEFAULT 0,
-    asset           SMALLINT NOT NULL,
-    msg_type        SMALLINT NOT NULL,
-    is_deleted      BOOLEAN NOT NULL DEFAULT FALSE,
-    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
-);
-
-comment
-on column cross_message.asset is 'ETH, ERC20, ERC721, ERC1155';
-
-comment
-on column cross_message.msg_type is 'unknown, l1msg, l2msg';
-
-comment 
-on column cross_message.is_deleted is 'NotDeleted false, Deleted true';
-
-CREATE INDEX valid_l1_msg_index ON cross_message (layer1_hash, is_deleted);
-
-CREATE INDEX valid_l2_msg_index ON cross_message (layer2_hash, is_deleted);
-
-CREATE INDEX valid_height_index ON cross_message (height, msg_type, is_deleted);
-
-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();
-
-CREATE OR REPLACE FUNCTION deleted_at_trigger()
-RETURNS TRIGGER AS $$
-BEGIN
-    IF NEW.is_deleted AND OLD.is_deleted != NEW.is_deleted THEN
-        UPDATE cross_message SET deleted_at = NOW() WHERE id = NEW.id;
-    END IF;
-    RETURN NEW;
-END;
-$$ LANGUAGE plpgsql;
-
-CREATE TRIGGER deleted_at_trigger
-AFTER UPDATE ON cross_message
-FOR EACH ROW
-EXECUTE FUNCTION deleted_at_trigger();
-
-
--- +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,55 +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 '',
-    is_deleted  BOOLEAN NOT NULL DEFAULT FALSE,
-    created_at  TIMESTAMP(0) NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    updated_at  TIMESTAMP(0) NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    deleted_at  TIMESTAMP(0) DEFAULT NULL
-);
-
-comment 
-on column relayed_msg.is_deleted is 'NotDeleted, Deleted';
-
-create unique index relayed_msg_hash_uindex
-on relayed_msg (msg_hash);
-
-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();
-
-CREATE OR REPLACE FUNCTION deleted_at_trigger()
-RETURNS TRIGGER AS $$
-BEGIN
-    IF NEW.is_deleted AND OLD.is_deleted != NEW.is_deleted THEN
-        UPDATE relayed_msg SET deleted_at = NOW() WHERE id = NEW.id;
-    END IF;
-    RETURN NEW;
-END;
-$$ LANGUAGE plpgsql;
-
-CREATE TRIGGER deleted_at_trigger
-AFTER UPDATE ON relayed_msg
-FOR EACH ROW
-EXECUTE FUNCTION deleted_at_trigger();
-
-
--- +goose StatementEnd
-
--- +goose Down
--- +goose StatementBegin
-drop table if exists relayed_msg;
--- +goose StatementEnd

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

@@ -1,105 +0,0 @@
-package orm
-
-import (
-	"context"
-	"time"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/jmoiron/sqlx"
-)
-
-type AssetType int
-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 AssetType = iota
-	ERC20
-	ERC721
-	ERC1155
-)
-
-const (
-	UnknownMsg MsgType = iota
-	Layer1Msg
-	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"`
-	TokenID     uint64     `json:"token_id" db:"token_id"`
-	Asset       int        `json:"asset" db:"asset"`
-	MsgType     int        `json:"msg_type" db:"msg_type"`
-	IsDeleted   bool       `json:"is_deleted" db:"is_deleted"`
-	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"`
-}
-
-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"`
-}
-
-// 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
-	// UpdateL1CrossMsgHash 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 l2_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
-	// UpdateL2CrossMsgHash 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)
-}
-
-type RelayedMsgOrm interface {
-	BatchInsertRelayedMsgDBTx(dbTx *sqlx.Tx, messages []*RelayedMsg) error
-	GetRelayedMsgByHash(msg_hash string) (*RelayedMsg, error)
-	GetLatestRelayedHeightOnL1() (int64, error)
-	GetLatestRelayedHeightOnL2() (int64, error)
-	DeleteL1RelayedHashAfterHeightDBTx(dbTx *sqlx.Tx, height int64) error
-	DeleteL2RelayedHashAfterHeightDBTx(dbTx *sqlx.Tx, height int64) error
-}

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

@@ -1,140 +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 NOT is_deleted;`, 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 NOT is_deleted;`, sender.String(), Layer1Msg)
-
-	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,
-			"layer1_hash":  msg.Layer1Hash,
-			"layer1_token": msg.Layer1Token,
-			"layer2_token": msg.Layer2Token,
-			"token_id":     msg.TokenID,
-			"msg_type":     Layer1Msg,
-		}
-
-		_, err = dbTx.NamedExec(`insert into cross_message(height, sender, target, asset, layer1_hash, layer1_token, layer2_token, token_id, amount, msg_type) select :height, :sender, :target, :asset, :layer1_hash, :layer1_token, :layer2_token, :token_id, :amount, :msg_type WHERE NOT EXISTS (SELECT 1 FROM cross_message WHERE layer1_hash = :layer1_hash AND NOT is_deleted);`, messageMaps[i])
-		if err != nil {
-			log.Error("BatchInsertL1CrossMsgDBTx: failed to insert l1 cross msgs", "l1hashes", msg.Layer1Hash, "heights", msg.Height, "err", err)
-			break
-		}
-	}
-	return err
-}
-
-// 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 NOT is_deleted;"), 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 NOT is_deleted;"), 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 NOT is_deleted 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 is_deleted = true 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 NOT is_deleted`, 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 NOT is_deleted 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,143 +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 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 l2_cross_message WHERE layer2_hash = $1 AND NOT is_deleted;`, l2Hash.String())
-	if err := row.StructScan(result); err != nil {
-		if errors.Is(err, sql.ErrNoRows) {
-			return nil, nil
-		}
-		return nil, err
-	}
-	return result, nil
-}
-
-// GetL2CrossMsgsByAddress 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 NOT is_deleted;`, sender.String(), Layer2Msg)
-
-	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 is_deleted = true 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,
-			"layer2_hash":  msg.Layer2Hash,
-			"layer1_token": msg.Layer1Token,
-			"layer2_token": msg.Layer2Token,
-			"token_id":     msg.TokenID,
-			"amount":       msg.Amount,
-			"msg_type":     Layer2Msg,
-		}
-
-		_, err = dbTx.NamedExec(`insert into cross_message(height, sender, target, asset, layer2_hash, layer1_token, layer2_token, token_id, amount, msg_type) select :height, :sender, :target, :asset, :layer2_hash, :layer1_token, :layer2_token, :token_id, :amount, :msg_type WHERE NOT EXISTS (SELECT 1 FROM cross_message WHERE layer2_hash = :layer2_hash AND NOT is_deleted);`, messageMaps[i])
-		if err != nil {
-			log.Error("BatchInsertL2CrossMsgDBTx: failed to insert l2 cross msgs", "layer2hash", msg.Layer2Hash, "heights", msg.Height, "err", err)
-			break
-		}
-	}
-	return err
-}
-
-func (l *l2CrossMsgOrm) UpdateL2CrossMsgHashDBTx(ctx context.Context, dbTx *sqlx.Tx, l2Hash, msgHash common.Hash) error {
-	if _, err := dbTx.ExecContext(ctx, l.db.Rebind("update public.cross_message set msg_hash = ? where layer2_hash = ? AND NOT is_deleted;"), 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 public.cross_message set msg_hash = ? where layer2_hash = ? AND NOT is_deleted;"), 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 NOT is_deleted 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 NOT is_deleted`, 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 NOT is_deleted 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
-}

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

@@ -1,94 +0,0 @@
-package orm
-
-import (
-	"database/sql"
-	"errors"
-	"strings"
-
-	"github.com/ethereum/go-ethereum/log"
-	"github.com/jmoiron/sqlx"
-)
-
-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[i])
-		if err != nil && !strings.Contains(err.Error(), "pq: duplicate key value violates unique constraint \"relayed_msg_hash_uindex") {
-			log.Error("BatchInsertRelayedMsgDBTx: failed to insert l1 cross msgs", "msg_Hashe", msg.MsgHash, "height", msg.Height, "err", err)
-			break
-		}
-	}
-	return err
-}
-
-func (l *relayedMsgOrm) GetRelayedMsgByHash(msg_hash 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 NOT is_deleted;`, msg_hash)
-	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 NOT is_deleted 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 NOT is_deleted 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 is_deleted = true 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 is_deleted = true WHERE height > $1 AND layer2_hash != '';`, height)
-	return err
-}

bridge-history-api/db/orm_factory.go

@@ -1,91 +0,0 @@
-package db
-
-import (
-	"database/sql"
-	"errors"
-
-	"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
-	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
-	*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),
-		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 NOT is_deleted;`, 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 NOT is_deleted ORDER BY block_timestamp DESC NULLS FIRST, id DESC LIMIT $2 OFFSET $3;`, para, limit, offset)
-	if err != nil || rows == nil {
-		return nil, 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.21
 
 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.18
-	github.com/modern-go/reflect2 v1.0.2
-	github.com/pressly/goose/v3 v3.7.0
-	github.com/stretchr/testify v1.8.2
-	github.com/urfave/cli/v2 v2.17.2-0.20221006022127-8f469abc00aa
+	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.16.0
+	github.com/scroll-tech/go-ethereum v1.10.14-0.20240326144132-0f0cd99f7a2e
+	github.com/stretchr/testify v1.9.0
+	github.com/urfave/cli/v2 v2.25.7
+	golang.org/x/sync v0.6.0
+	gorm.io/gorm v1.25.5
 )
 
 require (
-	github.com/BurntSushi/toml v1.2.1 // 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.1 // 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.12.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.12.1 // indirect
+	github.com/cpuguy83/go-md2man/v2 v2.0.3 // indirect
+	github.com/crate-crypto/go-kzg-4844 v0.7.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 v1.8.0 // indirect
+	github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
+	github.com/docker/cli v25.0.1+incompatible // indirect
+	github.com/docker/docker v25.0.3+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/bindings/go v0.0.0-20230126171313-363c7d7593b4 // 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-kit/kit v0.9.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/protobuf v1.5.3 // 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/go-cmp v0.6.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.2.4 // indirect
+	github.com/huin/goupnp v1.3.0 // indirect
+	github.com/iden3/go-iden3-crypto v0.0.15 // 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/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.4 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.5 // 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/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/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/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/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.4.0 // indirect
+	github.com/prometheus/common v0.42.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/rjeczalik/notify v0.9.1 // indirect
 	github.com/rogpeppe/go-internal v1.10.0 // 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.7.1 // 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/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.11-0.20230124161941-ca03e11a3ff2 // 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.12 // indirect
+	github.com/tklauser/numcpus v0.6.1 // 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.9.0 // indirect
-	golang.org/x/exp v0.0.0-20230206171751-46f607a40771 // indirect
-	golang.org/x/net v0.10.0 // indirect
-	golang.org/x/sync v0.1.0 // indirect
-	golang.org/x/sys v0.8.0 // indirect
-	golang.org/x/text v0.9.0 // indirect
+	github.com/yusufpapurcu/wmi v1.2.3 // 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.17.0 // indirect
+	golang.org/x/mod v0.16.0 // indirect
+	golang.org/x/net v0.18.0 // indirect
+	golang.org/x/sys v0.17.0 // indirect
+	golang.org/x/text v0.14.0 // indirect
 	golang.org/x/time v0.3.0 // indirect
-	golang.org/x/tools v0.8.0 // indirect
-	golang.org/x/xerrors v0.0.0-20220517211312-f3a8303e98df // indirect
-	google.golang.org/protobuf v1.29.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.31.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,66 @@
+package config
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+
+	"scroll-tech/common/database"
+)
+
+// 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"`
+	ERC721GatewayAddr        string `json:"ERC721GatewayAddr"`
+	ERC1155GatewayAddr       string `json:"ERC1155GatewayAddr"`
+	ScrollChainAddr          string `json:"ScrollChainAddr"`
+	GatewayRouterAddr        string `json:"GatewayRouterAddr"`
+	MessageQueueAddr         string `json:"MessageQueueAddr"`
+}
+
+// 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
+	}
+
+	return cfg, nil
+}

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

@@ -0,0 +1,22 @@
+package api
+
+import (
+	"sync"
+
+	"github.com/go-redis/redis/v8"
+	"gorm.io/gorm"
+)
+
+var (
+	// HistoryCtrler is controller instance
+	HistoryCtrler *HistoryController
+
+	initControllerOnce sync.Once
+)
+
+// InitController inits Controller with database
+func InitController(db *gorm.DB, redis *redis.Client) {
+	initControllerOnce.Do(func() {
+		HistoryCtrler = NewHistoryController(db, redis)
+	})
+}

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

@@ -0,0 +1,94 @@
+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"
+)
+
+// HistoryController contains the query claimable txs service
+type HistoryController struct {
+	historyLogic *logic.HistoryLogic
+}
+
+// NewHistoryController return HistoryController instance
+func NewHistoryController(db *gorm.DB, redis *redis.Client) *HistoryController {
+	return &HistoryController{
+		historyLogic: logic.NewHistoryLogic(db, redis),
+	}
+}
+
+// GetL2UnclaimedWithdrawalsByAddress defines the http get method behavior
+func (c *HistoryController) 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)
+}
+
+// GetL2WithdrawalsByAddress defines the http get method behavior
+func (c *HistoryController) 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)
+}
+
+// GetTxsByAddress defines the http get method behavior
+func (c *HistoryController) 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)
+}
+
+// PostQueryTxsByHashes defines the http post method behavior
+func (c *HistoryController) 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,154 @@
+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"
+)
+
+// 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 {
+	c := &L1MessageFetcher{
+		ctx:              ctx,
+		cfg:              cfg,
+		client:           client,
+		eventUpdateLogic: logic.NewEventUpdateLogic(db, true),
+		l1FetcherLogic:   logic.NewL1FetcherLogic(cfg, db, client),
+	}
+
+	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
+}
+
+// Start starts the L1 message fetching process.
+func (c *L1MessageFetcher) Start() {
+	messageSyncedHeight, batchSyncedHeight, dbErr := c.eventUpdateLogic.GetL1SyncHeight(c.ctx)
+	if dbErr != nil {
+		log.Crit("L1MessageFetcher start failed", "err", dbErr)
+	}
+
+	l1SyncHeight := messageSyncedHeight
+	if batchSyncedHeight > l1SyncHeight {
+		l1SyncHeight = batchSyncedHeight
+	}
+	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, "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,153 @@
+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, dbErr := c.eventUpdateLogic.GetL2MessageSyncedHeightInDB(c.ctx)
+	if dbErr != nil {
+		log.Crit("failed to get L2 cross message processed height", "err", dbErr)
+		return
+	}
+
+	l2SyncHeight := l2SentMessageSyncedHeight
+	// 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", "message synced height", l2SentMessageSyncedHeight, "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.UpdateL1BatchIndexAndStatus(c.ctx, c.l2SyncHeight); 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,195 @@
+package logic
+
+import (
+	"context"
+	"fmt"
+
+	"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"
+	"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
+
+	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),
+	}
+
+	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, error) {
+	messageSyncedHeight, err := b.crossMessageOrm.GetMessageSyncedHeightInDB(ctx, orm.MessageTypeL1SentMessage)
+	if err != nil {
+		log.Error("failed to get L1 cross message synced height", "error", err)
+		return 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, err
+	}
+
+	return messageSyncedHeight, batchSyncedHeight, nil
+}
+
+// GetL2MessageSyncedHeightInDB gets L2 messages synced height
+func (b *EventUpdateLogic) GetL2MessageSyncedHeightInDB(ctx context.Context) (uint64, error) {
+	l2SentMessageSyncedHeight, err := b.crossMessageOrm.GetMessageSyncedHeightInDB(ctx, orm.MessageTypeL2SentMessage)
+	if err != nil {
+		log.Error("failed to get L2 cross message processed height", "err", err)
+		return 0, err
+	}
+	return l2SentMessageSyncedHeight, 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
+	}
+	return nil
+}
+
+func (b *EventUpdateLogic) updateL2WithdrawMessageInfos(ctx context.Context, batchIndex, startBlock, endBlock uint64) error {
+	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, "actuall next message nonce", l2WithdrawMessages[0].MessageNonce)
+		return fmt.Errorf("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(orm.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
+}
+
+// UpdateL1BatchIndexAndStatus updates L1 finalized batch index and status
+func (b *EventUpdateLogic) UpdateL1BatchIndexAndStatus(ctx context.Context, height uint64) error {
+	finalizedBatches, err := b.batchEventOrm.GetFinalizedBatchesLEBlockHeight(ctx, height)
+	if err != nil {
+		log.Error("failed to get batches >= block height", "error", err)
+		return err
+	}
+
+	for _, finalizedBatch := range finalizedBatches {
+		log.Info("update finalized batch info of L2 withdrawals", "index", finalizedBatch.BatchIndex, "start", finalizedBatch.StartBlockNumber, "end", finalizedBatch.EndBlockNumber)
+		if updateErr := b.updateL2WithdrawMessageInfos(ctx, finalizedBatch.BatchIndex, finalizedBatch.StartBlockNumber, finalizedBatch.EndBlockNumber); updateErr != nil {
+			log.Error("failed to update L2 withdraw message infos", "index", finalizedBatch.BatchIndex, "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, "start", finalizedBatch.StartBlockNumber, "end", finalizedBatch.EndBlockNumber, "error", dbErr)
+			return dbErr
+		}
+		b.eventUpdateLogicL1FinalizeBatchEventL2BlockUpdateHeight.Set(float64(finalizedBatch.EndBlockNumber))
+	}
+	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,407 @@
+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"
+	"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
+	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),
+		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 messages []*orm.CrossMessage
+		messages, err = h.crossMessageOrm.GetL2UnclaimedWithdrawalsByAddress(ctx, address)
+		if err != nil {
+			return nil, err
+		}
+		return messages, nil
+	})
+	if err != nil {
+		log.Error("failed to get L2 claimable withdrawals by address", "address", address, "error", err)
+		return nil, 0, err
+	}
+
+	messages, ok := result.([]*orm.CrossMessage)
+	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, messages, 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 messages []*orm.CrossMessage
+		messages, err = h.crossMessageOrm.GetL2WithdrawalsByAddress(ctx, address)
+		if err != nil {
+			return nil, err
+		}
+		return messages, nil
+	})
+	if err != nil {
+		log.Error("failed to get L2 withdrawals by address", "address", address, "error", err)
+		return nil, 0, err
+	}
+
+	messages, ok := result.([]*orm.CrossMessage)
+	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, messages, 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 messages []*orm.CrossMessage
+		messages, err = h.crossMessageOrm.GetTxsByAddress(ctx, address)
+		if err != nil {
+			return nil, err
+		}
+		return messages, nil
+	})
+	if err != nil {
+		log.Error("failed to get txs by address", "address", address, "error", err)
+		return nil, 0, err
+	}
+
+	messages, ok := result.([]*orm.CrossMessage)
+	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, messages, 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 {
+		messages, err := h.crossMessageOrm.GetMessagesByTxHashes(ctx, uncachedHashes)
+		if err != nil {
+			log.Error("failed to get messages by tx hashes", "hashes", uncachedHashes)
+			return nil, err
+		}
+
+		var txHistories []*types.TxHistoryInfo
+		for _, message := range messages {
+			txHistories = append(txHistories, getTxHistoryInfo(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 getTxHistoryInfo(message *orm.CrossMessage) *types.TxHistoryInfo {
+	txHistory := &types.TxHistoryInfo{
+		MessageHash:    message.MessageHash,
+		TokenType:      orm.TokenType(message.TokenType),
+		TokenIDs:       utils.ConvertStringToStringArray(message.TokenIDs),
+		TokenAmounts:   utils.ConvertStringToStringArray(message.TokenAmounts),
+		L1TokenAddress: message.L1TokenAddress,
+		L2TokenAddress: message.L2TokenAddress,
+		MessageType:    orm.MessageType(message.MessageType),
+		TxStatus:       orm.TxStatusType(message.TxStatus),
+		BlockTimestamp: message.BlockTimestamp,
+	}
+	if txHistory.MessageType == orm.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 orm.RollupStatusType(message.RollupStatus) == orm.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 (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.ZRange(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 indices.
+			for i, 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(i), 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, messages []*orm.CrossMessage, page, pageSize uint64) ([]*types.TxHistoryInfo, uint64, error) {
+	var txHistories []*types.TxHistoryInfo
+	for _, message := range messages {
+		txHistories = append(txHistories, getTxHistoryInfo(message))
+	}
+
+	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,320 @@
+package logic
+
+import (
+	"context"
+	"math/big"
+
+	"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"
+
+	backendabi "scroll-tech/bridge-history-api/abi"
+	"scroll-tech/bridge-history-api/internal/config"
+	"scroll-tech/bridge-history-api/internal/orm"
+	"scroll-tech/bridge-history-api/internal/utils"
+)
+
+// L1EventParser the l1 event parser
+type L1EventParser struct {
+	cfg    *config.FetcherConfig
+	client *ethclient.Client
+}
+
+// NewL1EventParser creates l1 event parser
+func NewL1EventParser(cfg *config.FetcherConfig, client *ethclient.Client) *L1EventParser {
+	return &L1EventParser{
+		cfg:    cfg,
+		client: client,
+	}
+}
+
+// ParseL1CrossChainEventLogs parses L1 watched cross chain events.
+func (e *L1EventParser) ParseL1CrossChainEventLogs(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(orm.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(orm.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(orm.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(orm.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(orm.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(orm.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.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(orm.TokenTypeETH),
+				L1TxHash:       vlog.TxHash.String(),
+				TokenAmounts:   event.Value.String(),
+				MessageNonce:   event.MessageNonce.Uint64(),
+				MessageType:    int(orm.MessageTypeL1SentMessage),
+				TxStatus:       int(orm.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(orm.TxStatusTypeRelayed),
+				MessageType:   int(orm.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(orm.TxStatusTypeFailedRelayed),
+				MessageType:   int(orm.MessageTypeL2SentMessage),
+			})
+		}
+	}
+	return l1DepositMessages, l1RelayedMessages, nil
+}
+
+// ParseL1BatchEventLogs parses L1 watched batch events.
+func (e *L1EventParser) ParseL1BatchEventLogs(ctx context.Context, logs []types.Log, client *ethclient.Client) ([]*orm.BatchEvent, error) {
+	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
+			}
+			commitTx, isPending, err := client.TransactionByHash(ctx, vlog.TxHash)
+			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
+			}
+			startBlock, endBlock, err := utils.GetBatchRangeFromCalldata(commitTx.Data())
+			if err != nil {
+				log.Error("Failed to get batch range from calldata", "hash", commitTx.Hash().String(), "height", vlog.BlockNumber)
+				return nil, err
+			}
+			l1BatchEvents = append(l1BatchEvents, &orm.BatchEvent{
+				BatchStatus:      int(orm.BatchStatusTypeCommitted),
+				BatchIndex:       event.BatchIndex.Uint64(),
+				BatchHash:        event.BatchHash.String(),
+				StartBlockNumber: startBlock,
+				EndBlockNumber:   endBlock,
+				L1BlockNumber:    vlog.BlockNumber,
+			})
+		case backendabi.L1RevertBatchEventSig:
+			event := backendabi.L1RevertBatchEvent{}
+			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(orm.BatchStatusTypeReverted),
+				BatchIndex:    event.BatchIndex.Uint64(),
+				BatchHash:     event.BatchHash.String(),
+				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(orm.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:   orm.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:  orm.MessageQueueEventTypeDequeueTransaction,
+					QueueIndex: index,
+				})
+			}
+		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:  orm.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
+}

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

@@ -0,0 +1,330 @@
+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"
+	"gorm.io/gorm"
+
+	backendabi "scroll-tech/bridge-history-api/abi"
+	"scroll-tech/bridge-history-api/internal/config"
+	"scroll-tech/bridge-history-api/internal/orm"
+	"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
+}
+
+// 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) *L1FetcherLogic {
+	addressList := []common.Address{
+		common.HexToAddress(cfg.ETHGatewayAddr),
+
+		common.HexToAddress(cfg.StandardERC20GatewayAddr),
+		common.HexToAddress(cfg.CustomERC20GatewayAddr),
+		common.HexToAddress(cfg.WETHGatewayAddr),
+		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.ETHGatewayAddr),
+
+		common.HexToAddress(cfg.StandardERC20GatewayAddr),
+		common.HexToAddress(cfg.CustomERC20GatewayAddr),
+		common.HexToAddress(cfg.WETHGatewayAddr),
+		common.HexToAddress(cfg.DAIGatewayAddr),
+
+		common.HexToAddress(cfg.ERC721GatewayAddr),
+		common.HexToAddress(cfg.ERC1155GatewayAddr),
+
+		common.HexToAddress(cfg.MessengerAddr),
+
+		common.HexToAddress(cfg.GatewayRouterAddr),
+	}
+
+	// Optional erc20 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))
+	}
+
+	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),
+	}
+
+	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) (map[uint64]uint64, []*orm.CrossMessage, error) {
+	var l1RevertedTxs []*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() {
+			// 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, 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, nil, senderErr
+			}
+
+			l1RevertedTxs = append(l1RevertedTxs, &orm.CrossMessage{
+				L1TxHash:       tx.Hash().String(),
+				MessageType:    int(orm.MessageTypeL1SentMessage),
+				Sender:         sender.String(),
+				Receiver:       (*tx.To()).String(),
+				L1BlockNumber:  receipt.BlockNumber.Uint64(),
+				BlockTimestamp: block.Time(),
+				TxStatus:       int(orm.TxStatusTypeSentTxReverted),
+			})
+		}
+	}
+	return blockTimestampsMap, 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, 13)
+	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.L1RevertBatchEventSig
+	query.Topics[0][9] = backendabi.L1FinalizeBatchEventSig
+	query.Topics[0][10] = backendabi.L1QueueTransactionEventSig
+	query.Topics[0][11] = backendabi.L1DequeueTransactionEventSig
+	query.Topics[0][12] = backendabi.L1DropTransactionEventSig
+
+	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
+	}
+
+	blockTimestampsMap, 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
+	}
+
+	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, 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)
+	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,
+	}
+
+	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 orm.TokenType(depositMessage.TokenType) {
+		case orm.TokenTypeETH:
+			f.l1FetcherLogicFetchedTotal.WithLabelValues("L1_deposit_eth").Add(1)
+		case orm.TokenTypeERC20:
+			f.l1FetcherLogicFetchedTotal.WithLabelValues("L1_deposit_erc20").Add(1)
+		case orm.TokenTypeERC721:
+			f.l1FetcherLogicFetchedTotal.WithLabelValues("L1_deposit_erc721").Add(1)
+		case orm.TokenTypeERC1155:
+			f.l1FetcherLogicFetchedTotal.WithLabelValues("L1_deposit_erc1155").Add(1)
+		}
+	}
+
+	for _, relayedMessage := range res.RelayedMessages {
+		switch orm.TxStatusType(relayedMessage.TxStatus) {
+		case orm.TxStatusTypeRelayed:
+			f.l1FetcherLogicFetchedTotal.WithLabelValues("L1_relayed_message").Add(1)
+		case orm.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 orm.BatchStatusType(batchEvent.BatchStatus) {
+		case orm.BatchStatusTypeCommitted:
+			f.l1FetcherLogicFetchedTotal.WithLabelValues("L1_commit_batch_event").Add(1)
+		case orm.BatchStatusTypeReverted:
+			f.l1FetcherLogicFetchedTotal.WithLabelValues("L1_revert_batch_event").Add(1)
+		case orm.BatchStatusTypeFinalized:
+			f.l1FetcherLogicFetchedTotal.WithLabelValues("L1_finalize_batch_event").Add(1)
+		}
+	}
+
+	for _, messageQueueEvent := range res.MessageQueueEvents {
+		switch messageQueueEvent.EventType {
+		case orm.MessageQueueEventTypeQueueTransaction: // sendMessage is filtered out, only leaving replayMessage or appendEnforcedTransaction.
+			f.l1FetcherLogicFetchedTotal.WithLabelValues("L1_replay_message_or_enforced_transaction").Add(1)
+		case orm.MessageQueueEventTypeDequeueTransaction:
+			f.l1FetcherLogicFetchedTotal.WithLabelValues("L1_skip_message").Add(1)
+		case orm.MessageQueueEventTypeDropTransaction:
+			f.l1FetcherLogicFetchedTotal.WithLabelValues("L1_drop_message").Add(1)
+		}
+	}
+}

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

@@ -0,0 +1,181 @@
+package logic
+
+import (
+	"context"
+
+	"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"
+	"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 watched events
+func (e *L2EventParser) ParseL2EventLogs(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(orm.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(orm.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(orm.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(orm.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(orm.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(orm.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(orm.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(orm.MessageTypeL2SentMessage),
+				TxStatus:       int(orm.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(orm.TxStatusTypeRelayed),
+				MessageType:   int(orm.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(orm.TxStatusTypeFailedRelayed),
+				MessageType:   int(orm.MessageTypeL1SentMessage),
+			})
+		}
+	}
+	return l2WithdrawMessages, l2RelayedMessages, nil
+}

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

@@ -0,0 +1,310 @@
+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"
+	"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.
+}
+
+// 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.WETHGatewayAddr),
+		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.WETHGatewayAddr),
+		common.HexToAddress(cfg.DAIGatewayAddr),
+
+		common.HexToAddress(cfg.ERC721GatewayAddr),
+		common.HexToAddress(cfg.ERC1155GatewayAddr),
+
+		common.HexToAddress(cfg.MessengerAddr),
+
+		common.HexToAddress(cfg.GatewayRouterAddr),
+	}
+
+	// Optional erc20 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.USDCGatewayAddr))
+	}
+
+	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(orm.TxStatusTypeRelayTxReverted),
+						L2BlockNumber: receipt.BlockNumber.Uint64(),
+						MessageType:   int(orm.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(orm.MessageTypeL2SentMessage),
+					Sender:         sender.String(),
+					Receiver:       (*tx.To()).String(),
+					L2BlockNumber:  receipt.BlockNumber.Uint64(),
+					BlockTimestamp: block.Time(),
+					TxStatus:       int(orm.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, 7)
+	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
+
+	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, 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,
+	}
+
+	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 orm.TokenType(withdrawMessage.TokenType) {
+		case orm.TokenTypeETH:
+			f.l2FetcherLogicFetchedTotal.WithLabelValues("L2_withdraw_eth").Add(1)
+		case orm.TokenTypeERC20:
+			f.l2FetcherLogicFetchedTotal.WithLabelValues("L2_withdraw_erc20").Add(1)
+		case orm.TokenTypeERC721:
+			f.l2FetcherLogicFetchedTotal.WithLabelValues("L2_withdraw_erc721").Add(1)
+		case orm.TokenTypeERC1155:
+			f.l2FetcherLogicFetchedTotal.WithLabelValues("L2_withdraw_erc1155").Add(1)
+		}
+	}
+
+	for _, relayedMessage := range res.RelayedMessages {
+		switch orm.TxStatusType(relayedMessage.TxStatus) {
+		case orm.TxStatusTypeRelayed:
+			f.l2FetcherLogicFetchedTotal.WithLabelValues("L2_relayed_message").Add(1)
+		case orm.TxStatusTypeFailedRelayed:
+			f.l2FetcherLogicFetchedTotal.WithLabelValues("L2_failed_relayed_message").Add(1)
+		case orm.TxStatusTypeRelayTxReverted:
+			f.l2FetcherLogicFetchedTotal.WithLabelValues("L2_reverted_relayed_message_transaction").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,144 @@
+package orm
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+)
+
+// 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
+)
+
+// 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 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
+}
+
+// GetFinalizedBatchesLEBlockHeight returns the finalized batches with end block <= given block height in db.
+func (c *BatchEvent) GetFinalizedBatchesLEBlockHeight(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 = ?", BatchStatusTypeFinalized)
+	db = db.Where("update_status = ?", UpdateStatusTypeUnupdated)
+	db = db.Order("batch_index asc")
+	if err := db.Find(&batches).Error; err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return nil, nil
+		}
+		return nil, fmt.Errorf("failed to get 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 BatchStatusType(l1BatchEvent.BatchStatus) {
+		case 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 BatchStatusTypeFinalized:
+			db = db.Where("batch_index = ?", l1BatchEvent.BatchIndex)
+			db = db.Where("batch_hash = ?", l1BatchEvent.BatchHash)
+			updateFields["batch_status"] = BatchStatusTypeFinalized
+			if err := db.Updates(updateFields).Error; err != nil {
+				return fmt.Errorf("failed to update batch event, error: %w", err)
+			}
+		case BatchStatusTypeReverted:
+			db = db.Where("batch_index = ?", l1BatchEvent.BatchIndex)
+			db = db.Where("batch_hash = ?", l1BatchEvent.BatchHash)
+			updateFields["batch_status"] = 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": 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/cross_message.go

@@ -0,0 +1,554 @@
+package orm
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/scroll-tech/go-ethereum/common"
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+)
+
+// 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
+)
+
+// 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.
+	// Retry: this often occurs due to an out of gas (OOG) issue if the transaction was initiated via the frontend.
+	TxStatusTypeFailedRelayed
+	// 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.
+)
+
+// 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
+)
+
+// MessageQueueEvent struct represents the details of a batch event.
+type MessageQueueEvent struct {
+	EventType  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 MessageType) (uint64, error) {
+	var message CrossMessage
+	db := c.db.WithContext(ctx)
+	db = db.Model(&CrossMessage{})
+	db = db.Where("message_type = ?", messageType)
+	switch {
+	case messageType == MessageTypeL1SentMessage:
+		db = db.Order("l1_block_number desc")
+	case messageType == MessageTypeL2SentMessage:
+		db = db.Order("l2_block_number desc")
+	}
+	if err := db.First(&message).Error; err != nil {
+		if 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 == MessageTypeL1SentMessage:
+		return message.L1BlockNumber, nil
+	case messageType == 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 = ?", MessageTypeL2SentMessage)
+	db = db.Where("rollup_status = ?", RollupStatusTypeFinalized)
+	db = db.Order("message_nonce desc")
+	if err := db.First(&message).Error; err != nil {
+		if 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 != ?", TxStatusTypeSentTxReverted)
+	db = db.Where("message_type = ?", MessageTypeL2SentMessage)
+	db = db.Order("message_nonce asc")
+	if err := db.Find(&messages).Error; err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return nil, nil
+		}
+		return nil, fmt.Errorf("failed to get latest L2 finalized sent message event, error: %w", 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 = ?", MessageTypeL2SentMessage)
+	db = db.Where("tx_status = ?", TxStatusTypeSent)
+	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 = ?", 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 MessageQueueEventTypeQueueTransaction:
+			continue
+		case MessageQueueEventTypeDequeueTransaction:
+			// do not over-write terminal statuses.
+			db = db.Where("tx_status != ?", TxStatusTypeRelayed)
+			db = db.Where("tx_status != ?", TxStatusTypeDropped)
+			db = db.Where("message_nonce = ?", l1MessageQueueEvent.QueueIndex)
+			db = db.Where("message_type = ?", MessageTypeL1SentMessage)
+			txStatusUpdateFields["tx_status"] = TxStatusTypeSkipped
+		case MessageQueueEventTypeDropTransaction:
+			// do not over-write terminal statuses.
+			db = db.Where("tx_status != ?", TxStatusTypeRelayed)
+			db = db.Where("tx_status != ?", TxStatusTypeDropped)
+			db = db.Where("message_nonce = ?", l1MessageQueueEvent.QueueIndex)
+			db = db.Where("message_type = ?", MessageTypeL1SentMessage)
+			txStatusUpdateFields["tx_status"] = TxStatusTypeDropped
+		}
+		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 MessageQueueEventTypeDequeueTransaction:
+			continue
+		case 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 MessageQueueEventTypeDropTransaction:
+			db = db.Where("message_nonce = ?", l1MessageQueueEvent.QueueIndex)
+			db = db.Where("message_type = ?", 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 = ?", 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"] = 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 TxStatusType(message.TxStatus) == 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: TxStatusTypeRelayed},
+					clause.Neq{Column: "cross_message_v2.tx_status", Value: 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 TxStatusType(message.TxStatus) == 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: TxStatusTypeRelayed},
+					clause.Neq{Column: "cross_message_v2.tx_status", Value: 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/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.HistoryCtrler.GetTxsByAddress)
+	r.GET("/l2/withdrawals", api.HistoryCtrler.GetL2WithdrawalsByAddress)
+	r.GET("/l2/unclaimed/withdrawals", api.HistoryCtrler.GetL2UnclaimedWithdrawalsByAddress)
+
+	r.POST("/txsbyhashes", api.HistoryCtrler.PostQueryTxsByHashes)
+}

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

@@ -0,0 +1,132 @@
+package types
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+
+	"scroll-tech/bridge-history-api/internal/orm"
+)
+
+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          orm.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        orm.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           orm.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"`
+}
+
+// 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,185 @@
+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 fmt.Errorf("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))
+}
+
+type commitBatchArgs struct {
+	Version                uint8
+	ParentBatchHeader      []byte
+	Chunks                 [][]byte
+	SkippedL1MessageBitmap []byte
+}
+
+// GetBatchRangeFromCalldata find the block range from calldata, both inclusive.
+func GetBatchRangeFromCalldata(calldata []byte) (uint64, uint64, error) {
+	method := backendabi.IScrollChainABI.Methods["commitBatch"]
+	values, err := method.Inputs.Unpack(calldata[4:])
+	if err != nil {
+		// special case: import genesis batch
+		method = backendabi.IScrollChainABI.Methods["importGenesisBatch"]
+		_, err2 := method.Inputs.Unpack(calldata[4:])
+		if err2 == nil {
+			// genesis batch
+			return 0, 0, nil
+		}
+		// none of "commitBatch" and "importGenesisBatch" match, give up
+		return 0, 0, err
+	}
+	args := commitBatchArgs{}
+	err = method.Inputs.Copy(&args, values)
+	if err != nil {
+		return 0, 0, err
+	}
+
+	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(args.Chunks) == 0 {
+		return 0, 0, errors.New("invalid chunks")
+	}
+	chunk := args.Chunks[0]
+	block := chunk[1:61] // first block in chunk
+	startBlock = binary.BigEndian.Uint64(block[0:8])
+
+	chunk = args.Chunks[len(args.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 startBlock, finishBlock, err
+}
+
+// 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/utils_test.go

@@ -0,0 +1,91 @@
+package utils
+
+import (
+	"math/big"
+	"testing"
+
+	"github.com/scroll-tech/go-ethereum/common"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestKeccak2(t *testing.T) {
+	a := common.HexToHash("0xe90b7bceb6e7df5418fb78d8ee546e97c83a08bbccc01a0644d599ccd2a7c2e0")
+	b := common.HexToHash("0x222ff5e0b5877792c2bc1670e2ccd0c2c97cd7bb1672a57d598db05092d3d72c")
+	c := Keccak2(a, b)
+	assert.NotEmpty(t, c)
+	assert.NotEqual(t, a, c)
+	assert.NotEqual(t, b, c)
+	assert.Equal(t, "0xc0ffbd7f501bd3d49721b0724b2bff657cb2378f15d5a9b97cd7ea5bf630d512", c.Hex())
+}
+
+func TestGetBatchRangeFromCalldata(t *testing.T) {
+	// single chunk
+	start, finish, err := GetBatchRangeFromCalldata(common.Hex2Bytes("1325aca000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000001a0000000000000000000000000000000000000000000000000000000000000005900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000003d0100000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000100000000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000000"))
+	assert.NoError(t, err)
+	assert.Equal(t, start, uint64(1))
+	assert.Equal(t, finish, uint64(1))
+
+	// multiple chunk
+	start, finish, err = GetBatchRangeFromCalldata(common.Hex2Bytes("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"))
+	assert.NoError(t, err)
+	assert.Equal(t, start, uint64(10))
+	assert.Equal(t, finish, uint64(20))
+
+	// genesis batch
+	start, finish, err = GetBatchRangeFromCalldata(common.Hex2Bytes("3fdeecb200000000000000000000000000000000000000000000000000000000000000402dcb5308098d24a37fc1487a229fcedb09fa4343ede39cbad365bc925535bb09000000000000000000000000000000000000000000000000000000000000005900000000000000000000000000000000000000000000000000c252bc9780c4d83cf11f14b8cd03c92c4d18ce07710ba836d31d12da216c8330000000000000000000000000000000000000000000000000000000000000000000000000000000"))
+	assert.NoError(t, err)
+	assert.Equal(t, start, uint64(0))
+	assert.Equal(t, finish, uint64(0))
+}
+
+// TestConvertBigIntArrayToString tests the ConvertBigIntArrayToString function
+func TestConvertBigIntArrayToString(t *testing.T) {
+	tests := []struct {
+		array    []*big.Int
+		expected string
+	}{
+		{[]*big.Int{big.NewInt(1), big.NewInt(2), big.NewInt(3)}, "1, 2, 3"},
+		{[]*big.Int{big.NewInt(0), big.NewInt(-1)}, "0, -1"},
+		{[]*big.Int{}, ""},
+	}
+
+	for _, test := range tests {
+		got := ConvertBigIntArrayToString(test.array)
+		assert.Equal(t, test.expected, got)
+	}
+}
+
+// TestConvertStringToStringArray tests the ConvertStringToStringArray function
+func TestConvertStringToStringArray(t *testing.T) {
+	tests := []struct {
+		s        string
+		expected []string
+	}{
+		{"1, 2, 3", []string{"1", "2", "3"}},
+		{" 4 , 5 , 6 ", []string{"4", "5", "6"}},
+		{"", []string{}},
+	}
+
+	for _, test := range tests {
+		got := ConvertStringToStringArray(test.s)
+		assert.Equal(t, test.expected, got)
+	}
+}
+
+// TestGetSkippedQueueIndices tests the GetSkippedQueueIndices function
+func TestGetSkippedQueueIndices(t *testing.T) {
+	tests := []struct {
+		startIndex uint64
+		bitmap     *big.Int
+		expected   []uint64
+	}{
+		{0, big.NewInt(0b101), []uint64{0, 2}},
+		{10, big.NewInt(0b110), []uint64{11, 12}},
+		{0, big.NewInt(0), nil}, // No bits set
+	}
+
+	for _, test := range tests {
+		got := GetSkippedQueueIndices(test.startIndex, test.bitmap)
+		assert.Equal(t, test.expected, got)
+	}
+}

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

@@ -1,12 +1,10 @@
-package cross_msg
+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,15 +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 {
@@ -88,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
@@ -96,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)
 	}
@@ -110,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
@@ -124,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])
@@ -133,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][:]...)
@@ -142,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
@@ -153,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
@@ -165,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
@@ -174,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,14 +1,11 @@
-package cross_msg_test
+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/cross_msg"
-	"bridge-history-api/utils"
 )
 
 func TestUpdateBranchWithNewMessage(t *testing.T) {
@@ -16,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])
 	}
 
-	cross_msg.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())
 	}
 
-	cross_msg.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())
 	}
 
-	cross_msg.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())
 	}
 
-	cross_msg.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 := cross_msg.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))
 	}
@@ -58,7 +55,7 @@ func TestDecodeEncodeMerkleProof(t *testing.T) {
 		t.Fatalf("proof[3] mismatch, want %s, got %s", "0x2ebffc1a6671c51e30777a680904b103992630ec995b6e6ff76a04d5259d4904", proof[0].Hex())
 	}
 
-	bytes := cross_msg.EncodeMerkleProofToBytes(proof)
+	bytes := encodeMerkleProofToBytes(proof)
 	if common.Bytes2Hex(bytes) != "2ebffc1a6671c51e30777a680904b103992630ec995b6e6ff76a04d5259d49012ebffc1a6671c51e30777a680904b103992630ec995b6e6ff76a04d5259d49022ebffc1a6671c51e30777a680904b103992630ec995b6e6ff76a04d5259d49032ebffc1a6671c51e30777a680904b103992630ec995b6e6ff76a04d5259d4904" {
 		t.Fatalf("wrong encoded bytes")
 	}
@@ -69,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 := cross_msg.UpdateBranchWithNewMessage(zeroes, branches, 0, common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000001"))
-	tmpBranches := cross_msg.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 = cross_msg.UpdateBranchWithNewMessage(zeroes, branches, 1, common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000002"))
-	tmpBranches = cross_msg.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 = cross_msg.UpdateBranchWithNewMessage(zeroes, branches, 2, common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000003"))
-	tmpBranches = cross_msg.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 = cross_msg.UpdateBranchWithNewMessage(zeroes, branches, 3, common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000004"))
-	tmpBranches = cross_msg.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())
@@ -107,7 +104,7 @@ func TestRecoverBranchFromProof(t *testing.T) {
 
 func TestWithdrawTrieOneByOne(t *testing.T) {
 	for initial := 0; initial < 128; initial++ {
-		withdrawTrie := cross_msg.NewWithdrawTrie()
+		withdrawTrie := NewWithdrawTrie()
 		var hashes []common.Hash
 		for i := 0; i < initial; i++ {
 			hash := common.BigToHash(big.NewInt(int64(i + 1)))
@@ -126,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 := cross_msg.DecodeBytesToMerkleProof(proofBytes[0])
+			proof := decodeBytesToMerkleProof(proofBytes[0])
 			verifiedRoot := verifyMerkleProof(uint64(i), hash, proof)
 			assert.Equal(t, expectedRoot.String(), verifiedRoot.String())
 		}
@@ -153,7 +150,7 @@ func TestWithdrawTrieMultiple(t *testing.T) {
 		}
 
 		for finish := initial; finish < 100; finish++ {
-			withdrawTrie := cross_msg.NewWithdrawTrie()
+			withdrawTrie := NewWithdrawTrie()
 			withdrawTrie.AppendMessages(hashes)
 
 			var newHashes []common.Hash
@@ -167,7 +164,7 @@ func TestWithdrawTrieMultiple(t *testing.T) {
 
 			for i := initial; i <= finish; i++ {
 				hash := common.BigToHash(big.NewInt(int64(i + 1)))
-				proof := cross_msg.DecodeBytesToMerkleProof(proofBytes[i-initial])
+				proof := decodeBytesToMerkleProof(proofBytes[i-initial])
 				verifiedRoot := verifyMerkleProof(uint64(i), hash, proof)
 				assert.Equal(t, expectedRoots[finish].String(), verifiedRoot.String())
 			}
@@ -179,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
 	}
@@ -201,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,11 +0,0 @@
-package model
-
-type QueryByAddressRequest struct {
-	Address string `url:"address"`
-	Offset  int    `url:"offset"`
-	Limit   int    `url:"limit"`
-}
-
-type QueryByHashRequest struct {
-	Txs []string `url:"txs"`
-}

bridge-history-api/model/response.go

@@ -1,18 +0,0 @@
-package model
-
-import "bridge-history-api/service"
-
-type Data struct {
-	Result []*service.TxHistoryInfo `json:"result"`
-	Total  uint64                   `json:"total"`
-}
-
-type QueryByAddressResponse struct {
-	Message string `json:"message"`
-	Data    *Data  `json:"data"`
-}
-
-type QueryByHashResponse struct {
-	Message string `json:"message"`
-	Data    *Data  `json:"data"`
-}

bridge-history-api/service/service.go

@@ -1,148 +0,0 @@
-package service
-
-import (
-	"time"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/log"
-
-	"bridge-history-api/db"
-	"bridge-history-api/db/orm"
-)
-
-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
-}
-
-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"`
-	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)
-}
-
-// 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
-}
-
-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
-	}
-
-}
-
-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: "",
-			},
-		}
-		updateCrossTxHash(msg.MsgHash, txHistory, h.db)
-		txHistories = append(txHistories, txHistory)
-	}
-	return txHistories, total, nil
-}
-
-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: "",
-				},
-			}
-			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/utils.go

@@ -1,108 +0,0 @@
-package utils
-
-import (
-	"bytes"
-	"context"
-	"errors"
-	"fmt"
-	"math/big"
-
-	"github.com/ethereum/go-ethereum/accounts/abi"
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/ethclient"
-
-	backendabi "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()[:]...)))
-}
-
-func GetSafeBlockNumber(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 fmt.Errorf("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.L2ScrollMessengerABI.Pack("relayMessage", sender, target, value, messageNonce, message)
-	return common.BytesToHash(crypto.Keccak256(data))
-}
-
-// GetBatchRangeFromCalldataV1 find the block range from calldata, both inclusive.
-func GetBatchRangeFromCalldataV1(calldata []byte) ([]uint64, []uint64, []uint64, error) {
-	var batchIndices []uint64
-	var startBlocks []uint64
-	var finishBlocks []uint64
-	if bytes.Equal(calldata[0:4], common.Hex2Bytes("cb905499")) {
-		// commitBatches
-		method := backendabi.ScrollChainABI.Methods["commitBatches"]
-		values, err := method.Inputs.Unpack(calldata[4:])
-		if err != nil {
-			return batchIndices, startBlocks, finishBlocks, err
-		}
-		args := make([]backendabi.IScrollChainBatch, len(values))
-		err = method.Inputs.Copy(&args, values)
-		if err != nil {
-			return batchIndices, startBlocks, finishBlocks, err
-		}
-
-		for i := 0; i < len(args); i++ {
-			batchIndices = append(batchIndices, args[i].BatchIndex)
-			startBlocks = append(startBlocks, args[i].Blocks[0].BlockNumber)
-			finishBlocks = append(finishBlocks, args[i].Blocks[len(args[i].Blocks)-1].BlockNumber)
-		}
-	} else if bytes.Equal(calldata[0:4], common.Hex2Bytes("8c73235d")) {
-		// commitBatch
-		method := backendabi.ScrollChainABI.Methods["commitBatch"]
-		values, err := method.Inputs.Unpack(calldata[4:])
-		if err != nil {
-			return batchIndices, startBlocks, finishBlocks, err
-		}
-
-		args := backendabi.IScrollChainBatch{}
-		err = method.Inputs.Copy(&args, values)
-		if err != nil {
-			return batchIndices, startBlocks, finishBlocks, err
-		}
-		batchIndices = append(batchIndices, args.BatchIndex)
-		startBlocks = append(startBlocks, args.Blocks[0].BlockNumber)
-		finishBlocks = append(finishBlocks, args.Blocks[len(args.Blocks)-1].BlockNumber)
-	} else {
-		return batchIndices, startBlocks, finishBlocks, errors.New("invalid selector")
-	}
-	return batchIndices, startBlocks, finishBlocks, nil
-}

bridge-history-api/utils/utils_test.go

@@ -1,48 +0,0 @@
-package utils_test
-
-import (
-	"os"
-	"testing"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/stretchr/testify/assert"
-
-	"bridge-history-api/utils"
-)
-
-func TestKeccak2(t *testing.T) {
-	a := common.HexToHash("0xe90b7bceb6e7df5418fb78d8ee546e97c83a08bbccc01a0644d599ccd2a7c2e0")
-	b := common.HexToHash("0x222ff5e0b5877792c2bc1670e2ccd0c2c97cd7bb1672a57d598db05092d3d72c")
-	c := utils.Keccak2(a, b)
-	assert.NotEmpty(t, c)
-	assert.NotEqual(t, a, c)
-	assert.NotEqual(t, b, c)
-	assert.Equal(t, "0xc0ffbd7f501bd3d49721b0724b2bff657cb2378f15d5a9b97cd7ea5bf630d512", c.Hex())
-}
-
-func TestGetBatchRangeFromCalldataV1(t *testing.T) {
-	calldata, err := os.ReadFile("../testdata/commit-batches-0x3095e91db7ba4a6fbf4654d607db322e58ff5579c502219c8024acaea74cf311.txt")
-	assert.NoError(t, err)
-
-	// multiple batches
-	batchIndices, startBlocks, finishBlocks, err := utils.GetBatchRangeFromCalldataV1(common.Hex2Bytes(string(calldata[:])))
-	assert.NoError(t, err)
-	assert.Equal(t, len(batchIndices), 5)
-	assert.Equal(t, len(startBlocks), 5)
-	assert.Equal(t, len(finishBlocks), 5)
-	assert.Equal(t, batchIndices[0], uint64(1))
-	assert.Equal(t, batchIndices[1], uint64(2))
-	assert.Equal(t, batchIndices[2], uint64(3))
-	assert.Equal(t, batchIndices[3], uint64(4))
-	assert.Equal(t, batchIndices[4], uint64(5))
-	assert.Equal(t, startBlocks[0], uint64(1))
-	assert.Equal(t, startBlocks[1], uint64(6))
-	assert.Equal(t, startBlocks[2], uint64(7))
-	assert.Equal(t, startBlocks[3], uint64(19))
-	assert.Equal(t, startBlocks[4], uint64(20))
-	assert.Equal(t, finishBlocks[0], uint64(5))
-	assert.Equal(t, finishBlocks[1], uint64(6))
-	assert.Equal(t, finishBlocks[2], uint64(18))
-	assert.Equal(t, finishBlocks[3], uint64(19))
-	assert.Equal(t, finishBlocks[4], uint64(20))
-}

bridge/README.md

@@ -1,36 +0,0 @@
-# Bridge
-
-This repo contains the Scroll bridge.
-
-In addition, launching the bridge will launch a separate instance of l2geth, and sets up a communication channel
-between the two, over JSON-RPC sockets.
-
-Something we should pay attention is that all private keys inside sender instance cannot be duplicated.
-
-## Dependency
-
-+ install `abigen`
-
-``` bash
-go install -v github.com/scroll-tech/go-ethereum/cmd/abigen
-```
-
-## Build
-
-```bash
-make clean
-make bridge
-```
-
-## Start
-* use default ports and config.json
-
-```bash
-./build/bin/bridge --http
-```
-
-* use specified ports and config.json
-
-```bash
-./build/bin/bridge --config ./config.json --http --http.addr localhost --http.port 8290
-```

bridge/abi/bridge_abi.go

@@ -1,242 +0,0 @@
-package bridgeabi
-
-import (
-	"math/big"
-
-	"github.com/scroll-tech/go-ethereum/accounts/abi"
-	"github.com/scroll-tech/go-ethereum/accounts/abi/bind"
-	"github.com/scroll-tech/go-ethereum/common"
-)
-
-var (
-	// ScrollChainABI holds information about ScrollChain's context and available invokable methods.
-	ScrollChainABI *abi.ABI
-	// L1ScrollMessengerABI holds information about L1ScrollMessenger's context and available invokable methods.
-	L1ScrollMessengerABI *abi.ABI
-	// L1MessageQueueABI holds information about L1MessageQueue contract's context and available invokable methods.
-	L1MessageQueueABI *abi.ABI
-	// L2GasPriceOracleABI holds information about L2GasPriceOracle's context and available invokable methods.
-	L2GasPriceOracleABI *abi.ABI
-
-	// L2ScrollMessengerABI holds information about L2ScrollMessenger's context and available invokable methods.
-	L2ScrollMessengerABI *abi.ABI
-	// L1BlockContainerABI holds information about L1BlockContainer contract's context and available invokable methods.
-	L1BlockContainerABI *abi.ABI
-	// L1GasPriceOracleABI holds information about L1GasPriceOracle's context and available invokable methods.
-	L1GasPriceOracleABI *abi.ABI
-	// L2MessageQueueABI holds information about L2MessageQueue contract's context and available invokable methods.
-	L2MessageQueueABI *abi.ABI
-
-	// L1SentMessageEventSignature = keccak256("SentMessage(address,address,uint256,uint256,uint256,bytes)")
-	L1SentMessageEventSignature common.Hash
-	// L1RelayedMessageEventSignature = keccak256("RelayedMessage(bytes32)")
-	L1RelayedMessageEventSignature common.Hash
-	// L1FailedRelayedMessageEventSignature = keccak256("FailedRelayedMessage(bytes32)")
-	L1FailedRelayedMessageEventSignature common.Hash
-
-	// L1CommitBatchEventSignature = keccak256("CommitBatch(bytes32)")
-	L1CommitBatchEventSignature common.Hash
-	// L1FinalizeBatchEventSignature = keccak256("FinalizeBatch(bytes32)")
-	L1FinalizeBatchEventSignature common.Hash
-
-	// L1QueueTransactionEventSignature = keccak256("QueueTransaction(address,address,uint256,uint256,uint256,bytes)")
-	L1QueueTransactionEventSignature common.Hash
-
-	// L2SentMessageEventSignature = keccak256("SentMessage(address,address,uint256,uint256,uint256,bytes,uint256,uint256)")
-	L2SentMessageEventSignature common.Hash
-	// L2RelayedMessageEventSignature = keccak256("RelayedMessage(bytes32)")
-	L2RelayedMessageEventSignature common.Hash
-	// L2FailedRelayedMessageEventSignature = keccak256("FailedRelayedMessage(bytes32)")
-	L2FailedRelayedMessageEventSignature common.Hash
-
-	// L2ImportBlockEventSignature = keccak256("ImportBlock(bytes32,uint256,uint256,uint256,bytes32)")
-	L2ImportBlockEventSignature common.Hash
-
-	// L2AppendMessageEventSignature = keccak256("AppendMessage(uint256,bytes32)")
-	L2AppendMessageEventSignature common.Hash
-)
-
-func init() {
-	ScrollChainABI, _ = ScrollChainMetaData.GetAbi()
-	L1ScrollMessengerABI, _ = L1ScrollMessengerMetaData.GetAbi()
-	L1MessageQueueABI, _ = L1MessageQueueMetaData.GetAbi()
-	L2GasPriceOracleABI, _ = L2GasPriceOracleMetaData.GetAbi()
-
-	L2ScrollMessengerABI, _ = L2ScrollMessengerMetaData.GetAbi()
-	L1BlockContainerABI, _ = L1BlockContainerMetaData.GetAbi()
-	L2MessageQueueABI, _ = L2MessageQueueMetaData.GetAbi()
-	L1GasPriceOracleABI, _ = L1GasPriceOracleMetaData.GetAbi()
-
-	L1SentMessageEventSignature = L1ScrollMessengerABI.Events["SentMessage"].ID
-	L1RelayedMessageEventSignature = L1ScrollMessengerABI.Events["RelayedMessage"].ID
-	L1FailedRelayedMessageEventSignature = L1ScrollMessengerABI.Events["FailedRelayedMessage"].ID
-
-	L1CommitBatchEventSignature = ScrollChainABI.Events["CommitBatch"].ID
-	L1FinalizeBatchEventSignature = ScrollChainABI.Events["FinalizeBatch"].ID
-
-	L1QueueTransactionEventSignature = L1MessageQueueABI.Events["QueueTransaction"].ID
-
-	L2SentMessageEventSignature = L2ScrollMessengerABI.Events["SentMessage"].ID
-	L2RelayedMessageEventSignature = L2ScrollMessengerABI.Events["RelayedMessage"].ID
-	L2FailedRelayedMessageEventSignature = L2ScrollMessengerABI.Events["FailedRelayedMessage"].ID
-
-	L2ImportBlockEventSignature = L1BlockContainerABI.Events["ImportBlock"].ID
-
-	L2AppendMessageEventSignature = L2MessageQueueABI.Events["AppendMessage"].ID
-}
-
-// Generated manually from abigen and only necessary events and mutable calls are kept.
-
-// ScrollChainMetaData contains all meta data concerning the ScrollChain contract.
-var ScrollChainMetaData = &bind.MetaData{
-	ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"batchHash\",\"type\":\"bytes32\"}],\"name\":\"CommitBatch\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"batchHash\",\"type\":\"bytes32\"}],\"name\":\"FinalizeBatch\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"batchHash\",\"type\":\"bytes32\"}],\"name\":\"RevertBatch\",\"type\":\"event\"},{\"inputs\":[{\"components\":[{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"blockHash\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"parentHash\",\"type\":\"bytes32\"},{\"internalType\":\"uint64\",\"name\":\"blockNumber\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"timestamp\",\"type\":\"uint64\"},{\"internalType\":\"uint256\",\"name\":\"baseFee\",\"type\":\"uint256\"},{\"internalType\":\"uint64\",\"name\":\"gasLimit\",\"type\":\"uint64\"},{\"internalType\":\"uint16\",\"name\":\"numTransactions\",\"type\":\"uint16\"},{\"internalType\":\"uint16\",\"name\":\"numL1Messages\",\"type\":\"uint16\"}],\"internalType\":\"structIScrollChain.BlockContext[]\",\"name\":\"blocks\",\"type\":\"tuple[]\"},{\"internalType\":\"bytes32\",\"name\":\"prevStateRoot\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"newStateRoot\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"withdrawTrieRoot\",\"type\":\"bytes32\"},{\"internalType\":\"uint64\",\"name\":\"batchIndex\",\"type\":\"uint64\"},{\"internalType\":\"bytes32\",\"name\":\"parentBatchHash\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"l2Transactions\",\"type\":\"bytes\"}],\"internalType\":\"structIScrollChain.Batch\",\"name\":\"batch\",\"type\":\"tuple\"}],\"name\":\"commitBatch\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"blockHash\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"parentHash\",\"type\":\"bytes32\"},{\"internalType\":\"uint64\",\"name\":\"blockNumber\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"timestamp\",\"type\":\"uint64\"},{\"internalType\":\"uint256\",\"name\":\"baseFee\",\"type\":\"uint256\"},{\"internalType\":\"uint64\",\"name\":\"gasLimit\",\"type\":\"uint64\"},{\"internalType\":\"uint16\",\"name\":\"numTransactions\",\"type\":\"uint16\"},{\"internalType\":\"uint16\",\"name\":\"numL1Messages\",\"type\":\"uint16\"}],\"internalType\":\"structIScrollChain.BlockContext[]\",\"name\":\"blocks\",\"type\":\"tuple[]\"},{\"internalType\":\"bytes32\",\"name\":\"prevStateRoot\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"newStateRoot\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"withdrawTrieRoot\",\"type\":\"bytes32\"},{\"internalType\":\"uint64\",\"name\":\"batchIndex\",\"type\":\"uint64\"},{\"internalType\":\"bytes32\",\"name\":\"parentBatchHash\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"l2Transactions\",\"type\":\"bytes\"}],\"internalType\":\"structIScrollChain.Batch[]\",\"name\":\"batches\",\"type\":\"tuple[]\"}],\"name\":\"commitBatches\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"batchId\",\"type\":\"bytes32\"},{\"internalType\":\"uint256[]\",\"name\":\"proof\",\"type\":\"uint256[]\"},{\"internalType\":\"uint256[]\",\"name\":\"instances\",\"type\":\"uint256[]\"}],\"name\":\"finalizeBatchWithProof\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"batchHash\",\"type\":\"bytes32\"}],\"name\":\"getL2MessageRoot\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"batchHash\",\"type\":\"bytes32\"}],\"name\":\"isBatchFinalized\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"batchId\",\"type\":\"bytes32\"}],\"name\":\"revertBatch\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]",
-}
-
-// L1ScrollMessengerMetaData contains all meta data concerning the L1ScrollMessenger contract.
-var L1ScrollMessengerMetaData = &bind.MetaData{
-	ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"messageHash\",\"type\":\"bytes32\"}],\"name\":\"FailedRelayedMessage\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"messageHash\",\"type\":\"bytes32\"}],\"name\":\"RelayedMessage\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"messageNonce\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasLimit\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"SentMessage\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"},{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"batchHash\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"merkleProof\",\"type\":\"bytes\"}],\"internalType\":\"structIL1ScrollMessenger.L2MessageProof\",\"name\":\"proof\",\"type\":\"tuple\"}],\"name\":\"relayMessageWithProof\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"queueIndex\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"},{\"internalType\":\"uint32\",\"name\":\"oldGasLimit\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"newGasLimit\",\"type\":\"uint32\"}],\"name\":\"replayMessage\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"gasLimit\",\"type\":\"uint256\"}],\"name\":\"sendMessage\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"xDomainMessageSender\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]",
-}
-
-// L1MessageQueueMetaData contains all meta data concerning the L1MessageQueue contract.
-var L1MessageQueueMetaData = &bind.MetaData{
-	ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"queueIndex\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasLimit\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"QueueTransaction\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"gasLimit\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"appendCrossDomainMessage\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"gasLimit\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"appendEnforcedTransaction\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"gasLimit\",\"type\":\"uint256\"}],\"name\":\"estimateCrossDomainMessageFee\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"queueIndex\",\"type\":\"uint256\"}],\"name\":\"getCrossDomainMessage\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"nextCrossDomainMessageIndex\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]",
-}
-
-// L2GasPriceOracleMetaData contains all meta data concerning the L2GasPriceOracle contract.
-var L2GasPriceOracleMetaData = &bind.MetaData{
-	ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"l2BaseFee\",\"type\":\"uint256\"}],\"name\":\"L2BaseFeeUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"_oldWhitelist\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"_newWhitelist\",\"type\":\"address\"}],\"name\":\"UpdateWhitelist\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"_gasLimit\",\"type\":\"uint256\"}],\"name\":\"estimateCrossDomainMessageFee\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"l2BaseFee\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_l2BaseFee\",\"type\":\"uint256\"}],\"name\":\"setL2BaseFee\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_newWhitelist\",\"type\":\"address\"}],\"name\":\"updateWhitelist\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"whitelist\",\"outputs\":[{\"internalType\":\"contract IWhitelist\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]",
-}
-
-// L2ScrollMessengerMetaData contains all meta data concerning the L2ScrollMessenger contract.
-var L2ScrollMessengerMetaData = &bind.MetaData{
-	ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"messageHash\",\"type\":\"bytes32\"}],\"name\":\"FailedRelayedMessage\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"messageHash\",\"type\":\"bytes32\"}],\"name\":\"RelayedMessage\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"messageNonce\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasLimit\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"SentMessage\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"relayMessage\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"},{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"blockHash\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"stateRootProof\",\"type\":\"bytes\"}],\"internalType\":\"structIL2ScrollMessenger.L1MessageProof\",\"name\":\"proof\",\"type\":\"tuple\"}],\"name\":\"retryMessageWithProof\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"gasLimit\",\"type\":\"uint256\"}],\"name\":\"sendMessage\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"xDomainMessageSender\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]",
-}
-
-// L1BlockContainerMetaData contains all meta data concerning the L1BlockContainer contract.
-var L1BlockContainerMetaData = &bind.MetaData{
-	ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"blockHash\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"blockHeight\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"blockTimestamp\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"baseFee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"stateRoot\",\"type\":\"bytes32\"}],\"name\":\"ImportBlock\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"blockHash\",\"type\":\"bytes32\"}],\"name\":\"getBlockTimestamp\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"timestamp\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"blockHash\",\"type\":\"bytes32\"}],\"name\":\"getStateRoot\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"stateRoot\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"blockHash\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"blockHeaderRLP\",\"type\":\"bytes\"},{\"internalType\":\"bool\",\"name\":\"updateGasPriceOracle\",\"type\":\"bool\"}],\"name\":\"importBlockHeader\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"latestBaseFee\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"latestBlockHash\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"latestBlockNumber\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"latestBlockTimestamp\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]",
-}
-
-// L2MessageQueueMetaData contains all meta data concerning the L2MessageQueue contract.
-var L2MessageQueueMetaData = &bind.MetaData{
-	ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"index\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"messageHash\",\"type\":\"bytes32\"}],\"name\":\"AppendMessage\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"_oldOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"_newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"_messageHash\",\"type\":\"bytes32\"}],\"name\":\"appendMessage\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"branches\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"messageRoot\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"messenger\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"nextMessageIndex\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_messenger\",\"type\":\"address\"}],\"name\":\"updateMessenger\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]",
-}
-
-// L1GasPriceOracleMetaData contains all meta data concerning the L1GasPriceOracle contract.
-var L1GasPriceOracleMetaData = &bind.MetaData{
-	ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"l1BaseFee\",\"type\":\"uint256\"}],\"name\":\"L1BaseFeeUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"overhead\",\"type\":\"uint256\"}],\"name\":\"OverheadUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"_oldOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"_newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"scalar\",\"type\":\"uint256\"}],\"name\":\"ScalarUpdated\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"_data\",\"type\":\"bytes\"}],\"name\":\"getL1Fee\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"_data\",\"type\":\"bytes\"}],\"name\":\"getL1GasUsed\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"l1BaseFee\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"overhead\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"scalar\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_l1BaseFee\",\"type\":\"uint256\"}],\"name\":\"setL1BaseFee\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_overhead\",\"type\":\"uint256\"}],\"name\":\"setOverhead\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_scalar\",\"type\":\"uint256\"}],\"name\":\"setScalar\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]",
-}
-
-// IL1ScrollMessengerL2MessageProof is an auto generated low-level Go binding around an user-defined struct.
-type IL1ScrollMessengerL2MessageProof struct {
-	BatchHash   common.Hash
-	MerkleProof []byte
-}
-
-// IScrollChainBatch is an auto generated low-level Go binding around an user-defined struct.
-type IScrollChainBatch struct {
-	Blocks           []IScrollChainBlockContext
-	PrevStateRoot    common.Hash
-	NewStateRoot     common.Hash
-	WithdrawTrieRoot common.Hash
-	BatchIndex       uint64
-	ParentBatchHash  common.Hash
-	L2Transactions   []byte
-}
-
-// IScrollChainBlockContext is an auto generated low-level Go binding around an user-defined struct.
-type IScrollChainBlockContext struct {
-	BlockHash       common.Hash
-	ParentHash      common.Hash
-	BlockNumber     uint64
-	Timestamp       uint64
-	BaseFee         *big.Int
-	GasLimit        uint64
-	NumTransactions uint16
-	NumL1Messages   uint16
-}
-
-// L1CommitBatchEvent represents a CommitBatch event raised by the ScrollChain contract.
-type L1CommitBatchEvent struct {
-	BatchHash common.Hash
-}
-
-// L1FinalizeBatchEvent represents a FinalizeBatch event raised by the ScrollChain contract.
-type L1FinalizeBatchEvent struct {
-	BatchHash common.Hash
-}
-
-// L1RevertBatchEvent represents a RevertBatch event raised by the ScrollChain contract.
-type L1RevertBatchEvent struct {
-	BatchHash common.Hash
-}
-
-// L1QueueTransactionEvent represents a QueueTransaction event raised by the L1MessageQueue contract.
-type L1QueueTransactionEvent struct {
-	Sender     common.Address
-	Target     common.Address
-	Value      *big.Int
-	QueueIndex *big.Int
-	GasLimit   *big.Int
-	Data       []byte
-}
-
-// L1SentMessageEvent represents a SentMessage event raised by the L1ScrollMessenger contract.
-type L1SentMessageEvent struct {
-	Sender       common.Address
-	Target       common.Address
-	Value        *big.Int
-	MessageNonce *big.Int
-	GasLimit     *big.Int
-	Message      []byte
-}
-
-// L1FailedRelayedMessageEvent represents a FailedRelayedMessage event raised by the L1ScrollMessenger contract.
-type L1FailedRelayedMessageEvent struct {
-	MessageHash common.Hash
-}
-
-// L1RelayedMessageEvent represents a RelayedMessage event raised by the L1ScrollMessenger contract.
-type L1RelayedMessageEvent struct {
-	MessageHash common.Hash
-}
-
-// L2AppendMessageEvent represents a AppendMessage event raised by the L2MessageQueue contract.
-type L2AppendMessageEvent struct {
-	Index       *big.Int
-	MessageHash common.Hash
-}
-
-// L2ImportBlockEvent represents a ImportBlock event raised by the L1BlockContainer contract.
-type L2ImportBlockEvent struct {
-	BlockHash      common.Hash
-	BlockHeight    *big.Int
-	BlockTimestamp *big.Int
-	BaseFee        *big.Int
-	StateRoot      common.Hash
-}
-
-// L2SentMessageEvent represents a SentMessage event raised by the L2ScrollMessenger contract.
-type L2SentMessageEvent struct {
-	Sender       common.Address
-	Target       common.Address
-	Value        *big.Int
-	MessageNonce *big.Int
-	GasLimit     *big.Int
-	Message      []byte
-}
-
-// L2FailedRelayedMessageEvent represents a FailedRelayedMessage event raised by the L2ScrollMessenger contract.
-type L2FailedRelayedMessageEvent struct {
-	MessageHash common.Hash
-}
-
-// L2RelayedMessageEvent represents a RelayedMessage event raised by the L2ScrollMessenger contract.
-type L2RelayedMessageEvent struct {
-	MessageHash common.Hash
-}
-
-// GetBatchCalldataLength gets the calldata bytelen of IScrollChainBatch.
-func GetBatchCalldataLength(batch *IScrollChainBatch) uint64 {
-	return uint64(5*32 + len(batch.L2Transactions) + len(batch.Blocks)*8*32)
-}

bridge/cmd/event_watcher/main.go

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

bridge/cmd/gas_oracle/main.go

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

bridge/cmd/mock_app.go

@@ -1,106 +0,0 @@
-package app
-
-import (
-	"encoding/json"
-	"fmt"
-	"os"
-	"testing"
-	"time"
-
-	"scroll-tech/common/cmd"
-	"scroll-tech/common/docker"
-	"scroll-tech/common/utils"
-
-	"scroll-tech/bridge/internal/config"
-)
-
-// MockApp mockApp-test client manager.
-type MockApp struct {
-	Config *config.Config
-	base   *docker.App
-
-	mockApps map[utils.MockAppName]docker.AppAPI
-
-	originFile string
-	bridgeFile string
-
-	args []string
-}
-
-// NewBridgeApp return a new bridgeApp manager, name mush be one them.
-func NewBridgeApp(base *docker.App, file string) *MockApp {
-
-	bridgeFile := fmt.Sprintf("/tmp/%d_bridge-config.json", base.Timestamp)
-	bridgeApp := &MockApp{
-		base:       base,
-		mockApps:   make(map[utils.MockAppName]docker.AppAPI),
-		originFile: file,
-		bridgeFile: bridgeFile,
-		args:       []string{"--log.debug", "--config", bridgeFile},
-	}
-	if err := bridgeApp.MockConfig(true); err != nil {
-		panic(err)
-	}
-	return bridgeApp
-}
-
-// RunApp run bridge-test child process by multi parameters.
-func (b *MockApp) RunApp(t *testing.T, name utils.MockAppName, args ...string) {
-	if !(name == utils.EventWatcherApp ||
-		name == utils.GasOracleApp ||
-		name == utils.MessageRelayerApp ||
-		name == utils.RollupRelayerApp) {
-		t.Errorf(fmt.Sprintf("Don't support the mock app, name: %s", name))
-		return
-	}
-
-	if app, ok := b.mockApps[name]; ok {
-		t.Logf(fmt.Sprintf("%s already exist, free the current and recreate again", string(name)))
-		app.WaitExit()
-	}
-	appAPI := cmd.NewCmd(string(name), append(b.args, args...)...)
-	keyword := fmt.Sprintf("Start %s successfully", string(name)[:len(string(name))-len("-test")])
-	appAPI.RunApp(func() bool { return appAPI.WaitResult(t, time.Second*20, keyword) })
-	b.mockApps[name] = appAPI
-}
-
-// WaitExit wait util all processes exit.
-func (b *MockApp) WaitExit() {
-	for _, app := range b.mockApps {
-		app.WaitExit()
-	}
-	b.mockApps = make(map[utils.MockAppName]docker.AppAPI)
-}
-
-// Free stop and release bridge mocked apps.
-func (b *MockApp) Free() {
-	b.WaitExit()
-	_ = os.Remove(b.bridgeFile)
-}
-
-// MockConfig creates a new bridge config.
-func (b *MockApp) MockConfig(store bool) error {
-	base := b.base
-	// Load origin bridge config file.
-	cfg, err := config.NewConfig(b.originFile)
-	if err != nil {
-		return err
-	}
-
-	cfg.L1Config.Endpoint = base.L1gethImg.Endpoint()
-	cfg.L2Config.RelayerConfig.SenderConfig.Endpoint = base.L1gethImg.Endpoint()
-	cfg.L2Config.Endpoint = base.L2gethImg.Endpoint()
-	cfg.L1Config.RelayerConfig.SenderConfig.Endpoint = base.L2gethImg.Endpoint()
-	cfg.DBConfig.DSN = base.DBImg.Endpoint()
-	b.Config = cfg
-
-	if !store {
-		return nil
-	}
-	// Store changed bridge config into a temp file.
-	data, err := json.Marshal(b.Config)
-	if err != nil {
-		return err
-	}
-	return os.WriteFile(b.bridgeFile, data, 0600)
-}

bridge/cmd/msg_relayer/app/app.go

@@ -1,109 +0,0 @@
-package app
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"os/signal"
-	"time"
-
-	"github.com/scroll-tech/go-ethereum/ethclient"
-	"github.com/scroll-tech/go-ethereum/log"
-	"github.com/urfave/cli/v2"
-
-	"scroll-tech/common/metrics"
-	cutils "scroll-tech/common/utils"
-	"scroll-tech/common/version"
-
-	"scroll-tech/bridge/internal/config"
-	"scroll-tech/bridge/internal/controller/relayer"
-	"scroll-tech/bridge/internal/utils"
-)
-
-var app *cli.App
-
-func init() {
-	// Set up message-relayer app info.
-	app = cli.NewApp()
-	app.Action = action
-	app.Name = "message-relayer"
-	app.Usage = "The Scroll Message Relayer"
-	app.Description = "Message Relayer contains two main service: 1) relay l1 message to l2. 2) relay l2 message to l1."
-	app.Version = version.Version
-	app.Flags = append(app.Flags, cutils.CommonFlags...)
-	app.Commands = []*cli.Command{}
-	app.Before = func(ctx *cli.Context) error {
-		return cutils.LogSetup(ctx)
-	}
-	// Register `message-relayer-test` app for integration-test.
-	cutils.RegisterSimulation(app, cutils.MessageRelayerApp)
-}
-
-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)
-	// Init db connection
-	db, err := utils.InitDB(cfg.DBConfig)
-	if err != nil {
-		log.Crit("failed to init db connection", "err", err)
-	}
-	defer func() {
-		cancel()
-		if err = utils.CloseDB(db); err != nil {
-			log.Error("can not close ormFactory", "error", err)
-		}
-	}()
-
-	// Start metrics server.
-	metrics.Serve(subCtx, ctx)
-
-	// Init l2geth connection
-	l2client, err := ethclient.Dial(cfg.L2Config.Endpoint)
-	if err != nil {
-		log.Error("failed to connect l2 geth", "config file", cfgFile, "error", err)
-		return err
-	}
-
-	l1relayer, err := relayer.NewLayer1Relayer(ctx.Context, db, cfg.L1Config.RelayerConfig)
-	if err != nil {
-		log.Error("failed to create new l1 relayer", "config file", cfgFile, "error", err)
-		return err
-	}
-	l2relayer, err := relayer.NewLayer2Relayer(ctx.Context, l2client, db, cfg.L2Config.RelayerConfig)
-	if err != nil {
-		log.Error("failed to create new l2 relayer", "config file", cfgFile, "error", err)
-		return err
-	}
-
-	// Start l1relayer process
-	go cutils.Loop(subCtx, 10*time.Second, l1relayer.ProcessSavedEvents)
-
-	// Start l2relayer process
-	go cutils.Loop(subCtx, 2*time.Second, l2relayer.ProcessSavedEvents)
-
-	// Finish start all message relayer functions
-	log.Info("Start message-relayer successfully")
-
-	// 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 message_relayer cmd instance.
-func Run() {
-	if err := app.Run(os.Args); err != nil {
-		_, _ = fmt.Fprintln(os.Stderr, err)
-		os.Exit(1)
-	}
-}

bridge/cmd/msg_relayer/main.go

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

bridge/cmd/rollup_relayer/app/app.go

@@ -1,124 +0,0 @@
-package app
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"os/signal"
-	"time"
-
-	"github.com/scroll-tech/go-ethereum/ethclient"
-	"github.com/scroll-tech/go-ethereum/log"
-	"github.com/urfave/cli/v2"
-
-	"scroll-tech/common/metrics"
-	cutils "scroll-tech/common/utils"
-	"scroll-tech/common/version"
-
-	"scroll-tech/bridge/internal/config"
-	"scroll-tech/bridge/internal/controller/relayer"
-	"scroll-tech/bridge/internal/controller/watcher"
-	"scroll-tech/bridge/internal/utils"
-)
-
-var app *cli.App
-
-func init() {
-	// Set up rollup-relayer app info.
-	app = cli.NewApp()
-	app.Action = action
-	app.Name = "rollup-relayer"
-	app.Usage = "The Scroll Rollup Relayer"
-	app.Version = version.Version
-	app.Flags = append(app.Flags, cutils.CommonFlags...)
-	app.Commands = []*cli.Command{}
-	app.Before = func(ctx *cli.Context) error {
-		return cutils.LogSetup(ctx)
-	}
-	// Register `rollup-relayer-test` app for integration-test.
-	cutils.RegisterSimulation(app, cutils.RollupRelayerApp)
-}
-
-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)
-	// Init db connection
-	db, err := utils.InitDB(cfg.DBConfig)
-	if err != nil {
-		log.Crit("failed to init db connection", "err", err)
-	}
-	defer func() {
-		cancel()
-		if err = utils.CloseDB(db); err != nil {
-			log.Error("can not close ormFactory", "error", err)
-		}
-	}()
-
-	// Start metrics server.
-	metrics.Serve(subCtx, ctx)
-
-	// Init l2geth connection
-	l2client, err := ethclient.Dial(cfg.L2Config.Endpoint)
-	if err != nil {
-		log.Error("failed to connect l2 geth", "config file", cfgFile, "error", err)
-		return err
-	}
-
-	l2relayer, err := relayer.NewLayer2Relayer(ctx.Context, l2client, db, cfg.L2Config.RelayerConfig)
-	if err != nil {
-		log.Error("failed to create l2 relayer", "config file", cfgFile, "error", err)
-		return err
-	}
-
-	batchProposer := watcher.NewBatchProposer(subCtx, cfg.L2Config.BatchProposerConfig, l2relayer, db)
-	if err != nil {
-		log.Error("failed to create batchProposer", "config file", cfgFile, "error", err)
-		return err
-	}
-
-	l2watcher := watcher.NewL2WatcherClient(subCtx, l2client, cfg.L2Config.Confirmations, cfg.L2Config.L2MessengerAddress, cfg.L2Config.L2MessageQueueAddress, cfg.L2Config.WithdrawTrieRootSlot, db)
-
-	// Watcher loop to fetch missing blocks
-	go cutils.LoopWithContext(subCtx, 2*time.Second, func(ctx context.Context) {
-		number, loopErr := utils.GetLatestConfirmedBlockNumber(ctx, l2client, cfg.L2Config.Confirmations)
-		if loopErr != nil {
-			log.Error("failed to get block number", "err", loopErr)
-			return
-		}
-		l2watcher.TryFetchRunningMissingBlocks(ctx, number)
-	})
-
-	// Batch proposer loop
-	go cutils.Loop(subCtx, 2*time.Second, func() {
-		batchProposer.TryProposeBatch()
-		batchProposer.TryCommitBatches()
-	})
-
-	go cutils.Loop(subCtx, 2*time.Second, l2relayer.ProcessCommittedBatches)
-
-	// Finish start all rollup relayer functions.
-	log.Info("Start rollup-relayer successfully")
-
-	// 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 rollup relayer cmd instance.
-func Run() {
-	if err := app.Run(os.Args); err != nil {
-		_, _ = fmt.Fprintln(os.Stderr, err)
-		os.Exit(1)
-	}
-}

bridge/cmd/rollup_relayer/main.go

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

bridge/conf/config.json

@@ -1,96 +0,0 @@
-{
-  "l1_config": {
-    "confirmations": "0x6",
-    "endpoint": "DUMMY_ENDPOINT",
-    "l1_messenger_address": "0x0000000000000000000000000000000000000000",
-    "l1_message_queue_address": "0x0000000000000000000000000000000000000000",
-    "scroll_chain_address": "0x0000000000000000000000000000000000000000",
-    "start_height": 0,
-    "relayer_config": {
-      "messenger_contract_address": "0x0000000000000000000000000000000000000000",
-      "gas_price_oracle_address": "0x0000000000000000000000000000000000000000",
-      "sender_config": {
-        "endpoint": "/var/lib/jenkins/workspace/SequencerPipeline/MyPrivateNetwork/geth.ipc",
-        "check_pending_time": 2,
-        "check_balance_time": 100,
-        "escalate_blocks": 100,
-        "confirmations": "0x1",
-        "escalate_multiple_num": 11,
-        "escalate_multiple_den": 10,
-        "max_gas_price": 10000000000,
-        "tx_type": "LegacyTx",
-        "min_balance": 100000000000000000000,
-        "pending_limit": 10
-      },
-      "gas_oracle_config": {
-        "min_gas_price": 0,
-        "gas_price_diff": 50000
-      },
-      "finalize_batch_interval_sec": 0,
-      "message_sender_private_keys": [
-        "1212121212121212121212121212121212121212121212121212121212121212"
-      ],
-      "gas_oracle_sender_private_keys": [
-        "1313131313131313131313131313131313131313131313131313131313131313"
-      ]
-    }
-  },
-  "l2_config": {
-    "confirmations": "0x1",
-    "endpoint": "/var/lib/jenkins/workspace/SequencerPipeline/MyPrivateNetwork/geth.ipc",
-    "l2_messenger_address": "0x0000000000000000000000000000000000000000",
-    "l2_message_queue_address": "0x0000000000000000000000000000000000000000",
-    "relayer_config": {
-      "rollup_contract_address": "0x0000000000000000000000000000000000000000",
-      "messenger_contract_address": "0x0000000000000000000000000000000000000000",
-      "gas_price_oracle_address": "0x0000000000000000000000000000000000000000",
-      "sender_config": {
-        "endpoint": "DUMMY_ENDPOINT",
-        "check_pending_time": 10,
-        "check_balance_time": 100,
-        "escalate_blocks": 100,
-        "confirmations": "0x6",
-        "escalate_multiple_num": 11,
-        "escalate_multiple_den": 10,
-        "max_gas_price": 10000000000,
-        "tx_type": "LegacyTx",
-        "min_balance": 100000000000000000000,
-        "pending_limit": 10
-      },
-      "gas_oracle_config": {
-        "min_gas_price": 0,
-        "gas_price_diff": 50000
-      },
-      "finalize_batch_interval_sec": 0,
-      "message_sender_private_keys": [
-        "1212121212121212121212121212121212121212121212121212121212121212"
-      ],
-      "gas_oracle_sender_private_keys": [
-        "1313131313131313131313131313131313131313131313131313131313131313"
-      ],
-      "rollup_sender_private_keys": [
-        "1414141414141414141414141414141414141414141414141414141414141414"
-      ]
-    },
-    "batch_proposer_config": {
-      "proof_generation_freq": 1,
-      "batch_gas_threshold": 3000000,
-      "batch_tx_num_threshold": 44,
-      "batch_time_sec": 300,
-      "batch_commit_time_sec": 1200,
-      "batch_blocks_limit": 100,
-      "commit_tx_calldata_size_limit": 200000,
-      "commit_tx_batch_count_limit": 30,
-      "public_input_config": {
-        "max_tx_num": 44,
-        "padding_tx_hash": "0x0000000000000000000000000000000000000000000000000000000000000000"
-      }
-    }
-  },
-  "db_config": {
-    "driver_name": "postgres",
-    "dsn": "postgres://admin:123456@localhost/test?sslmode=disable",
-    "maxOpenNum": 200,
-    "maxIdleNum": 20
-  }
-}

bridge/go.mod

@@ -1,72 +0,0 @@
-module scroll-tech/bridge
-
-go 1.19
-
-require (
-	github.com/agiledragon/gomonkey/v2 v2.9.0
-	github.com/jmoiron/sqlx v1.3.5
-	github.com/lib/pq v1.10.7
-	github.com/orcaman/concurrent-map v1.0.0
-	github.com/orcaman/concurrent-map/v2 v2.0.1
-	github.com/pressly/goose/v3 v3.7.0
-	github.com/scroll-tech/go-ethereum v1.10.14-0.20230508165858-27a3830afa61
-	github.com/smartystreets/goconvey v1.8.0
-	github.com/stretchr/testify v1.8.2
-	github.com/urfave/cli/v2 v2.17.2-0.20221006022127-8f469abc00aa
-	golang.org/x/sync v0.1.0
-	gorm.io/driver/postgres v1.5.0
-	gorm.io/gorm v1.25.1
-	modernc.org/mathutil v1.4.1
-)
-
-require (
-	github.com/btcsuite/btcd v0.20.1-beta // indirect
-	github.com/cespare/xxhash/v2 v2.2.0 // indirect
-	github.com/cpuguy83/go-md2man/v2 v2.0.2 // indirect
-	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/deckarep/golang-set v1.8.0 // indirect
-	github.com/go-ole/go-ole v1.2.6 // indirect
-	github.com/go-sql-driver/mysql v1.7.0 // indirect
-	github.com/go-stack/stack v1.8.1 // indirect
-	github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb // indirect
-	github.com/google/uuid v1.3.0 // indirect
-	github.com/gopherjs/gopherjs v1.17.2 // indirect
-	github.com/gorilla/websocket v1.5.0 // indirect
-	github.com/holiman/uint256 v1.2.2 // indirect
-	github.com/huin/goupnp v1.0.3 // indirect
-	github.com/iden3/go-iden3-crypto v0.0.15 // indirect
-	github.com/jackc/pgpassfile v1.0.0 // indirect
-	github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a // indirect
-	github.com/jackc/pgx/v5 v5.3.0 // indirect
-	github.com/jackpal/go-nat-pmp v1.0.2 // indirect
-	github.com/jinzhu/inflection v1.0.0 // indirect
-	github.com/jinzhu/now v1.1.5 // indirect
-	github.com/jtolds/gls v4.20.0+incompatible // indirect
-	github.com/kr/pretty v0.3.1 // indirect
-	github.com/mattn/go-colorable v0.1.13 // indirect
-	github.com/mattn/go-isatty v0.0.18 // indirect
-	github.com/mattn/go-runewidth v0.0.14 // indirect
-	github.com/mattn/go-sqlite3 v1.14.14 // indirect
-	github.com/pmezard/go-difflib v1.0.0 // indirect
-	github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0 // indirect
-	github.com/rivo/uniseg v0.4.4 // indirect
-	github.com/rjeczalik/notify v0.9.1 // indirect
-	github.com/rogpeppe/go-internal v1.10.0 // indirect
-	github.com/russross/blackfriday/v2 v2.1.0 // indirect
-	github.com/scroll-tech/zktrie v0.5.3 // indirect
-	github.com/shirou/gopsutil v3.21.11+incompatible // indirect
-	github.com/smartystreets/assertions v1.13.1 // indirect
-	github.com/status-im/keycard-go v0.2.0 // indirect
-	github.com/tklauser/go-sysconf v0.3.11 // indirect
-	github.com/tklauser/numcpus v0.6.0 // indirect
-	github.com/tyler-smith/go-bip39 v1.1.0 // indirect
-	github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 // indirect
-	github.com/yusufpapurcu/wmi v1.2.2 // indirect
-	golang.org/x/crypto v0.9.0 // indirect
-	golang.org/x/sys v0.8.0 // indirect
-	golang.org/x/text v0.9.0 // indirect
-	golang.org/x/time v0.3.0 // indirect
-	golang.org/x/tools v0.8.0 // indirect
-	gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce // indirect
-	gopkg.in/yaml.v3 v3.0.1 // indirect
-)

bridge/go.sum

@@ -1,254 +0,0 @@
-github.com/VictoriaMetrics/fastcache v1.6.0 h1:C/3Oi3EiBCqufydp1neRZkqcwmEiuRT9c3fqvvgKm5o=
-github.com/aead/siphash v1.0.1/go.mod h1:Nywa3cDsYNNK3gaciGTWPwHt0wlpNV15vwmswBAUSII=
-github.com/agiledragon/gomonkey/v2 v2.9.0 h1:PDiKKybR596O6FHW+RVSG0Z7uGCBNbmbUXh3uCNQ7Hc=
-github.com/agiledragon/gomonkey/v2 v2.9.0/go.mod h1:ap1AmDzcVOAz1YpeJ3TCzIgstoaWLA6jbbgxfB4w2iY=
-github.com/btcsuite/btcd v0.20.1-beta h1:Ik4hyJqN8Jfyv3S4AGBOmyouMsYE3EdYODkMbQjwPGw=
-github.com/btcsuite/btcd v0.20.1-beta/go.mod h1:wVuoA8VJLEcwgqHBwHmzLRazpKxTv13Px/pDuV7OomQ=
-github.com/btcsuite/btclog v0.0.0-20170628155309-84c8d2346e9f/go.mod h1:TdznJufoqS23FtqVCzL0ZqgP5MqXbb4fg/WgDys70nA=
-github.com/btcsuite/btcutil v0.0.0-20190425235716-9e5f4b9a998d/go.mod h1:+5NJ2+qvTyV9exUAL/rxXi3DcLg2Ts+ymUAY5y4NvMg=
-github.com/btcsuite/go-socks v0.0.0-20170105172521-4720035b7bfd/go.mod h1:HHNXQzUsZCxOoE+CPiyCTO6x34Zs86zZUiwtpXoGdtg=
-github.com/btcsuite/goleveldb v0.0.0-20160330041536-7834afc9e8cd/go.mod h1:F+uVaaLLH7j4eDXPRvw78tMflu7Ie2bzYOH4Y8rRKBY=
-github.com/btcsuite/snappy-go v0.0.0-20151229074030-0bdef8d06723/go.mod h1:8woku9dyThutzjeg+3xrA5iCpBRH8XEEg3lh6TiUghc=
-github.com/btcsuite/websocket v0.0.0-20150119174127-31079b680792/go.mod h1:ghJtEyQwv5/p4Mg4C0fgbePVuGr935/5ddU9Z3TmDRY=
-github.com/btcsuite/winsvc v1.0.0/go.mod h1:jsenWakMcC0zFBFurPLEAyrnc/teJEM1O46fmI40EZs=
-github.com/cespare/cp v0.1.0 h1:SE+dxFebS7Iik5LK0tsi1k9ZCxEaFX4AjQmoyA+1dJk=
-github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44=
-github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
-github.com/cpuguy83/go-md2man/v2 v2.0.2 h1:p1EgwI/C7NhT0JmVkwCD2ZBK8j4aeHQX2pMHHBfMQ6w=
-github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
-github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
-github.com/davecgh/go-spew v0.0.0-20171005155431-ecdeabc65495/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
-github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/deckarep/golang-set v1.8.0 h1:sk9/l/KqpunDwP7pSjUg0keiOOLEnOBHzykLrsPppp4=
-github.com/deckarep/golang-set v1.8.0/go.mod h1:5nI87KwE7wgsBU1F4GKAw2Qod7p5kyS383rP6+o6qqo=
-github.com/edsrzf/mmap-go v1.0.0 h1:CEBF7HpRnUCSJgGUb5h1Gm7e3VkmVDrR8lvWVLtrOFw=
-github.com/fjl/memsize v0.0.0-20190710130421-bcb5799ab5e5 h1:FtmdgXiUlNeRsoNMFlKLDt+S+6hbjVMEW6RGQ7aUf7c=
-github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
-github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff h1:tY80oXqGNY4FhTFhk+o9oFHGINQ/+vhlm8HFzi6znCI=
-github.com/go-ole/go-ole v1.2.6 h1:/Fpf6oFPoeFik9ty7siob0G6Ke8QvQEuVcuChpwXzpY=
-github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0=
-github.com/go-sql-driver/mysql v1.6.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg=
-github.com/go-sql-driver/mysql v1.7.0 h1:ueSltNNllEqE3qcWBTD0iQd3IpL/6U+mJxLkazJ7YPc=
-github.com/go-sql-driver/mysql v1.7.0/go.mod h1:OXbVy3sEdcQ2Doequ6Z5BW6fXNQTmx+9S1MCJN5yJMI=
-github.com/go-stack/stack v1.8.1 h1:ntEHSVwIt7PNXNpgPmVfMrNhLtgjlmnZha2kOpuRiDw=
-github.com/go-stack/stack v1.8.1/go.mod h1:dcoOX6HbPZSZptuspn9bctJ+N/CnF5gGygcUP3XYfe4=
-github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb h1:PBC98N2aIaM3XXiurYmW7fx4GZkL8feAMVq7nEjURHk=
-github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
-github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
-github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
-github.com/gopherjs/gopherjs v1.17.2 h1:fQnZVsXk8uxXIStYb0N4bGk7jeyTalG/wsZjQ25dO0g=
-github.com/gopherjs/gopherjs v1.17.2/go.mod h1:pRRIvn/QzFLrKfvEz3qUuEhtE/zLCWfreZ6J5gM2i+k=
-github.com/gorilla/websocket v1.5.0 h1:PPwGk2jz7EePpoHN/+ClbZu8SPxiqlu12wZP/3sWmnc=
-github.com/gorilla/websocket v1.5.0/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
-github.com/hashicorp/go-bexpr v0.1.10 h1:9kuI5PFotCboP3dkDYFr/wi0gg0QVbSNz5oFRpxn4uE=
-github.com/hashicorp/golang-lru v0.5.5-0.20210104140557-80c98217689d h1:dg1dEPuWpEqDnvIw251EVy4zlP8gWbsGj4BsUKCRpYs=
-github.com/holiman/bloomfilter/v2 v2.0.3 h1:73e0e/V0tCydx14a0SCYS/EWCxgwLZ18CZcZKVu0fao=
-github.com/holiman/uint256 v1.2.2 h1:TXKcSGc2WaxPD2+bmzAsVthL4+pEN0YwXcL5qED83vk=
-github.com/holiman/uint256 v1.2.2/go.mod h1:SC8Ryt4n+UBbPbIBKaG9zbbDlp4jOru9xFZmPzLUTxw=
-github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
-github.com/huin/goupnp v1.0.3 h1:N8No57ls+MnjlB+JPiCVSOyy/ot7MJTqlo7rn+NYSqQ=
-github.com/huin/goupnp v1.0.3/go.mod h1:ZxNlw5WqJj6wSsRK5+YfflQGXYfccj5VgQsMNixHM7Y=
-github.com/huin/goutil v0.0.0-20170803182201-1ca381bf3150/go.mod h1:PpLOETDnJ0o3iZrZfqZzyLl6l7F3c6L1oWn7OICBi6o=
-github.com/iden3/go-iden3-crypto v0.0.15 h1:4MJYlrot1l31Fzlo2sF56u7EVFeHHJkxGXXZCtESgK4=
-github.com/iden3/go-iden3-crypto v0.0.15/go.mod h1:dLpM4vEPJ3nDHzhWFXDjzkn1qHoBeOT/3UEhXsEsP3E=
-github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
-github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
-github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a h1:bbPeKD0xmW/Y25WS6cokEszi5g+S0QxI/d45PkRi7Nk=
-github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
-github.com/jackc/pgx/v5 v5.3.0 h1:/NQi8KHMpKWHInxXesC8yD4DhkXPrVhmnwYkjp9AmBA=
-github.com/jackc/pgx/v5 v5.3.0/go.mod h1:t3JDKnCBlYIc0ewLF0Q7B8MXmoIaBOZj/ic7iHozM/8=
-github.com/jackc/puddle/v2 v2.2.0/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
-github.com/jackpal/go-nat-pmp v1.0.2 h1:KzKSgb7qkJvOUTqYl9/Hg/me3pWgBmERKrTGD7BdWus=
-github.com/jackpal/go-nat-pmp v1.0.2/go.mod h1:QPH045xvCAeXUZOxsnwmrtiCoxIr9eob+4orBN1SBKc=
-github.com/jessevdk/go-flags v0.0.0-20141203071132-1679536dcc89/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=
-github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E=
-github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc=
-github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ=
-github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8=
-github.com/jmoiron/sqlx v1.3.5 h1:vFFPA71p1o5gAeqtEAwLU4dnX2napprKtHr7PYIcN3g=
-github.com/jmoiron/sqlx v1.3.5/go.mod h1:nRVWtLre0KfCLJvgxzCsLVMogSvQ1zNJtpYr2Ccp0mQ=
-github.com/jrick/logrotate v1.0.0/go.mod h1:LNinyqDIJnpAur+b8yyulnQw/wDuN1+BYKlTRt3OuAQ=
-github.com/jtolds/gls v4.20.0+incompatible h1:xdiiI2gbIgH/gLH7ADydsJ1uDOEzR8yvV7C0MuV77Wo=
-github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
-github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 h1:Z9n2FFNUXsshfwJMBgNA0RU6/i7WVaAegv3PtuIHPMs=
-github.com/kkdai/bstream v0.0.0-20161212061736-f391b8402d23/go.mod h1:J+Gs4SYgM6CZQHDETBtE9HaSEkGmuNXF86RwHhHUvq4=
-github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
-github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
-github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk=
-github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
-github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
-github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
-github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
-github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
-github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
-github.com/leanovate/gopter v0.2.9 h1:fQjYxZaynp97ozCzfOyOuAGOU4aU/z37zf/tOujFk7c=
-github.com/lib/pq v1.2.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
-github.com/lib/pq v1.10.7 h1:p7ZhMD+KsSRozJr34udlUrhboJwWAgCg34+/ZZNvZZw=
-github.com/lib/pq v1.10.7/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
-github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
-github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
-github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
-github.com/mattn/go-isatty v0.0.18 h1:DOKFKCQ7FNG2L1rbrmstDN4QVRdS89Nkh85u68Uwp98=
-github.com/mattn/go-isatty v0.0.18/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-github.com/mattn/go-runewidth v0.0.14 h1:+xnbZSEeDbOIg5/mE6JF0w6n9duR1l3/WmbinWVwUuU=
-github.com/mattn/go-runewidth v0.0.14/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
-github.com/mattn/go-sqlite3 v1.14.6/go.mod h1:NyWgC/yNuGj7Q9rpYnZvas74GogHl5/Z4A/KQRfk6bU=
-github.com/mattn/go-sqlite3 v1.14.14 h1:qZgc/Rwetq+MtyE18WhzjokPD93dNqLGNT3QJuLvBGw=
-github.com/mattn/go-sqlite3 v1.14.14/go.mod h1:NyWgC/yNuGj7Q9rpYnZvas74GogHl5/Z4A/KQRfk6bU=
-github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY=
-github.com/mitchellh/pointerstructure v1.2.0 h1:O+i9nHnXS3l/9Wu7r4NrEdwA2VFTicjUEN1uBnDo34A=
-github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
-github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
-github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
-github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
-github.com/orcaman/concurrent-map v1.0.0 h1:I/2A2XPCb4IuQWcQhBhSwGfiuybl/J0ev9HDbW65HOY=
-github.com/orcaman/concurrent-map v1.0.0/go.mod h1:Lu3tH6HLW3feq74c2GC+jIMS/K2CFcDWnWD9XkenwhI=
-github.com/orcaman/concurrent-map/v2 v2.0.1 h1:jOJ5Pg2w1oeB6PeDurIYf6k9PQ+aTITr/6lP/L/zp6c=
-github.com/orcaman/concurrent-map/v2 v2.0.1/go.mod h1:9Eq3TG2oBe5FirmYWQfYO5iH1q0Jv47PLaNK++uCdOM=
-github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
-github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/pressly/goose/v3 v3.7.0 h1:jblaZul15uCIEKHRu5KUdA+5wDA7E60JC0TOthdrtf8=
-github.com/pressly/goose/v3 v3.7.0/go.mod h1:N5gqPdIzdxf3BiPWdmoPreIwHStkxsvKWE5xjUvfYNk=
-github.com/prometheus/tsdb v0.7.1 h1:YZcsG11NqnK4czYLrWd9mpEuAJIHVQLwdrleYfszMAA=
-github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0 h1:OdAsTTz6OkFY5QxjkYwrChwuRruF69c169dPK26NUlk=
-github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
-github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis=
-github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
-github.com/rjeczalik/notify v0.9.1 h1:CLCKso/QK1snAlnhNR/CNvNiFU2saUtjV0bx3EwNeCE=
-github.com/rjeczalik/notify v0.9.1/go.mod h1:rKwnCoCGeuQnwBtTSPL9Dad03Vh2n40ePRrjvIXnJho=
-github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
-github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
-github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjRBZyWFQ=
-github.com/rogpeppe/go-internal v1.10.0/go.mod h1:UQnix2H7Ngw/k4C5ijL5+65zddjncjaFoBhdsK/akog=
-github.com/rs/cors v1.7.0 h1:+88SsELBHx5r+hZ8TCkggzSstaWNbDvThkVK8H6f9ik=
-github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
-github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20230508165858-27a3830afa61 h1:4fslVpNOPLeJPYX3tivrVWgqNvChPs7/y9OqWvQSNCw=
-github.com/scroll-tech/go-ethereum v1.10.14-0.20230508165858-27a3830afa61/go.mod h1:45PZqlQCqV0dU4o4+SE8LoJLEvXkK5j45ligvbih9QY=
-github.com/scroll-tech/zktrie v0.5.3 h1:jjzQchGU6XPL5s1C5bwwivSadefSRuYASE9OL7UKAdE=
-github.com/scroll-tech/zktrie v0.5.3/go.mod h1:XvNo7vAk8yxNyTjBDj5WIiFzYW4bx/gJ78+NK6Zn6Uk=
-github.com/shirou/gopsutil v3.21.11+incompatible h1:+1+c1VGhc88SSonWP6foOcLhvnKlUeu/erjjvaPEYiI=
-github.com/shirou/gopsutil v3.21.11+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA=
-github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
-github.com/smartystreets/assertions v1.13.1 h1:Ef7KhSmjZcK6AVf9YbJdvPYG9avaF0ZxudX+ThRdWfU=
-github.com/smartystreets/assertions v1.13.1/go.mod h1:cXr/IwVfSo/RbCSPhoAPv73p3hlSdrBH/b3SdnW/LMY=
-github.com/smartystreets/goconvey v1.6.4/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA=
-github.com/smartystreets/goconvey v1.8.0 h1:Oi49ha/2MURE0WexF052Z0m+BNSGirfjg5RL+JXWq3w=
-github.com/smartystreets/goconvey v1.8.0/go.mod h1:EdX8jtrTIj26jmjCOVNMVSIYAtgexqXKHOXW2Dx9JLg=
-github.com/status-im/keycard-go v0.2.0 h1:QDLFswOQu1r5jsycloeQh3bVU8n/NatHHaZobtDnDzA=
-github.com/status-im/keycard-go v0.2.0/go.mod h1:wlp8ZLbsmrF6g6WjugPAx+IzoLrkdf9+mHxBEeo3Hbg=
-github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
-github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
-github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
-github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
-github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
-github.com/stretchr/testify v1.8.2 h1:+h33VjcLVPDHtOdpUCuF+7gSuG3yGIftsP1YvFihtJ8=
-github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
-github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 h1:epCh84lMvA70Z7CTTCmYQn2CKbY8j86K7/FAIr141uY=
-github.com/tklauser/go-sysconf v0.3.11 h1:89WgdJhk5SNwJfu+GKyYveZ4IaJ7xAkecBo+KdJV0CM=
-github.com/tklauser/go-sysconf v0.3.11/go.mod h1:GqXfhXY3kiPa0nAXPDIQIWzJbMCB7AmcWpGR8lSZfqI=
-github.com/tklauser/numcpus v0.6.0 h1:kebhY2Qt+3U6RNK7UqpYNA+tJ23IBEGKkB7JQBfDYms=
-github.com/tklauser/numcpus v0.6.0/go.mod h1:FEZLMke0lhOUG6w2JadTzp0a+Nl8PF/GFkQ5UVIcaL4=
-github.com/tyler-smith/go-bip39 v1.1.0 h1:5eUemwrMargf3BSLRRCalXT93Ns6pQJIjYQN2nyfOP8=
-github.com/tyler-smith/go-bip39 v1.1.0/go.mod h1:gUYDtqQw1JS3ZJ8UWVcGTGqqr6YIN3CWg+kkNaLt55U=
-github.com/urfave/cli/v2 v2.17.2-0.20221006022127-8f469abc00aa h1:5SqCsI/2Qya2bCzK15ozrqo2sZxkh0FHynJZOTVoV6Q=
-github.com/urfave/cli/v2 v2.17.2-0.20221006022127-8f469abc00aa/go.mod h1:1CNUng3PtjQMtRzJO4FMXBQvkGtuYRxxiR9xMa7jMwI=
-github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 h1:bAn7/zixMGCfxrRTfdpNzjtPYqr8smhKouy9mxVdGPU=
-github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673/go.mod h1:N3UwUGtsrSj3ccvlPHLoLsHnpR27oXr4ZE984MbSER8=
-github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
-github.com/yusufpapurcu/wmi v1.2.2 h1:KBNDSne4vP5mbSWnJbO+51IMOXJB67QiYCSBrubbPRg=
-github.com/yusufpapurcu/wmi v1.2.2/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0=
-golang.org/x/crypto v0.0.0-20170930174604-9419663f5a44/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
-golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
-golang.org/x/crypto v0.6.0/go.mod h1:OFC/31mSvZgRz0V1QTNCzfAI1aIRzbiufJtkMIlEp58=
-golang.org/x/crypto v0.9.0 h1:LF6fAI+IutBocDJ2OT0Q1g8plpYljMZ4+lty+dsqw3g=
-golang.org/x/crypto v0.9.0/go.mod h1:yrmDGqONDYtNj3tH8X9dzUun2m2lzPa9ngI6/RUPGR0=
-golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
-golang.org/x/mod v0.10.0 h1:lFO9qtOdlre5W1jxS3r/4szv2/6iXxScdzjoBMXNhYk=
-golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
-golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
-golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
-golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o=
-golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.8.0 h1:EBmGv8NaZBZTWvrbjNoL6HVt+IVy3QDQpJs7VRIw3tU=
-golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
-golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
-golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
-golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
-golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
-golang.org/x/text v0.9.0 h1:2sjJmO8cDvYveuX97RDLsxlyUxLl+GHoLxBiRdHllBE=
-golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
-golang.org/x/time v0.3.0 h1:rg5rLMjNzMS1RkNLzCG38eapWhnYLFYXDXj2gOlr8j4=
-golang.org/x/time v0.3.0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
-golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20190328211700-ab21143f2384/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
-golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
-golang.org/x/tools v0.8.0 h1:vSDcovVPld282ceKgDimkRSC8kpaH1dgyc9UMzlt84Y=
-golang.org/x/tools v0.8.0/go.mod h1:JxBZ99ISMI5ViVkT1tr6tdNmXeTrcpVSD3vZ1RsRdN4=
-golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
-gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
-gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
-gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
-gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce h1:+JknDZhAj8YMt7GC73Ei8pv4MzjDUNPHgQWJdtMAaDU=
-gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce/go.mod h1:5AcXVHNjg+BDxry382+8OKon8SEWiKktQR07RKPsv1c=
-gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
-gopkg.in/urfave/cli.v1 v1.20.0 h1:NdAVW6RYxDif9DhDHaAortIu956m2c0v+09AZBPTbE0=
-gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
-gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-gorm.io/driver/postgres v1.5.0 h1:u2FXTy14l45qc3UeCJ7QaAXZmZfDDv0YrthvmRq1l0U=
-gorm.io/driver/postgres v1.5.0/go.mod h1:FUZXzO+5Uqg5zzwzv4KK49R8lvGIyscBOqYrtI1Ce9A=
-gorm.io/gorm v1.24.7-0.20230306060331-85eaf9eeda11/go.mod h1:L4uxeKpfBml98NYqVqwAdmV1a2nBtAec/cf3fpucW/k=
-gorm.io/gorm v1.25.1 h1:nsSALe5Pr+cM3V1qwwQ7rOkw+6UeLrX5O4v3llhHa64=
-gorm.io/gorm v1.25.1/go.mod h1:L4uxeKpfBml98NYqVqwAdmV1a2nBtAec/cf3fpucW/k=
-lukechampine.com/uint128 v1.2.0 h1:mBi/5l91vocEN8otkC5bDLhi2KdCticRiwbdB0O+rjI=
-modernc.org/cc/v3 v3.36.1 h1:CICrjwr/1M4+6OQ4HJZ/AHxjcwe67r5vPUF518MkO8A=
-modernc.org/ccgo/v3 v3.16.8 h1:G0QNlTqI5uVgczBWfGKs7B++EPwCfXPWGD2MdeKloDs=
-modernc.org/libc v1.16.19 h1:S8flPn5ZeXx6iw/8yNa986hwTQDrY8RXU7tObZuAozo=
-modernc.org/mathutil v1.4.1 h1:ij3fYGe8zBF4Vu+g0oT7mB06r8sqGWKuJu1yXeR4by8=
-modernc.org/mathutil v1.4.1/go.mod h1:mZW8CKdRPY1v87qxC/wUdX5O1qDzXMP5TH3wjfpga6E=
-modernc.org/memory v1.1.1 h1:bDOL0DIDLQv7bWhP3gMvIrnoFw+Eo6F7a2QK9HPDiFU=
-modernc.org/opt v0.1.3 h1:3XOZf2yznlhC+ibLltsDGzABUGVx8J6pnFMS3E4dcq4=
-modernc.org/sqlite v1.18.1 h1:ko32eKt3jf7eqIkCgPAeHMBXw3riNSLhl2f3loEF7o8=
-modernc.org/strutil v1.1.2 h1:iFBDH6j1Z0bN/Q9udJnnFoFpENA4252qe/7/5woE5MI=
-modernc.org/token v1.0.0 h1:a0jaWiNMDhDUtqOj09wvjWWAqd3q7WpBulmL9H2egsk=

bridge/internal/config/config.go

@@ -1,30 +0,0 @@
-package config
-
-import (
-	"encoding/json"
-	"os"
-	"path/filepath"
-)
-
-// Config load configuration items.
-type Config struct {
-	L1Config *L1Config `json:"l1_config"`
-	L2Config *L2Config `json:"l2_config"`
-	DBConfig *DBConfig `json:"db_config"`
-}
-
-// 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/internal/config/db.go

@@ -1,33 +0,0 @@
-package config
-
-import (
-	"encoding/json"
-	"os"
-	"path/filepath"
-)
-
-// DBConfig db config
-type DBConfig struct {
-	// data source name
-	DSN        string `json:"dsn"`
-	DriverName string `json:"driver_name"`
-
-	MaxOpenNum int `json:"maxOpenNum"`
-	MaxIdleNum int `json:"maxIdleNum"`
-}
-
-// NewDBConfig returns a new instance of Config.
-func NewDBConfig(file string) (*DBConfig, error) {
-	buf, err := os.ReadFile(filepath.Clean(file))
-	if err != nil {
-		return nil, err
-	}
-
-	cfg := &DBConfig{}
-	err = json.Unmarshal(buf, cfg)
-	if err != nil {
-		return nil, err
-	}
-
-	return cfg, nil
-}

bridge/internal/config/l2.go

@@ -1,51 +0,0 @@
-package config
-
-import (
-	"github.com/scroll-tech/go-ethereum/rpc"
-
-	"github.com/scroll-tech/go-ethereum/common"
-
-	"scroll-tech/bridge/internal/types"
-)
-
-// L2Config loads l2geth configuration items.
-type L2Config struct {
-	// Confirmations block height confirmations number.
-	Confirmations rpc.BlockNumber `json:"confirmations"`
-	// l2geth node url.
-	Endpoint string `json:"endpoint"`
-	// The messenger contract address deployed on layer 2 chain.
-	L2MessengerAddress common.Address `json:"l2_messenger_address"`
-	// The L2MessageQueue contract address deployed on layer 2 chain.
-	L2MessageQueueAddress common.Address `json:"l2_message_queue_address"`
-	// The WithdrawTrieRootSlot in L2MessageQueue contract.
-	WithdrawTrieRootSlot common.Hash `json:"withdraw_trie_root_slot,omitempty"`
-	// The relayer config
-	RelayerConfig *RelayerConfig `json:"relayer_config"`
-	// The batch_proposer config
-	BatchProposerConfig *BatchProposerConfig `json:"batch_proposer_config"`
-}
-
-// BatchProposerConfig loads l2watcher batch_proposer configuration items.
-type BatchProposerConfig struct {
-	// Proof generation frequency, generating proof every k blocks
-	ProofGenerationFreq uint64 `json:"proof_generation_freq"`
-	// Txnum threshold in a batch
-	BatchTxNumThreshold uint64 `json:"batch_tx_num_threshold"`
-	// Gas threshold in a batch
-	BatchGasThreshold uint64 `json:"batch_gas_threshold"`
-	// Time waited to generate a batch even if gas_threshold not met
-	BatchTimeSec uint64 `json:"batch_time_sec"`
-	// Time waited to commit batches before the calldata met CommitTxCalldataSizeLimit
-	BatchCommitTimeSec uint64 `json:"batch_commit_time_sec"`
-	// Max number of blocks in a batch
-	BatchBlocksLimit uint64 `json:"batch_blocks_limit"`
-	// Commit tx calldata size limit in bytes, target to cap the gas use of commit tx at 2M gas
-	CommitTxCalldataSizeLimit uint64 `json:"commit_tx_calldata_size_limit"`
-	// Commit tx calldata min size limit in bytes
-	CommitTxCalldataMinSize uint64 `json:"commit_tx_calldata_min_size,omitempty"`
-	// Max number of batches in a commit transaction
-	CommitTxBatchCountLimit uint64 `json:"commit_tx_batch_count_limit"`
-	// The public input hash config
-	PublicInputConfig *types.PublicInputHashConfig `json:"public_input_config"`
-}

bridge/internal/config/relayer.go

@@ -1,146 +0,0 @@
-package config
-
-import (
-	"crypto/ecdsa"
-	"encoding/json"
-	"fmt"
-	"math/big"
-
-	"github.com/scroll-tech/go-ethereum/common"
-	"github.com/scroll-tech/go-ethereum/crypto"
-	"github.com/scroll-tech/go-ethereum/rpc"
-)
-
-// SenderConfig The config for transaction sender
-type SenderConfig struct {
-	// The RPC endpoint of the ethereum or scroll public node.
-	Endpoint string `json:"endpoint"`
-	// The time to trigger check pending txs in sender.
-	CheckPendingTime uint64 `json:"check_pending_time"`
-	// The number of blocks to wait to escalate increase gas price of the transaction.
-	EscalateBlocks uint64 `json:"escalate_blocks"`
-	// The gap number between a block be confirmed and the latest block.
-	Confirmations rpc.BlockNumber `json:"confirmations"`
-	// The numerator of gas price escalate multiple.
-	EscalateMultipleNum uint64 `json:"escalate_multiple_num"`
-	// The denominator of gas price escalate multiple.
-	EscalateMultipleDen uint64 `json:"escalate_multiple_den"`
-	// The maximum gas price can be used to send transaction.
-	MaxGasPrice uint64 `json:"max_gas_price"`
-	// The transaction type to use: LegacyTx, AccessListTx, DynamicFeeTx
-	TxType string `json:"tx_type"`
-	// The min balance set for check and set balance for sender's accounts.
-	MinBalance *big.Int `json:"min_balance"`
-	// The interval (in seconds) to check balance and top up sender's accounts
-	CheckBalanceTime uint64 `json:"check_balance_time"`
-	// The sender's pending count limit.
-	PendingLimit int `json:"pending_limit,omitempty"`
-}
-
-// RelayerConfig loads relayer configuration items.
-// What we need to pay attention to is that
-// `MessageSenderPrivateKeys` and `RollupSenderPrivateKeys` cannot have common private keys.
-type RelayerConfig struct {
-	// RollupContractAddress store the rollup contract address.
-	RollupContractAddress common.Address `json:"rollup_contract_address,omitempty"`
-	// MessengerContractAddress store the scroll messenger contract address.
-	MessengerContractAddress common.Address `json:"messenger_contract_address"`
-	// GasPriceOracleContractAddress store the scroll messenger contract address.
-	GasPriceOracleContractAddress common.Address `json:"gas_price_oracle_contract_address"`
-	// sender config
-	SenderConfig *SenderConfig `json:"sender_config"`
-	// gas oracle config
-	GasOracleConfig *GasOracleConfig `json:"gas_oracle_config"`
-	// The interval in which we send finalize batch transactions.
-	FinalizeBatchIntervalSec uint64 `json:"finalize_batch_interval_sec"`
-	// MessageRelayMinGasLimit to avoid OutOfGas error
-	MessageRelayMinGasLimit uint64 `json:"message_relay_min_gas_limit,omitempty"`
-	// The private key of the relayer
-	MessageSenderPrivateKeys   []*ecdsa.PrivateKey `json:"-"`
-	GasOracleSenderPrivateKeys []*ecdsa.PrivateKey `json:"-"`
-	RollupSenderPrivateKeys    []*ecdsa.PrivateKey `json:"-"`
-}
-
-// GasOracleConfig The config for updating gas price oracle.
-type GasOracleConfig struct {
-	// MinGasPrice store the minimum gas price to set.
-	MinGasPrice uint64 `json:"min_gas_price"`
-	// GasPriceDiff store the percentage of gas price difference.
-	GasPriceDiff uint64 `json:"gas_price_diff"`
-}
-
-// relayerConfigAlias RelayerConfig alias name
-type relayerConfigAlias RelayerConfig
-
-// UnmarshalJSON unmarshal relayer_config struct.
-func (r *RelayerConfig) UnmarshalJSON(input []byte) error {
-	var jsonConfig struct {
-		relayerConfigAlias
-		// The private key of the relayer
-		MessageSenderPrivateKeys   []string `json:"message_sender_private_keys"`
-		GasOracleSenderPrivateKeys []string `json:"gas_oracle_sender_private_keys"`
-		RollupSenderPrivateKeys    []string `json:"rollup_sender_private_keys,omitempty"`
-	}
-	if err := json.Unmarshal(input, &jsonConfig); err != nil {
-		return err
-	}
-
-	*r = RelayerConfig(jsonConfig.relayerConfigAlias)
-
-	// Get messenger private key list.
-	for _, privStr := range jsonConfig.MessageSenderPrivateKeys {
-		priv, err := crypto.ToECDSA(common.FromHex(privStr))
-		if err != nil {
-			return fmt.Errorf("incorrect private_key_list format, err: %v", err)
-		}
-		r.MessageSenderPrivateKeys = append(r.MessageSenderPrivateKeys, priv)
-	}
-
-	// Get gas oracle private key list.
-	for _, privStr := range jsonConfig.GasOracleSenderPrivateKeys {
-		priv, err := crypto.ToECDSA(common.FromHex(privStr))
-		if err != nil {
-			return fmt.Errorf("incorrect private_key_list format, err: %v", err)
-		}
-		r.GasOracleSenderPrivateKeys = append(r.GasOracleSenderPrivateKeys, priv)
-	}
-
-	// Get rollup private key
-	for _, privStr := range jsonConfig.RollupSenderPrivateKeys {
-		priv, err := crypto.ToECDSA(common.FromHex(privStr))
-		if err != nil {
-			return fmt.Errorf("incorrect roller_private_key format, err: %v", err)
-		}
-		r.RollupSenderPrivateKeys = append(r.RollupSenderPrivateKeys, priv)
-	}
-
-	return nil
-}
-
-// MarshalJSON marshal RelayerConfig config, transfer private keys.
-func (r *RelayerConfig) MarshalJSON() ([]byte, error) {
-	jsonConfig := struct {
-		relayerConfigAlias
-		// The private key of the relayer
-		MessageSenderPrivateKeys   []string `json:"message_sender_private_keys"`
-		GasOracleSenderPrivateKeys []string `json:"gas_oracle_sender_private_keys,omitempty"`
-		RollupSenderPrivateKeys    []string `json:"rollup_sender_private_keys,omitempty"`
-	}{relayerConfigAlias(*r), nil, nil, nil}
-
-	// Transfer message sender private keys to hex type.
-	for _, priv := range r.MessageSenderPrivateKeys {
-		jsonConfig.MessageSenderPrivateKeys = append(jsonConfig.MessageSenderPrivateKeys, common.Bytes2Hex(crypto.FromECDSA(priv)))
-	}
-
-	// Transfer rollup sender private keys to hex type.
-	for _, priv := range r.GasOracleSenderPrivateKeys {
-		jsonConfig.GasOracleSenderPrivateKeys = append(jsonConfig.GasOracleSenderPrivateKeys, common.Bytes2Hex(crypto.FromECDSA(priv)))
-	}
-
-	// Transfer rollup sender private keys to hex type.
-	for _, priv := range r.RollupSenderPrivateKeys {
-		jsonConfig.RollupSenderPrivateKeys = append(jsonConfig.RollupSenderPrivateKeys, common.Bytes2Hex(crypto.FromECDSA(priv)))
-	}
-
-	return json.Marshal(&jsonConfig)
-}