feat: add enable to chain-monitor config (#942)

Co-authored-by: HAOYUatHZ <haoyu@protonmail.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

@@ -51,7 +51,6 @@ jobs:
       uses: actions/checkout@v2
     - name: Test
       run: |
-        go get ./...
         make test
     - name: Upload coverage reports to Codecov
       uses: codecov/codecov-action@v3

.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:
@@ -77,7 +79,7 @@ jobs:
     - name: Install Go
       uses: actions/setup-go@v2
       with:
-        go-version: 1.18.x
+        go-version: 1.19.x
     - name: Checkout code
       uses: actions/checkout@v2
     - name: Install Solc

.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'
 
@@ -93,7 +95,7 @@ jobs:
     - name: Install Go
       uses: actions/setup-go@v2
       with:
-        go-version: 1.18.x
+        go-version: 1.19.x
     - name: Checkout code
       uses: actions/checkout@v2
     - name: Install Solc

.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:
@@ -70,7 +72,7 @@ jobs:
     - name: Install Go
       uses: actions/setup-go@v2
       with:
-        go-version: 1.18.x
+        go-version: 1.19.x
     - name: Checkout code
       uses: actions/checkout@v2
     - name: Install Solc

.github/workflows/docker.yml

@@ -6,7 +6,7 @@ on:
       - v**
 
 jobs:
-  build-and-push:
+  event_watcher:
     runs-on: ubuntu-latest
     steps:
     - name: Checkout code
@@ -27,6 +27,18 @@ jobs:
         tags: scrolltech/event-watcher:${{github.ref_name}}
         # cache-from: type=gha,scope=${{ github.workflow }}
         # cache-to: type=gha,scope=${{ github.workflow }}
+  gas_oracle:
+    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 gas_oracle docker
       uses: docker/build-push-action@v2
       with:
@@ -36,15 +48,18 @@ jobs:
         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
+  rollup_relayer:
+    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:
-        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 }}
+        username: ${{ secrets.DOCKERHUB_USERNAME }}
+        password: ${{ secrets.DOCKERHUB_TOKEN }}
     - name: Build and push rollup_relayer docker
       uses: docker/build-push-action@v2
       with:
@@ -54,6 +69,18 @@ jobs:
         tags: scrolltech/rollup-relayer:${{github.ref_name}}
         # cache-from: type=gha,scope=${{ github.workflow }}
         # cache-to: type=gha,scope=${{ github.workflow }}
+  bridgehistoryapi-cross-msg-fetcher:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v2
+    - name: Set up Docker Buildx
+      uses: docker/setup-buildx-action@v2
+    - name: Login to Docker Hub
+      uses: docker/login-action@v2
+      with:
+        username: ${{ secrets.DOCKERHUB_USERNAME }}
+        password: ${{ secrets.DOCKERHUB_TOKEN }}
     - name: Build and push bridgehistoryapi-cross-msg-fetcher docker
       uses: docker/build-push-action@v2
       with:
@@ -63,6 +90,18 @@ jobs:
         tags: scrolltech/bridgehistoryapi-cross-msg-fetcher:${{github.ref_name}}
         # cache-from: type=gha,scope=${{ github.workflow }}
         # cache-to: type=gha,scope=${{ github.workflow }}
+  bridgehistoryapi-server:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v2
+    - name: Set up Docker Buildx
+      uses: docker/setup-buildx-action@v2
+    - name: Login to Docker Hub
+      uses: docker/login-action@v2
+      with:
+        username: ${{ secrets.DOCKERHUB_USERNAME }}
+        password: ${{ secrets.DOCKERHUB_TOKEN }}
     - name: Build and push bridgehistoryapi-server docker
       uses: docker/build-push-action@v2
       with:
@@ -72,6 +111,18 @@ jobs:
         tags: scrolltech/bridgehistoryapi-server:${{github.ref_name}}
         # cache-from: type=gha,scope=${{ github.workflow }}
         # cache-to: type=gha,scope=${{ github.workflow }}
+  coordinator:
+    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 coordinator docker
       uses: docker/build-push-action@v2
       with:
@@ -81,3 +132,24 @@ jobs:
         tags: scrolltech/coordinator:${{github.ref_name}}
         # cache-from: type=gha,scope=${{ github.workflow }}
         # cache-to: type=gha,scope=${{ github.workflow }}
+  prover-stats-api:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v2
+    - name: Set up Docker Buildx
+      uses: docker/setup-buildx-action@v2
+    - name: Login to Docker Hub
+      uses: docker/login-action@v2
+      with:
+        username: ${{ secrets.DOCKERHUB_USERNAME }}
+        password: ${{ secrets.DOCKERHUB_TOKEN }}
+    - name: Build and push prover-stats-api docker
+      uses: docker/build-push-action@v2
+      with:
+        context: .
+        file: ./build/dockerfiles/prover-stats-api.Dockerfile
+        push: true
+        tags: scrolltech/prover-stats-api:${{github.ref_name}}
+        # cache-from: type=gha,scope=${{ github.workflow }}
+        # cache-to: type=gha,scope=${{ github.workflow }}

.github/workflows/integration.yml

@@ -22,7 +22,7 @@ jobs:
     - name: Install Go
       uses: actions/setup-go@v2
       with:
-        go-version: 1.18.x
+        go-version: 1.19.x
     - name: Checkout code
       uses: actions/checkout@v2
     - name: Install Solc
@@ -36,7 +36,7 @@ jobs:
     - 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/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,12 +17,12 @@ 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:
@@ -43,7 +43,7 @@ jobs:
       env:
         CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
       with:
-        flags: roller
+        flags: prover
   compile:
     if: github.event_name == 'push' # will only be triggered when pushing to main & staging & develop & alpha
     runs-on: ubuntu-latest
@@ -65,7 +65,7 @@ jobs:
         workspaces: "common/libzkp/impl -> target"
     - name: Test
       run: |
-        make roller
+        make prover
   check:
     if: github.event.pull_request.draft == false
     runs-on: ubuntu-latest
@@ -92,7 +92,7 @@ jobs:
       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:
@@ -44,7 +46,7 @@ jobs:
     - 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
@@ -62,14 +64,14 @@ jobs:
     - 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,7 +83,7 @@ jobs:
     - name: Install Go
       uses: actions/setup-go@v2
       with:
-        go-version: 1.18.x
+        go-version: 1.19.x
     - name: Checkout code
       uses: actions/checkout@v2
     - name: Install Solc
@@ -95,13 +97,13 @@ jobs:
     - 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
+*~

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 which 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,42 @@
+## 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.
+1. Create a new branch: `git checkout -b my-branch-name`.
+1. Make your change, add tests, and make sure the tests still pass.
+1. Push to your fork and [submit a pull request][pr].
+1. 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)

Makefile

@@ -1,32 +1,38 @@
 .PHONY: check update dev_docker build_test_docker run_test_docker clean
 
+L2GETH_TAG=scroll-v4.3.55
+
 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}'
 
 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
 	go work sync
-	cd $(PWD)/bridge/ && go get -u github.com/scroll-tech/go-ethereum@scroll-v4.1.0 && go mod tidy
+	cd $(PWD)/rollup/ && go get -u github.com/scroll-tech/go-ethereum@${L2GETH_TAG} && go mod tidy
 	cd $(PWD)/bridge-history-api/ && go get -u github.com/ethereum/go-ethereum@latest && go mod tidy
-	cd $(PWD)/common/ && go get -u github.com/scroll-tech/go-ethereum@scroll-v4.1.0 && go mod tidy
-	cd $(PWD)/coordinator/ && go get -u github.com/scroll-tech/go-ethereum@scroll-v4.1.0 && go mod tidy
-	cd $(PWD)/database/ && go get -u github.com/scroll-tech/go-ethereum@scroll-v4.1.0 && go mod tidy
-	cd $(PWD)/roller/ && go get -u github.com/scroll-tech/go-ethereum@scroll-v4.1.0 && go mod tidy
-	goimports -local $(PWD)/bridge/ -w .
+	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)/prover-stats-api/ && 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
+	goimports -local $(PWD)/rollup/ -w .
 	goimports -local $(PWD)/bridge-history-api/ -w .
 	goimports -local $(PWD)/common/ -w .
 	goimports -local $(PWD)/coordinator/ -w .
 	goimports -local $(PWD)/database/ -w .
-	goimports -local $(PWD)/roller/ -w .
+	goimports -local $(PWD)/prover/ -w .
+	goimports -local $(PWD)/prover-stats-api/ -w .
+	goimports -local $(PWD)/tests/integration-test/ -w .
 
 dev_docker: ## build docker images for development/testing usages
 	docker build -t scroll_l1geth ./common/docker/l1geth/

README.md

@@ -1,7 +1,34 @@
 # Scroll Monorepo
 
+[![rollup](https://github.com/scroll-tech/scroll/actions/workflows/rollup.yml/badge.svg)](https://github.com/scroll-tech/scroll/actions/workflows/rollup.yml)
+[![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 chain 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="./prover-stats-api">prover-stats-api</a>: Collect and show prover statistics
+├── <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
 + Rust (for version, see [rust-toolchain](./common/libzkp/impl/rust-toolchain))
@@ -15,14 +42,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 +82,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 +90,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/README.md

@@ -1 +1,82 @@
 # 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, check status services of DB
+```
+    cd ./bridge-history-api
+    make bridgehistoryapi-db-cli
+    ./build/bin/bridgehistoryapi-db-cli [command]
+```
+
+### bridgehistoryapi-cross-msg-fetcher
+
+Fetch the transactions from both l1 and l2
+```
+    cd ./bridge-history-api
+    make bridgehistoryapi-cross-msg-fetcher
+    ./build/bin/bridgehistoryapi-cross-msg-fetcher
+```
+
+### bridgehistoryapi-server
+
+provides REST APIs. Please refer to the API details below.
+```
+    cd ./bridge-history-api
+    make bridgehistoryapi-server
+    ./build/bin/bridgehistoryapi-server
+```
+
+## APIs provided by bridgehistoryapi-server
+
+assume `bridgehistoryapi-server` listening on `https://localhost:8080`
+can change this port thru modify `config.json`
+
+1. `/txs`
+```
+// @Summary    	 get all txs 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/txs [get]
+```
+
+2. `/txsbyhashes`
+```
+// @Summary    	 get txs by given tx hashes
+// @Accept       plain
+// @Produce      plain
+// @Param        hashes  query  string array  true  "array of hashes list"
+// @Success      200  
+// @Router       /api/txsbyhashes [post]
+```
+
+3. `/claimable`
+```
+// @Summary    	 get all claimable txs 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/claimable [get]
+```
+
+4. `/withdraw_root`
+```
+// @Summary    	 get withdraw_root of given batch index
+// @Accept       plain
+// @Produce      plain
+// @Param        batch_index  query string  true  "batch_index"
+// @Success      200
+// @Router       /api/withdraw_root [get]
+```

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

@@ -3,111 +3,70 @@ package app
 import (
 	"fmt"
 	"os"
+	"os/signal"
 
 	"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/gin-gonic/gin"
 	"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"
+	"bridge-history-api/internal/controller"
+	"bridge-history-api/internal/route"
+	"bridge-history-api/utils"
 )
 
 var (
 	app *cli.App
 )
 
-var database db.OrmFactory
-
-func pong(ctx iris.Context) {
-	_, err := ctx.WriteString("pong")
-	if err != nil {
-		log.Error("failed to write pong", "err", err)
-	}
-}
-
-func setupQueryByAddressHandler(backendApp *mvc.Application) {
-	// Register Dependencies.
-	backendApp.Register(
-		database,
-		service.NewHistoryService,
-	)
-
-	// Register Controllers.
-	backendApp.Handle(new(controller.QueryAddressController))
-}
-
-func setupQueryClaimableHandler(backendApp *mvc.Application) {
-	// Register Dependencies.
-	backendApp.Register(
-		database,
-		service.NewHistoryService,
-	)
-
-	// Register Controllers.
-	backendApp.Handle(new(controller.QueryClaimableController))
-}
-
-func setupQueryByHashHandler(backendApp *mvc.Application) {
-	backendApp.Register(
-		database,
-		service.NewHistoryService,
-	)
-	backendApp.Handle(new(controller.QueryHashController))
-}
-
 func init() {
 	app = cli.NewApp()
 
 	app.Action = action
 	app.Name = "Scroll Bridge History Web Service"
 	app.Usage = "The Scroll Bridge History Web Service"
-	app.Flags = append(app.Flags, cutils.CommonFlags...)
+	app.Flags = append(app.Flags, utils.CommonFlags...)
 	app.Commands = []*cli.Command{}
 
 	app.Before = func(ctx *cli.Context) error {
-		return cutils.LogSetup(ctx)
+		return utils.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)
+	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)
 	}
-	database, err = db.NewOrmFactory(cfg)
+	db, err := utils.InitDB(cfg.DB)
 	if err != nil {
-		log.Crit("can not connect to database", "err", err)
+		log.Crit("failed to init db", "err", err)
 	}
 	defer func() {
-		if err = database.Close(); err != nil {
-			log.Error("failed to close database", "err", err)
+		if deferErr := utils.CloseDB(db); deferErr != nil {
+			log.Error("failed to close db", "err", err)
 		}
 	}()
-	bridgeApp := iris.New()
-	bridgeApp.UseRouter(corsOptions)
-	bridgeApp.Get("/ping", pong).Describe("healthcheck")
+	// init Prover Stats API
+	port := cfg.Server.HostPort
 
-	mvc.Configure(bridgeApp.Party("/api/txs"), setupQueryByAddressHandler)
-	mvc.Configure(bridgeApp.Party("/api/txsbyhashes"), setupQueryByHashHandler)
-	mvc.Configure(bridgeApp.Party("/api/claimable"), setupQueryClaimableHandler)
+	router := gin.Default()
+	controller.InitController(db)
+	route.Route(router, cfg)
 
-	// 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)
-	}
+	go func() {
+		if runServerErr := router.Run(fmt.Sprintf(":%s", port)); runServerErr != nil {
+			log.Crit("run http server failure", "error", runServerErr)
+		}
+	}()
+	// 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
 }

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

@@ -14,8 +14,8 @@ import (
 	"bridge-history-api/config"
 	"bridge-history-api/crossmsg"
 	"bridge-history-api/crossmsg/messageproof"
-	"bridge-history-api/db"
-	cutils "bridge-history-api/utils"
+	"bridge-history-api/orm"
+	"bridge-history-api/utils"
 )
 
 var (
@@ -28,17 +28,17 @@ func init() {
 	app.Action = action
 	app.Name = "Scroll Bridge History API"
 	app.Usage = "The Scroll Bridge Web Backend"
-	app.Flags = append(app.Flags, cutils.CommonFlags...)
+	app.Flags = append(app.Flags, utils.CommonFlags...)
 	app.Commands = []*cli.Command{}
 
 	app.Before = func(ctx *cli.Context) error {
-		return cutils.LogSetup(ctx)
+		return utils.LogSetup(ctx)
 	}
 }
 
 func action(ctx *cli.Context) error {
 	// Load config file.
-	cfgFile := ctx.String(cutils.ConfigFileFlag.Name)
+	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)
@@ -55,9 +55,12 @@ func action(ctx *cli.Context) error {
 		log.Crit("failed to connect l2 geth", "config file", cfgFile, "error", err)
 	}
 
-	db, err := db.NewOrmFactory(cfg)
+	db, err := utils.InitDB(cfg.DB)
+	if err != nil {
+		log.Crit("failed to init db", "err", err)
+	}
 	defer func() {
-		if deferErr := db.Close(); deferErr != nil {
+		if deferErr := utils.CloseDB(db); deferErr != nil {
 			log.Error("failed to close db", "err", err)
 		}
 	}()
@@ -105,12 +108,14 @@ func action(ctx *cli.Context) error {
 	go l2crossMsgFetcher.Start()
 	defer l2crossMsgFetcher.Stop()
 
+	CrossMsgOrm := orm.NewCrossMsg(db)
+
 	// BlockTimestamp fetcher for l1 and l2
-	l1BlockTimeFetcher := crossmsg.NewBlockTimestampFetcher(subCtx, cfg.L1.Confirmation, int(cfg.L1.BlockTime), l1client, db.UpdateL1BlockTimestamp, db.GetL1EarliestNoBlockTimestampHeight)
+	l1BlockTimeFetcher := crossmsg.NewBlockTimestampFetcher(subCtx, cfg.L1.Confirmation, int(cfg.L1.BlockTime), l1client, CrossMsgOrm.UpdateL1BlockTimestamp, CrossMsgOrm.GetL1EarliestNoBlockTimestampHeight)
 	go l1BlockTimeFetcher.Start()
 	defer l1BlockTimeFetcher.Stop()
 
-	l2BlockTimeFetcher := crossmsg.NewBlockTimestampFetcher(subCtx, cfg.L2.Confirmation, int(cfg.L2.BlockTime), l2client, db.UpdateL2BlockTimestamp, db.GetL2EarliestNoBlockTimestampHeight)
+	l2BlockTimeFetcher := crossmsg.NewBlockTimestampFetcher(subCtx, cfg.L2.Confirmation, int(cfg.L2.BlockTime), l2client, CrossMsgOrm.UpdateL2BlockTimestamp, CrossMsgOrm.GetL2EarliestNoBlockTimestampHeight)
 	go l2BlockTimeFetcher.Start()
 	defer l2BlockTimeFetcher.Stop()
 

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

@@ -2,12 +2,11 @@ package app
 
 import (
 	"github.com/ethereum/go-ethereum/log"
-	"github.com/jmoiron/sqlx"
 	"github.com/urfave/cli/v2"
+	"gorm.io/gorm"
 
 	"bridge-history-api/config"
-	"bridge-history-api/db"
-	"bridge-history-api/db/migrate"
+	"bridge-history-api/orm/migrate"
 	"bridge-history-api/utils"
 )
 
@@ -20,14 +19,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 *config.DBConfig) (*gorm.DB, error) {
+	return utils.InitDB(dbCfg)
 }
 
 // resetDB clean or reset database.
@@ -36,11 +29,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 +51,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 +68,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 +88,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 +105,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/config.json

@@ -36,6 +36,6 @@
 		"maxIdleNum": 20
 	},
 	"server": {
-		"hostPort": "0.0.0.0:20006"
+		"hostPort": "20006"
 	}
-}
+}

bridge-history-api/controller/controller.go

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

bridge-history-api/crossmsg/batch_info_fetcher.go

@@ -7,9 +7,10 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/log"
+	"gorm.io/gorm"
 
 	"bridge-history-api/crossmsg/messageproof"
-	"bridge-history-api/db"
+	"bridge-history-api/orm"
 	"bridge-history-api/utils"
 )
 
@@ -21,12 +22,13 @@ type BatchInfoFetcher struct {
 	confirmation         uint64
 	blockTimeInSec       int
 	client               *ethclient.Client
-	db                   db.OrmFactory
+	db                   *gorm.DB
+	rollupOrm            *orm.RollupBatch
 	msgProofUpdater      *messageproof.MsgProofUpdater
 }
 
 // NewBatchInfoFetcher creates a new BatchInfoFetcher instance
-func NewBatchInfoFetcher(ctx context.Context, scrollChainAddr common.Address, batchInfoStartNumber uint64, confirmation uint64, blockTimeInSec int, client *ethclient.Client, db db.OrmFactory, msgProofUpdater *messageproof.MsgProofUpdater) *BatchInfoFetcher {
+func NewBatchInfoFetcher(ctx context.Context, scrollChainAddr common.Address, batchInfoStartNumber uint64, confirmation uint64, blockTimeInSec int, client *ethclient.Client, db *gorm.DB, msgProofUpdater *messageproof.MsgProofUpdater) *BatchInfoFetcher {
 	return &BatchInfoFetcher{
 		ctx:                  ctx,
 		scrollChainAddr:      scrollChainAddr,
@@ -35,6 +37,7 @@ func NewBatchInfoFetcher(ctx context.Context, scrollChainAddr common.Address, ba
 		blockTimeInSec:       blockTimeInSec,
 		client:               client,
 		db:                   db,
+		rollupOrm:            orm.NewRollupBatch(db),
 		msgProofUpdater:      msgProofUpdater,
 	}
 }
@@ -80,19 +83,23 @@ func (b *BatchInfoFetcher) fetchBatchInfo() error {
 		log.Error("Can not get latest block number: ", "err", err)
 		return err
 	}
-	latestBatch, err := b.db.GetLatestRollupBatch()
+	latestBatchHeight, err := b.rollupOrm.GetLatestRollupBatchProcessedHeight(b.ctx)
 	if err != nil {
 		log.Error("Can not get latest BatchInfo: ", "err", err)
 		return err
 	}
 	var startHeight uint64
-	if latestBatch == nil {
+	if latestBatchHeight == 0 {
+		log.Info("no batch record in database, start from batchInfoStartNumber", "batchInfoStartNumber", b.batchInfoStartNumber)
 		startHeight = b.batchInfoStartNumber
 	} else {
-		startHeight = latestBatch.CommitHeight + 1
+		startHeight = latestBatchHeight + 1
 	}
-	for from := startHeight; number >= from; from += uint64(fetchLimit) {
-		to := from + uint64(fetchLimit) - 1
+	if startHeight < b.batchInfoStartNumber {
+		startHeight = b.batchInfoStartNumber
+	}
+	for from := startHeight; number >= from; from += fetchLimit {
+		to := from + fetchLimit - 1
 		// number - confirmation can never less than 0 since the for loop condition
 		// but watch out the overflow
 		if to > number {

bridge-history-api/crossmsg/block_timestamp_fetcher.go

@@ -10,10 +10,10 @@ import (
 )
 
 // GetEarliestNoBlockTimestampHeightFunc is a function type that gets the earliest record without block timestamp from database
-type GetEarliestNoBlockTimestampHeightFunc func() (uint64, error)
+type GetEarliestNoBlockTimestampHeightFunc func(ctx context.Context) (uint64, error)
 
 // UpdateBlockTimestampFunc is a function type that updates block timestamp into database
-type UpdateBlockTimestampFunc func(height uint64, timestamp time.Time) error
+type UpdateBlockTimestampFunc func(ctx context.Context, height uint64, timestamp time.Time) error
 
 // BlockTimestampFetcher fetches block timestamp from blockchain and saves them to database
 type BlockTimestampFetcher struct {
@@ -52,7 +52,7 @@ func (b *BlockTimestampFetcher) Start() {
 					log.Error("Can not get latest block number", "err", err)
 					continue
 				}
-				startHeight, err := b.getEarliestNoBlockTimestampHeightFunc()
+				startHeight, err := b.getEarliestNoBlockTimestampHeightFunc(b.ctx)
 				if err != nil {
 					log.Error("Can not get latest record without block timestamp", "err", err)
 					continue
@@ -63,12 +63,12 @@ func (b *BlockTimestampFetcher) Start() {
 						log.Error("Can not get block by number", "err", err)
 						break
 					}
-					err = b.updateBlockTimestampFunc(height, time.Unix(int64(block.Time), 0))
+					err = b.updateBlockTimestampFunc(b.ctx, height, time.Unix(int64(block.Time), 0))
 					if err != nil {
 						log.Error("Can not update blockTimestamp into DB ", "err", err)
 						break
 					}
-					height, err = b.getEarliestNoBlockTimestampHeightFunc()
+					height, err = b.getEarliestNoBlockTimestampHeightFunc(b.ctx)
 					if err != nil {
 						log.Error("Can not get latest record without block timestamp", "err", err)
 						break

bridge-history-api/crossmsg/cross_msg_fetcher.go

@@ -12,9 +12,9 @@ import (
 	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/modern-go/reflect2"
+	"gorm.io/gorm"
 
 	"bridge-history-api/config"
-	"bridge-history-api/db"
 	"bridge-history-api/utils"
 )
 
@@ -22,7 +22,7 @@ import (
 type MsgFetcher struct {
 	ctx           context.Context
 	config        *config.LayerConfig
-	db            db.OrmFactory
+	db            *gorm.DB
 	client        *ethclient.Client
 	worker        *FetchEventWorker
 	reorgHandling ReorgHandling
@@ -34,7 +34,7 @@ type MsgFetcher struct {
 }
 
 // NewMsgFetcher creates a new MsgFetcher instance
-func NewMsgFetcher(ctx context.Context, config *config.LayerConfig, db db.OrmFactory, client *ethclient.Client, worker *FetchEventWorker, addressList []common.Address, reorg ReorgHandling) (*MsgFetcher, error) {
+func NewMsgFetcher(ctx context.Context, config *config.LayerConfig, db *gorm.DB, client *ethclient.Client, worker *FetchEventWorker, addressList []common.Address, reorg ReorgHandling) (*MsgFetcher, error) {
 	msgFetcher := &MsgFetcher{
 		ctx:           ctx,
 		config:        config,
@@ -120,22 +120,23 @@ func (c *MsgFetcher) forwardFetchAndSaveMissingEvents(confirmation uint64) {
 		log.Error(fmt.Sprintf("%s: invalid get/fetch function", c.worker.Name))
 		return
 	}
-	processedHeight, err := c.worker.G(c.db)
+	processedHeight, err := c.worker.G(c.ctx, c.db)
 	if err != nil {
 		log.Error(fmt.Sprintf("%s: can not get latest processed block height", c.worker.Name))
 	}
 	log.Info(fmt.Sprintf("%s: ", c.worker.Name), "height", processedHeight)
-	if processedHeight <= 0 || processedHeight < int64(c.config.StartHeight) {
-		processedHeight = int64(c.config.StartHeight)
+	if processedHeight <= 0 || processedHeight < c.config.StartHeight {
+		processedHeight = c.config.StartHeight
 	} else {
 		processedHeight++
 	}
-	for from := processedHeight; from <= int64(number); from += fetchLimit {
+	for from := processedHeight; from <= number; from += fetchLimit {
 		to := from + fetchLimit - 1
-		if to > int64(number) {
-			to = int64(number)
+		if to > number {
+			to = number
 		}
-		err := c.worker.F(c.ctx, c.client, c.db, from, to, c.addressList)
+		// watch for overflow here, tho its unlikely to happen
+		err := c.worker.F(c.ctx, c.client, c.db, int64(from), int64(to), c.addressList)
 		if err != nil {
 			log.Error(fmt.Sprintf("%s: failed!", c.worker.Name), "err", err)
 			break
@@ -191,7 +192,7 @@ func (c *MsgFetcher) fetchMissingLatestHeaders() {
 					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)
+				err = c.reorgHandling(c.ctx, num, c.db)
 				// if handling success then we can update the cachedHeaders
 				if err == nil {
 					c.cachedHeaders = c.cachedHeaders[:0]
@@ -200,7 +201,7 @@ func (c *MsgFetcher) fetchMissingLatestHeaders() {
 				c.reorgEndCh <- struct{}{}
 				return
 			}
-			err = c.reorgHandling(c.ctx, c.cachedHeaders[index].Number.Int64(), c.db)
+			err = c.reorgHandling(c.ctx, c.cachedHeaders[index].Number.Uint64(), c.db)
 			// if handling success then we can update the cachedHeaders
 			if err == nil {
 				c.cachedHeaders = c.cachedHeaders[:index+1]

bridge-history-api/crossmsg/fetch_missing_event.go

@@ -8,23 +8,24 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/log"
+	"gorm.io/gorm"
 
 	backendabi "bridge-history-api/abi"
-	"bridge-history-api/db"
+	"bridge-history-api/orm"
 	"bridge-history-api/utils"
 )
 
 // Todo : read from config
 var (
 	// the number of blocks fetch per round
-	fetchLimit = int64(3000)
+	fetchLimit = uint64(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
+type FetchAndSave func(ctx context.Context, client *ethclient.Client, database *gorm.DB, 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 GetLatestProcessed func(ctx context.Context, db *gorm.DB) (uint64, error)
 
 // FetchEventWorker defines worker with fetch and save function, processed number getter, and name
 type FetchEventWorker struct {
@@ -34,13 +35,15 @@ type FetchEventWorker struct {
 }
 
 // GetLatestL1ProcessedHeight get L1 the latest processed height
-func GetLatestL1ProcessedHeight(db db.OrmFactory) (int64, error) {
-	crossHeight, err := db.GetLatestL1ProcessedHeight()
+func GetLatestL1ProcessedHeight(ctx context.Context, db *gorm.DB) (uint64, error) {
+	l1CrossMsgOrm := orm.NewCrossMsg(db)
+	relayedOrm := orm.NewRelayedMsg(db)
+	crossHeight, err := l1CrossMsgOrm.GetLatestL1ProcessedHeight(ctx)
 	if err != nil {
 		log.Error("failed to get L1 cross message processed height: ", "err", err)
 		return 0, err
 	}
-	relayedHeight, err := db.GetLatestRelayedHeightOnL1()
+	relayedHeight, err := relayedOrm.GetLatestRelayedHeightOnL1(ctx)
 	if err != nil {
 		log.Error("failed to get L1 relayed message processed height: ", "err", err)
 		return 0, err
@@ -52,18 +55,21 @@ func GetLatestL1ProcessedHeight(db db.OrmFactory) (int64, error) {
 }
 
 // GetLatestL2ProcessedHeight get L2 latest processed height
-func GetLatestL2ProcessedHeight(db db.OrmFactory) (int64, error) {
-	crossHeight, err := db.GetLatestL2ProcessedHeight()
+func GetLatestL2ProcessedHeight(ctx context.Context, db *gorm.DB) (uint64, error) {
+	l2CrossMsgOrm := orm.NewCrossMsg(db)
+	relayedOrm := orm.NewRelayedMsg(db)
+	l2SentMsgOrm := orm.NewL2SentMsg(db)
+	crossHeight, err := l2CrossMsgOrm.GetLatestL2ProcessedHeight(ctx)
 	if err != nil {
 		log.Error("failed to get L2 cross message processed height", "err", err)
 		return 0, err
 	}
-	relayedHeight, err := db.GetLatestRelayedHeightOnL2()
+	relayedHeight, err := relayedOrm.GetLatestRelayedHeightOnL2(ctx)
 	if err != nil {
 		log.Error("failed to get L2 relayed message processed height", "err", err)
 		return 0, err
 	}
-	l2SentHeight, err := db.GetLatestSentMsgHeightOnL2()
+	l2SentHeight, err := l2SentMsgOrm.GetLatestSentMsgHeightOnL2(ctx)
 	if err != nil {
 		log.Error("failed to get L2 sent message processed height", "err", err)
 		return 0, err
@@ -79,7 +85,9 @@ func GetLatestL2ProcessedHeight(db db.OrmFactory) (int64, error) {
 }
 
 // L1FetchAndSaveEvents fetch and save events on L1
-func L1FetchAndSaveEvents(ctx context.Context, client *ethclient.Client, database db.OrmFactory, from int64, to int64, addrList []common.Address) error {
+func L1FetchAndSaveEvents(ctx context.Context, client *ethclient.Client, db *gorm.DB, from int64, to int64, addrList []common.Address) error {
+	l1CrossMsgOrm := orm.NewCrossMsg(db)
+	relayedOrm := orm.NewRelayedMsg(db)
 	query := geth.FilterQuery{
 		FromBlock: big.NewInt(from), // inclusive
 		ToBlock:   big.NewInt(to),   // inclusive
@@ -105,41 +113,28 @@ func L1FetchAndSaveEvents(ctx context.Context, client *ethclient.Client, databas
 		log.Error("l1FetchAndSaveEvents: Failed to parse cross msg event logs", "err", err)
 		return err
 	}
-	dbTx, err := database.Beginx()
-	if err != nil {
-		log.Error("l2FetchAndSaveEvents: Failed to begin db transaction", "err", err)
-		return err
-	}
-	err = database.BatchInsertL1CrossMsgDBTx(dbTx, depositL1CrossMsgs)
-	if err != nil {
-		if rollBackErr := dbTx.Rollback(); rollBackErr != nil {
-			log.Error("dbTx Rollback failed", "err", rollBackErr)
+	err = db.Transaction(func(tx *gorm.DB) error {
+		if txErr := l1CrossMsgOrm.InsertL1CrossMsg(ctx, depositL1CrossMsgs, tx); txErr != nil {
+			log.Error("l1FetchAndSaveEvents: Failed to insert cross msg event logs", "err", txErr)
+			return txErr
 		}
-		log.Crit("l1FetchAndSaveEvents: Failed to insert cross msg event logs", "err", err)
-	}
-
-	err = database.BatchInsertRelayedMsgDBTx(dbTx, relayedMsg)
-	if err != nil {
-		if rollBackErr := dbTx.Rollback(); rollBackErr != nil {
-			log.Error("dbTx Rollback failed", "err", rollBackErr)
+		if txErr := relayedOrm.InsertRelayedMsg(ctx, relayedMsg, tx); txErr != nil {
+			log.Error("l1FetchAndSaveEvents: Failed to insert relayed msg event logs", "err", txErr)
+			return txErr
 		}
-		log.Crit("l1FetchAndSaveEvents: Failed to insert relayed message event logs", "err", err)
-	}
-	err = dbTx.Commit()
+		return nil
+	})
 	if err != nil {
-		// if we can not insert into DB, there must something wrong, need a on-call member handle the dababase manually
-		if rollBackErr := dbTx.Rollback(); rollBackErr != nil {
-			log.Error("dbTx Rollback failed", "err", rollBackErr)
-		}
-		log.Error("l1FetchAndSaveEvents: Failed to commit db transaction", "err", err)
-		return err
+		log.Crit("l2FetchAndSaveEvents: Failed to finish transaction", "err", err)
 	}
-
-	return nil
+	return err
 }
 
 // L2FetchAndSaveEvents fetche and save events on L2
-func L2FetchAndSaveEvents(ctx context.Context, client *ethclient.Client, database db.OrmFactory, from int64, to int64, addrList []common.Address) error {
+func L2FetchAndSaveEvents(ctx context.Context, client *ethclient.Client, db *gorm.DB, from int64, to int64, addrList []common.Address) error {
+	l2CrossMsgOrm := orm.NewCrossMsg(db)
+	relayedOrm := orm.NewRelayedMsg(db)
+	l2SentMsgOrm := orm.NewL2SentMsg(db)
 	query := geth.FilterQuery{
 		FromBlock: big.NewInt(from), // inclusive
 		ToBlock:   big.NewInt(to),   // inclusive
@@ -166,50 +161,32 @@ func L2FetchAndSaveEvents(ctx context.Context, client *ethclient.Client, databas
 		return err
 	}
 
-	dbTx, err := database.Beginx()
-	if err != nil {
-		log.Error("l2FetchAndSaveEvents: Failed to begin db transaction", "err", err)
-		return err
-	}
-	err = database.BatchInsertL2CrossMsgDBTx(dbTx, depositL2CrossMsgs)
-	if err != nil {
-		if rollBackErr := dbTx.Rollback(); rollBackErr != nil {
-			log.Error("dbTx Rollback failed", "err", rollBackErr)
+	err = db.Transaction(func(tx *gorm.DB) error {
+		if txErr := l2CrossMsgOrm.InsertL2CrossMsg(ctx, depositL2CrossMsgs, tx); txErr != nil {
+			log.Error("l2FetchAndSaveEvents: Failed to insert cross msg event logs", "err", txErr)
+			return txErr
 		}
-		log.Crit("l2FetchAndSaveEvents: Failed to insert cross msg event logs", "err", err)
-	}
 
-	err = database.BatchInsertRelayedMsgDBTx(dbTx, relayedMsg)
-	if err != nil {
-		if rollBackErr := dbTx.Rollback(); rollBackErr != nil {
-			log.Error("dbTx Rollback failed", "err", rollBackErr)
+		if txErr := relayedOrm.InsertRelayedMsg(ctx, relayedMsg, tx); txErr != nil {
+			log.Error("l2FetchAndSaveEvents: Failed to insert relayed message event logs", "err", txErr)
+			return txErr
 		}
-		log.Crit("l2FetchAndSaveEvents: Failed to insert relayed message event logs", "err", err)
-	}
 
-	err = database.BatchInsertL2SentMsgDBTx(dbTx, l2SentMsgs)
-	if err != nil {
-		if rollBackErr := dbTx.Rollback(); rollBackErr != nil {
-			log.Error("dbTx Rollback failed", "err", rollBackErr)
+		if txErr := l2SentMsgOrm.InsertL2SentMsg(ctx, l2SentMsgs, tx); txErr != nil {
+			log.Error("l2FetchAndSaveEvents: Failed to insert l2 sent message", "err", txErr)
+			return txErr
 		}
-		log.Crit("l2FetchAndSaveEvents: Failed to insert l2 sent message", "err", err)
-	}
-
-	err = dbTx.Commit()
+		return nil
+	})
 	if err != nil {
-		// if we can not insert into DB, there must something wrong, need a on-call member handle the dababase manually
-		if rollBackErr := dbTx.Rollback(); rollBackErr != nil {
-			log.Error("dbTx Rollback failed", "err", rollBackErr)
-		}
-		log.Error("l2FetchAndSaveEvents: Failed to commit db transaction", "err", err)
-		return err
+		log.Crit("l2FetchAndSaveEvents: Failed to begin db transaction", "err", err)
 	}
-
-	return nil
+	return err
 }
 
 // FetchAndSaveBatchIndex fetche and save batch index
-func FetchAndSaveBatchIndex(ctx context.Context, client *ethclient.Client, database db.OrmFactory, from int64, to int64, scrollChainAddr common.Address) error {
+func FetchAndSaveBatchIndex(ctx context.Context, client *ethclient.Client, db *gorm.DB, from int64, to int64, scrollChainAddr common.Address) error {
+	rollupBatchOrm := orm.NewRollupBatch(db)
 	query := geth.FilterQuery{
 		FromBlock: big.NewInt(from), // inclusive
 		ToBlock:   big.NewInt(to),   // inclusive
@@ -228,26 +205,9 @@ func FetchAndSaveBatchIndex(ctx context.Context, client *ethclient.Client, datab
 		log.Error("FetchAndSaveBatchIndex: Failed to parse batch commit msg event logs", "err", err)
 		return err
 	}
-	dbTx, err := database.Beginx()
-	if err != nil {
-		log.Error("FetchAndSaveBatchIndex: Failed to begin db transaction", "err", err)
-		return err
-	}
-	err = database.BatchInsertRollupBatchDBTx(dbTx, rollupBatches)
-	if err != nil {
-		if rollBackErr := dbTx.Rollback(); rollBackErr != nil {
-			log.Error("dbTx Rollback failed", "err", rollBackErr)
-		}
-		log.Crit("FetchAndSaveBatchIndex: Failed to insert batch commit msg event logs", "err", err)
-	}
-	err = dbTx.Commit()
-	if err != nil {
-		// if we can not insert into DB, there must something wrong, need a on-call member handle the dababase manually
-		if rollBackErr := dbTx.Rollback(); rollBackErr != nil {
-			log.Error("dbTx Rollback failed", "err", rollBackErr)
-		}
-		log.Error("FetchAndSaveBatchIndex: Failed to commit db transaction", "err", err)
-		return err
+	if txErr := rollupBatchOrm.InsertRollupBatch(ctx, rollupBatches); txErr != nil {
+		log.Crit("FetchAndSaveBatchIndex: Failed to insert batch commit msg event logs", "err", txErr)
+		return txErr
 	}
 	return nil
 }

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

@@ -2,30 +2,32 @@ package messageproof
 
 import (
 	"context"
-	"database/sql"
-	"errors"
 	"fmt"
 	"time"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/log"
+	"gorm.io/gorm"
 
-	"bridge-history-api/db"
-	"bridge-history-api/db/orm"
+	"bridge-history-api/orm"
 )
 
 // MsgProofUpdater is used to update message proof in db
 type MsgProofUpdater struct {
 	ctx          context.Context
-	db           db.OrmFactory
+	db           *gorm.DB
+	l2SentMsgOrm *orm.L2SentMsg
+	rollupOrm    *orm.RollupBatch
 	withdrawTrie *WithdrawTrie
 }
 
 // NewMsgProofUpdater new MsgProofUpdater instance
-func NewMsgProofUpdater(ctx context.Context, confirmations uint64, startBlock uint64, db db.OrmFactory) *MsgProofUpdater {
+func NewMsgProofUpdater(ctx context.Context, confirmations uint64, startBlock uint64, db *gorm.DB) *MsgProofUpdater {
 	return &MsgProofUpdater{
 		ctx:          ctx,
 		db:           db,
+		l2SentMsgOrm: orm.NewL2SentMsg(db),
+		rollupOrm:    orm.NewRollupBatch(db),
 		withdrawTrie: NewWithdrawTrie(),
 	}
 }
@@ -42,7 +44,7 @@ func (m *MsgProofUpdater) Start() {
 				tick.Stop()
 				return
 			case <-tick.C:
-				latestBatch, err := m.db.GetLatestRollupBatch()
+				latestBatch, err := m.rollupOrm.GetLatestRollupBatch(m.ctx)
 				if err != nil {
 					log.Warn("MsgProofUpdater: Can not get latest RollupBatch: ", "err", err)
 					continue
@@ -50,11 +52,12 @@ func (m *MsgProofUpdater) Start() {
 				if latestBatch == nil {
 					continue
 				}
-				latestBatchIndexWithProof, err := m.db.GetLatestL2SentMsgBatchIndex()
+				latestBatchIndexWithProof, err := m.l2SentMsgOrm.GetLatestL2SentMsgBatchIndex(m.ctx)
 				if err != nil {
 					log.Error("MsgProofUpdater: Can not get latest L2SentMsgBatchIndex: ", "err", err)
 					continue
 				}
+				log.Info("latest batch with proof", "batch_index", latestBatchIndexWithProof)
 				var start uint64
 				if latestBatchIndexWithProof < 0 {
 					start = 1
@@ -62,7 +65,7 @@ func (m *MsgProofUpdater) Start() {
 					start = uint64(latestBatchIndexWithProof) + 1
 				}
 				for i := start; i <= latestBatch.BatchIndex; i++ {
-					batch, err := m.db.GetRollupBatchByIndex(i)
+					batch, err := m.rollupOrm.GetRollupBatchByIndex(m.ctx, i)
 					if err != nil {
 						log.Error("MsgProofUpdater: Can not get RollupBatch: ", "err", err, "index", i)
 						break
@@ -73,8 +76,16 @@ func (m *MsgProofUpdater) Start() {
 						log.Error("MsgProofUpdater: can not append l2messages", "startBlockNumber", batch.StartBlockNumber, "endBlockNumber", batch.EndBlockNumber, "err", err)
 						break
 					}
+					// here we update batch withdraw root
+					err = m.rollupOrm.UpdateRollupBatchWithdrawRoot(m.ctx, batch.BatchIndex, m.withdrawTrie.MessageRoot().Hex())
+					if err != nil {
+						// if failed better restart the binary
+						log.Error("MsgProofUpdater: can not update batch withdraw root", "err", err)
+						break
+					}
 					err = m.updateMsgProof(msgs, proofs, batch.BatchIndex)
 					if err != nil {
+						// if failed better restart the binary
 						log.Error("MsgProofUpdater: can not update msg proof", "err", err)
 						break
 					}
@@ -111,8 +122,8 @@ func (m *MsgProofUpdater) initialize(ctx context.Context) {
 
 func (m *MsgProofUpdater) initializeWithdrawTrie() error {
 	var batch *orm.RollupBatch
-	firstMsg, err := m.db.GetL2SentMessageByNonce(0)
-	if err != nil && !errors.Is(err, sql.ErrNoRows) {
+	firstMsg, err := m.l2SentMsgOrm.GetL2SentMessageByNonce(m.ctx, 0)
+	if err != nil {
 		return fmt.Errorf("failed to get first l2 message: %v", err)
 	}
 	// no l2 message
@@ -123,7 +134,7 @@ func (m *MsgProofUpdater) initializeWithdrawTrie() error {
 	}
 
 	// if no batch, return and wait for next try round
-	batch, err = m.db.GetLatestRollupBatch()
+	batch, err = m.rollupOrm.GetLatestRollupBatch(m.ctx)
 	if err != nil {
 		return fmt.Errorf("failed to get latest batch: %v", err)
 	}
@@ -135,7 +146,7 @@ func (m *MsgProofUpdater) initializeWithdrawTrie() error {
 	batchIndex := batch.BatchIndex
 	for {
 		var msg *orm.L2SentMsg
-		msg, err = m.db.GetLatestL2SentMsgLEHeight(batch.EndBlockNumber)
+		msg, err = m.l2SentMsgOrm.GetLatestL2SentMsgLEHeight(m.ctx, batch.EndBlockNumber)
 		if err != nil {
 			log.Warn("failed to get l2 sent message less than height", "endBlocknum", batch.EndBlockNumber, "err", err)
 		}
@@ -159,8 +170,8 @@ func (m *MsgProofUpdater) initializeWithdrawTrie() error {
 		// iterate for next batch
 		batchIndex--
 
-		batch, err = m.db.GetRollupBatchByIndex(batchIndex)
-		if err != nil {
+		batch, err = m.rollupOrm.GetRollupBatchByIndex(m.ctx, batchIndex)
+		if err != nil || batch == nil {
 			return fmt.Errorf("failed to get block batch %v: %v", batchIndex, err)
 		}
 	}
@@ -172,7 +183,10 @@ func (m *MsgProofUpdater) initializeWithdrawTrie() error {
 		if err != nil {
 			return err
 		}
-
+		err = m.rollupOrm.UpdateRollupBatchWithdrawRoot(m.ctx, b.BatchIndex, m.withdrawTrie.MessageRoot().Hex())
+		if err != nil {
+			return err
+		}
 		err = m.updateMsgProof(msgs, proofs, b.BatchIndex)
 		if err != nil {
 			return err
@@ -191,36 +205,26 @@ func (m *MsgProofUpdater) updateMsgProof(msgs []*orm.L2SentMsg, proofs [][]byte,
 	if len(msgs) != len(proofs) {
 		return fmt.Errorf("illegal state: len(msgs) != len(proofs)")
 	}
-	dbTx, err := m.db.Beginx()
+	err := m.db.Transaction(func(tx *gorm.DB) error {
+		for i, msg := range msgs {
+			proofHex := common.Bytes2Hex(proofs[i])
+			log.Debug("updateMsgProof", "msgHash", msg.MsgHash, "batchIndex", batchIndex, "proof", proofHex)
+			if err := m.l2SentMsgOrm.UpdateL2MessageProof(m.ctx, msg.MsgHash, proofHex, batchIndex, tx); err != nil {
+				return err
+			}
+		}
+		return nil
+	})
 	if err != nil {
 		return err
 	}
-
-	for i, msg := range msgs {
-		proofHex := common.Bytes2Hex(proofs[i])
-		log.Debug("updateMsgProof", "msgHash", msg.MsgHash, "batchIndex", batchIndex, "proof", proofHex)
-		if dbTxErr := m.db.UpdateL2MessageProofInDBTx(m.ctx, dbTx, msg.MsgHash, proofHex, batchIndex); dbTxErr != nil {
-			if err := dbTx.Rollback(); err != nil {
-				log.Error("dbTx.Rollback()", "err", err)
-			}
-			return dbTxErr
-		}
-	}
-
-	if dbTxErr := dbTx.Commit(); dbTxErr != nil {
-		if err := dbTx.Rollback(); err != nil {
-			log.Error("dbTx.Rollback()", "err", err)
-		}
-		return dbTxErr
-	}
-
 	return nil
 }
 
 // appendL2Messages will append all messages between firstBlock and lastBlock (both inclusive) to withdrawTrie and compute corresponding merkle proof of each message.
 func (m *MsgProofUpdater) appendL2Messages(firstBlock, lastBlock uint64) ([]*orm.L2SentMsg, [][]byte, error) {
 	var msgProofs [][]byte
-	messages, err := m.db.GetL2SentMsgMsgHashByHeightRange(firstBlock, lastBlock)
+	messages, err := m.l2SentMsgOrm.GetL2SentMsgMsgHashByHeightRange(m.ctx, firstBlock, lastBlock)
 	if err != nil {
 		log.Error("GetL2SentMsgMsgHashByHeightRange failed", "error", err, "firstBlock", firstBlock, "lastBlock", lastBlock)
 		return messages, msgProofs, err

bridge-history-api/crossmsg/reorg_handle.go

@@ -6,12 +6,13 @@ import (
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/log"
+	"gorm.io/gorm"
 
-	"bridge-history-api/db"
+	"bridge-history-api/orm"
 )
 
 // ReorgHandling handles reorg function type
-type ReorgHandling func(ctx context.Context, reorgHeight int64, db db.OrmFactory) error
+type ReorgHandling func(ctx context.Context, reorgHeight uint64, db *gorm.DB) error
 
 func reverseArray(arr []*types.Header) []*types.Header {
 	for i := 0; i < len(arr)/2; i++ {
@@ -60,73 +61,48 @@ func BackwardFindReorgBlock(ctx context.Context, headers []*types.Header, client
 }
 
 // L1ReorgHandling handles l1 reorg
-func L1ReorgHandling(ctx context.Context, reorgHeight int64, db db.OrmFactory) error {
-	dbTx, err := db.Beginx()
-	if err != nil {
-		log.Crit("begin db tx failed", "err", err)
-	}
-	err = db.DeleteL1CrossMsgAfterHeightDBTx(dbTx, reorgHeight)
-	if err != nil {
-		if rollBackErr := dbTx.Rollback(); rollBackErr != nil {
-			log.Error("dbTx Rollback failed", "err", rollBackErr)
+func L1ReorgHandling(ctx context.Context, reorgHeight uint64, db *gorm.DB) error {
+	l1CrossMsgOrm := orm.NewCrossMsg(db)
+	relayedOrm := orm.NewRelayedMsg(db)
+	err := db.Transaction(func(tx *gorm.DB) error {
+		if err := l1CrossMsgOrm.DeleteL1CrossMsgAfterHeight(ctx, reorgHeight, tx); err != nil {
+			log.Error("delete l1 cross msg from height", "height", reorgHeight, "err", err)
+			return err
 		}
-		log.Crit("delete l1 cross msg from height", "height", reorgHeight, "err", err)
-	}
-	err = db.DeleteL1RelayedHashAfterHeightDBTx(dbTx, reorgHeight)
-	if err != nil {
-		if rollBackErr := dbTx.Rollback(); rollBackErr != nil {
-			log.Error("dbTx Rollback failed", "err", rollBackErr)
+		if err := relayedOrm.DeleteL1RelayedHashAfterHeight(ctx, reorgHeight, tx); err != nil {
+			log.Error("delete l1 relayed msg from height", "height", reorgHeight, "err", err)
+			return err
 		}
-		log.Crit("delete l1 relayed hash from height", "height", reorgHeight, "err", err)
-	}
-	err = dbTx.Commit()
+		return nil
+	})
 	if err != nil {
-		if rollBackErr := dbTx.Rollback(); rollBackErr != nil {
-			log.Error("dbTx Rollback failed", "err", rollBackErr)
-		}
-		log.Error("commit tx failed", "err", err)
-		return err
+		log.Crit("l1 reorg handling failed", "err", err)
 	}
-	return nil
+	return err
 }
 
 // L2ReorgHandling handles l2 reorg
-func L2ReorgHandling(ctx context.Context, reorgHeight int64, db db.OrmFactory) error {
-	dbTx, err := db.Beginx()
-	if err != nil {
-		if rollBackErr := dbTx.Rollback(); rollBackErr != nil {
-			log.Error("dbTx Rollback failed", "err", rollBackErr)
+func L2ReorgHandling(ctx context.Context, reorgHeight uint64, db *gorm.DB) error {
+	l2CrossMsgOrm := orm.NewCrossMsg(db)
+	relayedOrm := orm.NewRelayedMsg(db)
+	l2SentMsgOrm := orm.NewL2SentMsg(db)
+	err := db.Transaction(func(tx *gorm.DB) error {
+		if err := l2CrossMsgOrm.DeleteL2CrossMsgFromHeight(ctx, reorgHeight, tx); err != nil {
+			log.Error("delete l2 cross msg from height", "height", reorgHeight, "err", err)
+			return err
 		}
-		log.Crit("begin db tx failed", "err", err)
-	}
-	err = db.DeleteL2CrossMsgFromHeightDBTx(dbTx, reorgHeight)
-	if err != nil {
-		if rollBackErr := dbTx.Rollback(); rollBackErr != nil {
-			log.Error("dbTx Rollback failed", "err", rollBackErr)
+		if err := relayedOrm.DeleteL2RelayedHashAfterHeight(ctx, reorgHeight, tx); err != nil {
+			log.Error("delete l2 relayed msg from height", "height", reorgHeight, "err", err)
+			return err
 		}
-		log.Crit("delete l2 cross msg from height", "height", reorgHeight, "err", err)
-	}
-	err = db.DeleteL2RelayedHashAfterHeightDBTx(dbTx, reorgHeight)
-	if err != nil {
-		if rollBackErr := dbTx.Rollback(); rollBackErr != nil {
-			log.Error("dbTx Rollback failed", "err", rollBackErr)
+		if err := l2SentMsgOrm.DeleteL2SentMsgAfterHeight(ctx, reorgHeight, tx); err != nil {
+			log.Error("delete l2 sent msg from height", "height", reorgHeight, "err", err)
+			return err
 		}
-		log.Crit("delete l2 relayed hash from height", "height", reorgHeight, "err", err)
-	}
-	err = db.DeleteL2SentMsgAfterHeightDBTx(dbTx, reorgHeight)
+		return nil
+	})
 	if err != nil {
-		if rollBackErr := dbTx.Rollback(); rollBackErr != nil {
-			log.Error("dbTx Rollback failed", "err", rollBackErr)
-		}
-		log.Crit("delete l2 sent msg from height", "height", reorgHeight, "err", err)
+		log.Crit("l2 reorg handling failed", "err", err)
 	}
-	err = dbTx.Commit()
-	if err != nil {
-		if rollBackErr := dbTx.Rollback(); rollBackErr != nil {
-			log.Error("dbTx Rollback failed", "err", rollBackErr)
-		}
-		log.Error("commit tx failed", "err", err)
-		return err
-	}
-	return nil
+	return err
 }

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

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

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

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

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

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

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

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

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

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

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

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

bridge-history-api/db/orm_factory.go

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

bridge-history-api/go.mod

@@ -3,35 +3,29 @@ module bridge-history-api
 go 1.19
 
 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/ethereum/go-ethereum v1.12.2
+	github.com/gin-contrib/cors v1.4.0
+	github.com/gin-gonic/gin v1.9.1
 	github.com/mattn/go-colorable v0.1.13
 	github.com/mattn/go-isatty v0.0.19
 	github.com/modern-go/reflect2 v1.0.2
 	github.com/pressly/goose/v3 v3.7.0
 	github.com/stretchr/testify v1.8.3
 	github.com/urfave/cli/v2 v2.25.7
+	gorm.io/driver/postgres v1.5.0
+	gorm.io/gorm v1.25.2
 )
 
 require (
-	github.com/BurntSushi/toml v1.3.2 // indirect
-	github.com/CloudyKit/fastprinter v0.0.0-20200109182630-33d98a066a53 // indirect
-	github.com/CloudyKit/jet/v6 v6.2.0 // indirect
 	github.com/DataDog/zstd v1.5.2 // indirect
-	github.com/Joker/jade v1.1.3 // indirect
-	github.com/Shopify/goreferrer v0.0.0-20220729165902-8cddb4f5de06 // indirect
 	github.com/VictoriaMetrics/fastcache v1.6.0 // indirect
-	github.com/andybalholm/brotli v1.0.5 // indirect
-	github.com/aymerick/douceur v0.2.0 // indirect
 	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/btcsuite/btcd v0.20.1-beta // indirect
 	github.com/btcsuite/btcd/btcec/v2 v2.3.2 // indirect
+	github.com/bytedance/sonic v1.9.2 // indirect
 	github.com/cespare/xxhash/v2 v2.2.0 // indirect
+	github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311 // 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
@@ -39,72 +33,64 @@ require (
 	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/crate-crypto/go-kzg-4844 v0.3.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/docker/docker v23.0.6+incompatible // indirect
+	github.com/ethereum/c-kzg-4844 v0.3.1 // indirect
 	github.com/fjl/memsize v0.0.0-20190710130421-bcb5799ab5e5 // indirect
-	github.com/flosch/pongo2/v4 v4.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/gin-contrib/sse v0.1.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-playground/locales v0.14.1 // indirect
+	github.com/go-playground/universal-translator v0.18.1 // indirect
+	github.com/go-playground/validator/v10 v10.14.1 // 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/goccy/go-json v0.10.2 // 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/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/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/holiman/billy v0.0.0-20230718173358-1c7e68d277a7 // indirect
 	github.com/holiman/bloomfilter/v2 v2.0.3 // indirect
-	github.com/holiman/uint256 v1.2.2 // indirect
+	github.com/holiman/uint256 v1.2.3 // 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/jackc/pgpassfile v1.0.0 // indirect
+	github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a // indirect
+	github.com/jackc/pgx/v5 v5.3.1 // 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/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.16.0 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.5 // indirect
 	github.com/kr/pretty v0.3.1 // indirect
 	github.com/kr/text v0.2.0 // indirect
-	github.com/mailgun/raymond/v2 v2.0.48 // indirect
-	github.com/mailru/easyjson v0.7.7 // indirect
+	github.com/leodido/go-urn v1.2.4 // indirect
 	github.com/mattn/go-runewidth v0.0.14 // indirect
-	github.com/mattn/go-sqlite3 v1.14.14 // indirect
 	github.com/matttproud/golang_protobuf_extensions v1.0.4 // indirect
-	github.com/mediocregopher/radix/v3 v3.8.1 // indirect
-	github.com/microcosm-cc/bluemonday v1.0.23 // indirect
 	github.com/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/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/pelletier/go-toml/v2 v2.0.8 // indirect
 	github.com/peterh/liner v1.1.1-0.20190123174540-a2c9a5303de7 // indirect
 	github.com/pkg/errors v0.9.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
@@ -116,35 +102,27 @@ require (
 	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/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 // 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/twitchyliquid64/golang-asm v0.15.1 // indirect
 	github.com/tyler-smith/go-bip39 v1.1.0 // indirect
-	github.com/valyala/bytebufferpool v1.0.0 // indirect
-	github.com/vmihailenco/msgpack/v5 v5.3.5 // indirect
-	github.com/vmihailenco/tagparser/v2 v2.0.0 // indirect
+	github.com/ugorji/go/codec v1.2.11 // indirect
 	github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 // indirect
-	github.com/yosssi/ace v0.0.5 // indirect
 	github.com/yusufpapurcu/wmi v1.2.2 // indirect
-	golang.org/x/crypto v0.11.0 // indirect
-	golang.org/x/exp v0.0.0-20230206171751-46f607a40771 // indirect
-	golang.org/x/net v0.12.0 // indirect
+	golang.org/x/arch v0.4.0 // indirect
+	golang.org/x/crypto v0.12.0 // indirect
+	golang.org/x/exp v0.0.0-20230810033253-352e893a4cad // indirect
+	golang.org/x/net v0.14.0 // indirect
 	golang.org/x/sync v0.3.0 // indirect
-	golang.org/x/sys v0.10.0 // indirect
-	golang.org/x/text v0.11.0 // indirect
+	golang.org/x/sys v0.11.0 // indirect
+	golang.org/x/text v0.12.0 // indirect
 	golang.org/x/time v0.3.0 // indirect
 	golang.org/x/tools v0.11.0 // indirect
-	golang.org/x/xerrors v0.0.0-20220517211312-f3a8303e98df // indirect
 	google.golang.org/protobuf v1.31.0 // indirect
-	gopkg.in/ini.v1 v1.67.0 // indirect
 	gopkg.in/natefinch/lumberjack.v2 v2.0.0 // indirect
 	gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect

bridge-history-api/go.sum

@@ -2,40 +2,24 @@ cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMT
 github.com/AndreasBriese/bbloom v0.0.0-20190306092124-e2d15f34fcf9/go.mod h1:bOvUY6CB00SOBii9/FifXqc0awNKxLFCL/+pkDPuyl8=
 github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
 github.com/BurntSushi/toml v1.3.2 h1:o7IhLm0Msx3BaB+n3Ag7L8EVlByGnpq14C4YWiu/gL8=
-github.com/BurntSushi/toml v1.3.2/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ=
-github.com/CloudyKit/fastprinter v0.0.0-20200109182630-33d98a066a53 h1:sR+/8Yb4slttB4vD+b9btVEnWgL3Q00OBTzVT8B9C0c=
 github.com/CloudyKit/fastprinter v0.0.0-20200109182630-33d98a066a53/go.mod h1:+3IMCy2vIlbG1XG/0ggNQv0SvxCAIpPM5b1nCz56Xno=
 github.com/CloudyKit/jet/v3 v3.0.0/go.mod h1:HKQPgSJmdK8hdoAbKUUWajkHyHo4RaU5rMdUywE7VMo=
-github.com/CloudyKit/jet/v6 v6.2.0 h1:EpcZ6SR9n28BUGtNJSvlBqf90IpjeFr36Tizxhn/oME=
-github.com/CloudyKit/jet/v6 v6.2.0/go.mod h1:d3ypHeIRNo2+XyqnGA8s+aphtcVpjP5hPwP/Lzo7Ro4=
 github.com/DataDog/zstd v1.5.2 h1:vUG4lAyuPCXO0TLbXvPv7EB7cNK1QV/luu55UHLrrn8=
 github.com/DataDog/zstd v1.5.2/go.mod h1:g4AWEaM3yOg3HYfnJ3YIawPnVdXJh9QME85blwSAmyw=
-github.com/Joker/hpp v1.0.0 h1:65+iuJYdRXv/XyN62C1uEmmOx3432rNG/rKlX6V7Kkc=
 github.com/Joker/hpp v1.0.0/go.mod h1:8x5n+M1Hp5hC0g8okX3sR3vFQwynaX/UgSOM9MeBKzY=
-github.com/Joker/jade v1.1.3 h1:Qbeh12Vq6BxURXT1qZBRHsDxeURB8ztcL6f3EXSGeHk=
-github.com/Joker/jade v1.1.3/go.mod h1:T+2WLyt7VH6Lp0TRxQrUYEs64nRc83wkMQrfeIQKduM=
 github.com/Shopify/goreferrer v0.0.0-20181106222321-ec9c9a553398/go.mod h1:a1uqRtAwp2Xwc6WNPJEufxJ7fx3npB4UV/JOLmbu5I0=
-github.com/Shopify/goreferrer v0.0.0-20220729165902-8cddb4f5de06 h1:KkH3I3sJuOLP3TjA/dfr4NAY8bghDwnXiU7cTKxQqo0=
-github.com/Shopify/goreferrer v0.0.0-20220729165902-8cddb4f5de06/go.mod h1:7erjKLwalezA0k99cWs5L11HWOAPNjdUZ6RxH1BXbbM=
 github.com/VictoriaMetrics/fastcache v1.6.0 h1:C/3Oi3EiBCqufydp1neRZkqcwmEiuRT9c3fqvvgKm5o=
 github.com/VictoriaMetrics/fastcache v1.6.0/go.mod h1:0qHz5QP0GMX4pfmMA/zt5RgfNuXJrTP0zS7DqpHGGTw=
 github.com/aead/siphash v1.0.1/go.mod h1:Nywa3cDsYNNK3gaciGTWPwHt0wlpNV15vwmswBAUSII=
-github.com/ajg/form v1.5.1 h1:t9c7v8JUKu/XxOGBU0yjNpaMloxGEJhUkqFRq0ibGeU=
 github.com/ajg/form v1.5.1/go.mod h1:uL1WgH+h2mgNtvBq0339dVnzXdBETtL2LeUXaIv25UY=
 github.com/allegro/bigcache v1.2.1-0.20190218064605-e24eb225f156 h1:eMwmnE/GDgah4HI848JfFxHt+iPb26b4zyfspmqY0/8=
 github.com/allegro/bigcache v1.2.1-0.20190218064605-e24eb225f156/go.mod h1:Cb/ax3seSYIx7SuZdm2G2xzfwmv3TPSk2ucNfQESPXM=
-github.com/andybalholm/brotli v1.0.5 h1:8uQZIdzKmjc/iuPu7O2ioW48L81FgatrcpfFmiq/cCs=
-github.com/andybalholm/brotli v1.0.5/go.mod h1:fO7iG3H7G2nSZ7m0zPUDn85XEX2GTukHGRSepvi9Eig=
 github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8=
-github.com/aymerick/douceur v0.2.0 h1:Mv+mAeH1Q+n9Fr+oyamOlAkUNPWPlA8PPGR0QAaYuPk=
-github.com/aymerick/douceur v0.2.0/go.mod h1:wlT5vV2O3h55X9m7iVYN0TBM0NH/MmbLnd30/FjWUq4=
 github.com/aymerick/raymond v2.0.3-0.20180322193309-b565731e1464+incompatible/go.mod h1:osfaiScAUVup+UC9Nfq76eWqDhXlp+4UYaA8uhTBO6g=
 github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
 github.com/bits-and-blooms/bitset v1.7.0 h1:YjAGVd3XmtK9ktAbX8Zg2g2PwLIMjGREZJHlV4j7NEo=
 github.com/bits-and-blooms/bitset v1.7.0/go.mod h1:gIdJ4wp64HaoK2YrL1Q5/N7Y16edYb8uY+O0FJTyyDA=
-github.com/blang/semver/v4 v4.0.0 h1:1PFHFE6yCCTv8C1TeyNNarDzntLi7wMI5i/pzqYIsAM=
-github.com/blang/semver/v4 v4.0.0/go.mod h1:IbckMUScFkM3pff0VJDNKRiT6TG/YpiHIM2yvyW5YoQ=
 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/btcd/btcec/v2 v2.3.2 h1:5n0X6hX0Zk+6omWcihdYvdAlGf2DfasC0GMf7DClJ3U=
@@ -47,12 +31,17 @@ github.com/btcsuite/goleveldb v0.0.0-20160330041536-7834afc9e8cd/go.mod h1:F+uVa
 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/bytedance/sonic v1.5.0/go.mod h1:ED5hyg4y6t3/9Ku1R6dU/4KyJ48DZ4jPhfY1O2AihPM=
+github.com/bytedance/sonic v1.9.2 h1:GDaNjuWSGu09guE9Oql0MSTNhNCLlWwO8y/xM5BzcbM=
+github.com/bytedance/sonic v1.9.2/go.mod h1:i736AoUSYt75HyZLoJW9ERYxcy6eaN6h4BZXU064P/U=
 github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
 github.com/cespare/cp v0.1.0 h1:SE+dxFebS7Iik5LK0tsi1k9ZCxEaFX4AjQmoyA+1dJk=
 github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 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/cheekybits/is v0.0.0-20150225183255-68e9c0620927/go.mod h1:h/aW8ynjgkuj+NQRlZcDbAbM1ORAbXjXX77sX7T289U=
+github.com/chenzhuoyu/base64x v0.0.0-20211019084208-fb5309c8db06/go.mod h1:DH46F32mSOjUmXrMHnKwZdA8wcEefY7UVqBKYGjpdQY=
+github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311 h1:qSGYFH7+jGhDF8vLC+iwCD4WpbV1EBDSzWkJODFLams=
+github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311/go.mod h1:b583jCggY9gE99b6G5LEC39OIiVsWj+R97kbl5odCEk=
 github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
 github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk=
 github.com/cockroachdb/datadriven v1.0.2 h1:H9MtNqVoVhvd9nCBwOyDjUEdZCREqbIdCJD93PBm/jA=
@@ -77,8 +66,8 @@ github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3Ee
 github.com/cpuguy83/go-md2man v1.0.10/go.mod h1:SmD6nW6nTyfqj6ABTjUi3V3JVMnlJmwcJI5acqYI6dE=
 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/crate-crypto/go-kzg-4844 v0.2.0 h1:UVuHOE+5tIWrim4zf/Xaa43+MIsDCPyW76QhUpiMGj4=
-github.com/crate-crypto/go-kzg-4844 v0.2.0/go.mod h1:SBP7ikXEgDnUPONgm33HtuDZEDtWa3L4QtN1ocJSEQ4=
+github.com/crate-crypto/go-kzg-4844 v0.3.0 h1:UBlWE0CgyFqqzTI+IFyCzA7A3Zw4iip6uzRv5NIXG0A=
+github.com/crate-crypto/go-kzg-4844 v0.3.0/go.mod h1:SBP7ikXEgDnUPONgm33HtuDZEDtWa3L4QtN1ocJSEQ4=
 github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
 github.com/cyberdelia/templates v0.0.0-20141128023046-ca7fffd4298c/go.mod h1:GyV+0YP4qX0UQ7r2MoYZ+AvYDp12OF5yg4q8rGnyNh4=
 github.com/davecgh/go-spew v0.0.0-20171005155431-ecdeabc65495/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
@@ -96,33 +85,29 @@ github.com/deepmap/oapi-codegen v1.8.2/go.mod h1:YLgSKSDv/bZQB7N4ws6luhozi3cEdRk
 github.com/dgraph-io/badger v1.6.0/go.mod h1:zwt7syl517jmP8s94KqSxTlM6IMsdhYy6psNgSztDR4=
 github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
 github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw=
-github.com/djherbis/atime v1.1.0/go.mod h1:28OF6Y8s3NQWwacXc5eZTsEsiMzp7LF8MbXE+XJPdBE=
-github.com/docker/docker v20.10.21+incompatible h1:UTLdBmHk3bEY+w8qeO5KttOhy6OmXWsl/FEet9Uswog=
-github.com/docker/docker v20.10.21+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
+github.com/docker/docker v23.0.6+incompatible h1:aBD4np894vatVX99UTx/GyOUOK4uEcROwA3+bQhEcoU=
+github.com/docker/docker v23.0.6+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
 github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
-github.com/eknkc/amber v0.0.0-20171010120322-cdade1c07385 h1:clC1lXBpe2kTj2VHdaIu9ajZQe4kcEY9j0NsnDDBZ3o=
 github.com/eknkc/amber v0.0.0-20171010120322-cdade1c07385/go.mod h1:0vRUJqYpeSZifjYj7uP3BG/gKcuzL9xWVV/Y+cK33KM=
 github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
 github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
 github.com/envoyproxy/go-control-plane v0.9.9-0.20210217033140-668b12f5399d/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk=
 github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
 github.com/etcd-io/bbolt v1.3.3/go.mod h1:ZF2nL25h33cCyBtcyWeZ2/I3HQOfTP+0PIEvHjkjCrw=
-github.com/ethereum/c-kzg-4844 v0.2.0 h1:+cUvymlnoDDQgMInp25Bo3OmLajmmY8mLJ/tLjqd77Q=
-github.com/ethereum/c-kzg-4844 v0.2.0/go.mod h1:WI2Nd82DMZAAZI1wV2neKGost9EKjvbpQR9OqE5Qqa8=
-github.com/ethereum/go-ethereum v1.12.0 h1:bdnhLPtqETd4m3mS8BGMNvBTf36bO5bx/hxE2zljOa0=
-github.com/ethereum/go-ethereum v1.12.0/go.mod h1:/oo2X/dZLJjf2mJ6YT9wcWxa4nNJDBKDBU6sFIpx1Gs=
+github.com/ethereum/c-kzg-4844 v0.3.1 h1:sR65+68+WdnMKxseNWxSJuAv2tsUrihTpVBTfM/U5Zg=
+github.com/ethereum/c-kzg-4844 v0.3.1/go.mod h1:VewdlzQmpT5QSrVhbBuGoCdFJkpaJlO1aQputP83wc0=
+github.com/ethereum/go-ethereum v1.12.2 h1:eGHJ4ij7oyVqUQn48LBz3B7pvQ8sV0wGJiIE6gDq/6Y=
+github.com/ethereum/go-ethereum v1.12.2/go.mod h1:1cRAEV+rp/xX0zraSCBnu9Py3HQ+geRMj3HdR+k0wfI=
 github.com/fasthttp-contrib/websocket v0.0.0-20160511215533-1f3b11f56072/go.mod h1:duJ4Jxv5lDcvg4QuQr0oowTf7dz4/CR8NtyCooz9HL8=
-github.com/fatih/structs v1.1.0 h1:Q7juDM0QtcnhCpeyLGQKyg4TOIghuNXrkL32pHAUMxo=
 github.com/fatih/structs v1.1.0/go.mod h1:9NiDSp5zOcgEDl+j00MP/WkGVPOlPRLejGD8Ga6PJ7M=
 github.com/fjl/memsize v0.0.0-20190710130421-bcb5799ab5e5 h1:FtmdgXiUlNeRsoNMFlKLDt+S+6hbjVMEW6RGQ7aUf7c=
 github.com/fjl/memsize v0.0.0-20190710130421-bcb5799ab5e5/go.mod h1:VvhXpOYNQvB+uIk2RvXzuaQtkQJzzIx6lSBe1xv7hi0=
-github.com/flosch/pongo2/v4 v4.0.2 h1:gv+5Pe3vaSVmiJvh/BZa82b7/00YUGm0PIyVVLop0Hw=
-github.com/flosch/pongo2/v4 v4.0.2/go.mod h1:B5ObFANs/36VwxxlgKpdchIJHMvHB562PW+BWPhwZD8=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
 github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
-github.com/fsnotify/fsnotify v1.5.4/go.mod h1:OVB6XrOHzAwXMpEM7uPOzcehqUV2UqJxmVXmkdnm1bU=
 github.com/fsnotify/fsnotify v1.6.0 h1:n+5WquG0fcWoWp6xPWfHdbskMCQaFnG6PfBrh1Ky4HY=
 github.com/fsnotify/fsnotify v1.6.0/go.mod h1:sl3t1tCWJFWoRz9R8WJCbQihKKwmorjAbSClcnxKAGw=
+github.com/gabriel-vasile/mimetype v1.4.2 h1:w5qFW6JKBz9Y393Y4q372O9A7cUSequkh1Q7OhCmWKU=
+github.com/gabriel-vasile/mimetype v1.4.2/go.mod h1:zApsH/mKG4w07erKIaJPFiX0Tsq9BFQgN3qGY5GnNgA=
 github.com/gavv/httpexpect v2.0.0+incompatible/go.mod h1:x+9tiU1YnrOvnB725RkpoLv1M62hOWzwo5OXotisrKc=
 github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff h1:tY80oXqGNY4FhTFhk+o9oFHGINQ/+vhlm8HFzi6znCI=
 github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff/go.mod h1:x7DCsMOv1taUwEWCzT4cmDeAkigA5/QCwUodaVOe8Ww=
@@ -132,8 +117,15 @@ github.com/getsentry/sentry-go v0.12.0/go.mod h1:NSap0JBYWzHND8oMbyi0+XZhUalc1TB
 github.com/getsentry/sentry-go v0.18.0 h1:MtBW5H9QgdcJabtZcuJG80BMOwaBpkRDZkxRkNC1sN0=
 github.com/getsentry/sentry-go v0.18.0/go.mod h1:Kgon4Mby+FJ7ZWHFUAZgVaIa8sxHtnRJRLTXZr51aKQ=
 github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
+github.com/gin-contrib/cors v1.4.0 h1:oJ6gwtUl3lqV0WEIwM/LxPF1QZ5qe2lGWdY2+bz7y0g=
+github.com/gin-contrib/cors v1.4.0/go.mod h1:bs9pNM0x/UsmHPBWT2xZz9ROh8xYjYkiURUfmBoMlcs=
 github.com/gin-contrib/sse v0.0.0-20190301062529-5545eab6dad3/go.mod h1:VJ0WA2NBN22VlZ2dKZQPAPnyWw5XTlK1KymzLKsr59s=
+github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE=
+github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI=
 github.com/gin-gonic/gin v1.4.0/go.mod h1:OW2EZn3DO8Ln9oIKOvM++LBO+5UPHJJDH72/q/3rZdM=
+github.com/gin-gonic/gin v1.8.1/go.mod h1:ji8BvRH1azfM+SYow9zQ6SZMvR8qOMZHmsCuWR9tTTk=
+github.com/gin-gonic/gin v1.9.1 h1:4idEAncQnU5cB7BeOkPtxjfCSye0AAm1R0RVIqJ+Jmg=
+github.com/gin-gonic/gin v1.9.1/go.mod h1:hPrL7YrpYKXt5YId3A/Tnip5kqbEAP+KLuI3SUcPTeU=
 github.com/go-check/check v0.0.0-20180628173108-788fd7840127/go.mod h1:9ES+weclKsC9YodN5RgxqK/VD9HM9JsCSh7rNhMZE98=
 github.com/go-chi/chi/v5 v5.0.0/go.mod h1:BBug9lr0cqtdAhsu6R4AAdvufI0/XBzAQSsUqJpoZOs=
 github.com/go-errors/errors v1.0.1/go.mod h1:f4zRHt4oKfwPJE5k8C9vpYG+aDHdBFUsgrm6/TyX73Q=
@@ -143,21 +135,26 @@ 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-openapi/jsonpointer v0.19.5/go.mod h1:Pl9vOtqEWErmShwVjC8pYs9cog34VGT37dQOVbmoatg=
 github.com/go-openapi/swag v0.19.5/go.mod h1:POnQmlKehdgb5mhVOsnJFsivZCEZ/vjK9gh66Z9tfKk=
-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-playground/assert/v2 v2.0.1/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
+github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=
+github.com/go-playground/locales v0.14.0/go.mod h1:sawfccIbzZTqEDETgFXqTho0QybSa7l++s0DH+LDiLs=
+github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA=
+github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY=
+github.com/go-playground/universal-translator v0.18.0/go.mod h1:UvRDBj+xPUEGrFYl+lu/H90nyDXpg0fqeB/AQUGNTVA=
+github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY=
+github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
+github.com/go-playground/validator/v10 v10.10.0/go.mod h1:74x4gJWsvQexRdW8Pn3dXSGrTK4nAUsbPlLADvpJkos=
+github.com/go-playground/validator/v10 v10.14.1 h1:9c50NUPC30zyuKprjL3vNZ0m5oG+jU0zvx4AqHGnv4k=
+github.com/go-playground/validator/v10 v10.14.1/go.mod h1:9iXMNT7sEkjXb0I+enO7QXmzG6QCsPWY4zveKFVRSyU=
 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/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0/go.mod h1:fyg7847qk6SyHyPtNmDHnmrv/HOrqktSC+C9fM+CJOE=
 github.com/gobwas/httphead v0.0.0-20180130184737-2c6c146eadee/go.mod h1:L0fX3K22YWvt/FAX9NnzrNzcI4wNYi9Yku4O0LKYflo=
-github.com/gobwas/httphead v0.1.0 h1:exrUm0f4YX0L7EBwZHuCF4GDp8aJfVeBrlLQrs6NqWU=
-github.com/gobwas/httphead v0.1.0/go.mod h1:O/RXo79gxV8G+RqlR/otEwx4Q36zl9rqC5u12GKvMCM=
 github.com/gobwas/pool v0.2.0/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6WezmKEw=
-github.com/gobwas/pool v0.2.1 h1:xfeeEhW7pwmX8nuLVlqbzVc7udMDrwetjEv+TZIz1og=
-github.com/gobwas/pool v0.2.1/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6WezmKEw=
 github.com/gobwas/ws v1.0.2/go.mod h1:szmBTxLgaFppYjEmNtny/v3w89xOydFnnZMcgRRu/EM=
-github.com/gobwas/ws v1.1.0 h1:7RFti/xnNkMJnrK7D1yQ/iCIB5OrrY/54/H930kIbHA=
-github.com/gobwas/ws v1.1.0/go.mod h1:nzvNcVha5eUziGrbxFCo6qFIojQHjJV5cLYIbezhfL0=
+github.com/goccy/go-json v0.9.7/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
+github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU=
+github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
 github.com/gofrs/flock v0.8.1 h1:+gYjHKf32LDeiEEFhQaotPbLuUXjY5ZqxKgXy7n59aw=
 github.com/gofrs/flock v0.8.1/go.mod h1:F1TvTiK9OcQqauNUHlbJvyl9Qa1QvF/gOUDKA14jxHU=
 github.com/gogo/googleapis v0.0.0-20180223154316-0cd9801be74a/go.mod h1:gf4bu3Q80BeJ6H1S1vYPm8/ELATdvryBaNFGgqEef3s=
@@ -199,15 +196,12 @@ github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/
 github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
 github.com/google/go-querystring v1.0.0/go.mod h1:odCYkC5MyYFN7vkCjXpyrEuKhc/BUO6wN/zVPAxq5ck=
-github.com/google/go-querystring v1.1.0 h1:AnCroh3fv4ZBgVIf1Iwtovgjaw/GiKJo8M8yD/fhyJ8=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
 github.com/google/subcommands v1.2.0/go.mod h1:ZjhPrFU+Olkh9WazFPsl27BQ4UPiG37m3yTrtFlrHVk=
 github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 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/gorilla/css v1.0.0 h1:BQqNyPTi50JCFMTw/b67hByjMVXZRwGha6wxVGkeihY=
-github.com/gorilla/css v1.0.0/go.mod h1:Dn721qIggHpt4+EFCcTLTU/vk5ySda2ReITrtgBl60c=
 github.com/gorilla/mux v1.8.0/go.mod h1:DVbg23sWSpFRCP0SfiEN6jmj59UnW/n46BH5rLB71So=
 github.com/gorilla/websocket v1.4.1/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/gorilla/websocket v1.5.0 h1:PPwGk2jz7EePpoHN/+ClbZu8SPxiqlu12wZP/3sWmnc=
@@ -218,16 +212,17 @@ github.com/hashicorp/go-bexpr v0.1.10 h1:9kuI5PFotCboP3dkDYFr/wi0gg0QVbSNz5oFRpx
 github.com/hashicorp/go-bexpr v0.1.10/go.mod h1:oxlubA2vC/gFVfX1A6JGp7ls7uCDlfJn732ehYYg+g0=
 github.com/hashicorp/go-version v1.2.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=
 github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
+github.com/holiman/billy v0.0.0-20230718173358-1c7e68d277a7 h1:3JQNjnMRil1yD0IfZKHF9GxxWKDJGj8I0IqOUol//sw=
+github.com/holiman/billy v0.0.0-20230718173358-1c7e68d277a7/go.mod h1:5GuXa7vkL8u9FkFuWdVvfR5ix8hRB7DbOAaYULamFpc=
 github.com/holiman/bloomfilter/v2 v2.0.3 h1:73e0e/V0tCydx14a0SCYS/EWCxgwLZ18CZcZKVu0fao=
 github.com/holiman/bloomfilter/v2 v2.0.3/go.mod h1:zpoh+gs7qcpqrHr3dB55AMiJwo0iURXE7ZOP9L9hSkA=
-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/holiman/uint256 v1.2.3 h1:K8UWO1HUJpRMXBxbmaY1Y8IAMZC/RsKB+ArEnnK4l5o=
+github.com/holiman/uint256 v1.2.3/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/hydrogen18/memlistener v0.0.0-20200120041712-dcc25e7acd91/go.mod h1:qEIFzExnS6016fRpRfxrExeVn2gbClQA99gQhnIcdhE=
-github.com/imkira/go-interpol v1.1.0 h1:KIiKr0VSG2CUW1hl1jpiyuzuJeKUUpC8iM1AIE7N1Vk=
 github.com/imkira/go-interpol v1.1.0/go.mod h1:z0h2/2T3XF8kyEPpRgJ3kmNv+C43p+I/CoI+jC3w2iA=
 github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
 github.com/influxdata/influxdb-client-go/v2 v2.4.0 h1:HGBfZYStlx3Kqvsv1h2pJixbCl/jhnFtxpKFAv9Tu5k=
@@ -238,48 +233,38 @@ github.com/influxdata/line-protocol v0.0.0-20200327222509-2487e7298839/go.mod h1
 github.com/influxdata/line-protocol v0.0.0-20210311194329-9aa0e372d097 h1:vilfsDSy7TDxedi9gyBkMvAirat/oRcL0lFdJBf6tdM=
 github.com/influxdata/line-protocol v0.0.0-20210311194329-9aa0e372d097/go.mod h1:xaLFMmpvUxqXtVkUJfg9QmT88cDaCJ3ZKgdZ78oO8Qo=
 github.com/iris-contrib/blackfriday v2.0.0+incompatible/go.mod h1:UzZ2bDEoaSGPbkg6SAB4att1aAwTmVIx/5gCVqeyUdI=
-github.com/iris-contrib/go.uuid v2.0.0+incompatible h1:XZubAYg61/JwnJNbZilGjf3b3pB80+OQg2qf6c8BfWE=
 github.com/iris-contrib/go.uuid v2.0.0+incompatible/go.mod h1:iz2lgM/1UnEf1kP0L/+fafWORmlnuysV2EMP8MW+qe0=
-github.com/iris-contrib/httpexpect/v2 v2.12.1 h1:3cTZSyBBen/kfjCtgNFoUKi1u0FVXNaAjyRJOo6AVS4=
 github.com/iris-contrib/jade v1.1.3/go.mod h1:H/geBymxJhShH5kecoiOCSssPX7QWYH7UaeZTSWddIk=
-github.com/iris-contrib/middleware/cors v0.0.0-20230531125531-980d3a09a458 h1:V60rHQJc6DieKV1BqHIGclraPdO4kinuFAZIrPGHN7s=
-github.com/iris-contrib/middleware/cors v0.0.0-20230531125531-980d3a09a458/go.mod h1:7eVziAp1yUwFB/ZMg71n84VWQH+7wukvxcHuF2e7cbg=
 github.com/iris-contrib/pongo2 v0.0.1/go.mod h1:Ssh+00+3GAZqSQb30AvBRNxBx7rf0GqwkjqxNd0u65g=
 github.com/iris-contrib/schema v0.0.1/go.mod h1:urYA3uvUNG1TIIjOSCzHr9/LmbQo8LrOcOqfqxa4hXw=
-github.com/iris-contrib/schema v0.0.6 h1:CPSBLyx2e91H2yJzPuhGuifVRnZBBJ3pCOMbOvPZaTw=
-github.com/iris-contrib/schema v0.0.6/go.mod h1:iYszG0IOsuIsfzjymw1kMzTL8YQcCWlm65f3wX8J5iA=
+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/go.mod h1:t3JDKnCBlYIc0ewLF0Q7B8MXmoIaBOZj/ic7iHozM/8=
+github.com/jackc/pgx/v5 v5.3.1 h1:Fcr8QJ1ZeLi5zsPZqQeUZhNhxfkkKBOgJuYkJHoBOtU=
+github.com/jackc/pgx/v5 v5.3.1/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/jmoiron/sqlx v1.3.5 h1:vFFPA71p1o5gAeqtEAwLU4dnX2napprKtHr7PYIcN3g=
-github.com/jmoiron/sqlx v1.3.5/go.mod h1:nRVWtLre0KfCLJvgxzCsLVMogSvQ1zNJtpYr2Ccp0mQ=
-github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8HmY=
-github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y=
+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/jrick/logrotate v1.0.0/go.mod h1:LNinyqDIJnpAur+b8yyulnQw/wDuN1+BYKlTRt3OuAQ=
 github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
 github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
+github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
+github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
 github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
 github.com/julienschmidt/httprouter v1.3.0 h1:U0609e9tgbseu3rBINet9P48AI/D3oJs4dN7jwJOQ1U=
 github.com/k0kubun/colorstring v0.0.0-20150214042306-9440f1994b88/go.mod h1:3w7q1U84EfirKl04SVQ/s7nPm1ZPhiXd34z40TNz36k=
-github.com/kataras/blocks v0.0.7 h1:cF3RDY/vxnSRezc7vLFlQFTYXG/yAr1o7WImJuZbzC4=
-github.com/kataras/blocks v0.0.7/go.mod h1:UJIU97CluDo0f+zEjbnbkeMRlvYORtmc1304EeyXf4I=
 github.com/kataras/golog v0.0.10/go.mod h1:yJ8YKCmyL+nWjERB90Qwn+bdyBZsaQwU3bTVFgkFIp8=
-github.com/kataras/golog v0.1.8 h1:isP8th4PJH2SrbkciKnylaND9xoTtfxv++NB+DF0l9g=
-github.com/kataras/golog v0.1.8/go.mod h1:rGPAin4hYROfk1qT9wZP6VY2rsb4zzc37QpdPjdkqVw=
 github.com/kataras/iris/v12 v12.1.8/go.mod h1:LMYy4VlP67TQ3Zgriz8RE2h2kMZV2SgMYbq3UhfoFmE=
-github.com/kataras/iris/v12 v12.2.0 h1:WzDY5nGuW/LgVaFS5BtTkW3crdSKJ/FEgWnxPnIVVLI=
-github.com/kataras/iris/v12 v12.2.0/go.mod h1:BLzBpEunc41GbE68OUaQlqX4jzi791mx5HU04uPb90Y=
 github.com/kataras/neffos v0.0.14/go.mod h1:8lqADm8PnbeFfL7CLXh1WHw53dG27MC3pgi2R1rmoTE=
-github.com/kataras/neffos v0.0.21 h1:UwN/F44jlqdtgFI29y3VhA7IlJ4JbK3UjCbTDg1pYoo=
-github.com/kataras/neffos v0.0.21/go.mod h1:FeGka8lu8cjD2H+0OpBvW8c6xXawy3fj5VX6xcIJ1Fg=
 github.com/kataras/pio v0.0.2/go.mod h1:hAoW0t9UmXi4R5Oyq5Z4irTbaTsOemSrDGUtaTl7Dro=
-github.com/kataras/pio v0.0.11 h1:kqreJ5KOEXGMwHAWHDwIl+mjfNCPhAwZPa8gK7MKlyw=
-github.com/kataras/pio v0.0.11/go.mod h1:38hH6SWH6m4DKSYmRhlrCJ5WItwWgCVrTNU62XZyUvI=
 github.com/kataras/sitemap v0.0.5/go.mod h1:KY2eugMKiPwsJgx7+U103YZehfvNGOXURubcGyk0Bz8=
-github.com/kataras/sitemap v0.0.6 h1:w71CRMMKYMJh6LR2wTgnk5hSgjVNB9KL60n5e2KHvLY=
-github.com/kataras/sitemap v0.0.6/go.mod h1:dW4dOCNs896OR1HmG+dMLdT7JjDk7mYBzoIRwuj5jA4=
-github.com/kataras/tunnel v0.0.4 h1:sCAqWuJV7nPzGrlb0os3j49lk2JhILT0rID38NHNLpA=
-github.com/kataras/tunnel v0.0.4/go.mod h1:9FkU4LaeifdMWqZu7o20ojmW4B7hdhv2CMLwfnHGpYw=
 github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 h1:Z9n2FFNUXsshfwJMBgNA0RU6/i7WVaAegv3PtuIHPMs=
 github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=
 github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
@@ -289,7 +274,11 @@ github.com/klauspost/compress v1.9.7/go.mod h1:RyIbtBH6LamlWaDj8nUwkbUhJ87Yi3uG0
 github.com/klauspost/compress v1.16.0 h1:iULayQNOReoYUe+1qtKOqw9CwJv3aNQu8ivo7lw1HU4=
 github.com/klauspost/compress v1.16.0/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE=
 github.com/klauspost/cpuid v1.2.1/go.mod h1:Pj4uuM528wm8OyEC2QMXAi2YiTZ96dNQPGgoMS4s3ek=
+github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
+github.com/klauspost/cpuid/v2 v2.2.5 h1:0E5MSMDEoAulmXNFquVs//DdoomxaoTY1kUhbc/qbZg=
+github.com/klauspost/cpuid/v2 v2.2.5/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws=
 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=
@@ -302,18 +291,13 @@ github.com/labstack/echo/v4 v4.2.1/go.mod h1:AA49e0DZ8kk5jTOOCKNuPR6oTnBS0dYiM4F
 github.com/labstack/echo/v4 v4.5.0/go.mod h1:czIriw4a0C1dFun+ObrXp7ok03xON0N1awStJ6ArI7Y=
 github.com/labstack/gommon v0.3.0/go.mod h1:MULnywXg0yavhxWKc+lOruYdAhDwPK9wf0OL7NoOu+k=
 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/leodido/go-urn v1.2.1/go.mod h1:zt4jvISO2HfUBqxjfIshjdMTYS56ZS/qv49ictyFfxY=
+github.com/leodido/go-urn v1.2.4 h1:XlAE/cm/ms7TE/VMVoduSpNBoyc2dOxHs5MZSwAN63Q=
+github.com/leodido/go-urn v1.2.4/go.mod h1:7ZrI8mTSeBSHl/UaRyKQW1qZeMgak41ANeCNaVckg+4=
 github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
-github.com/mailgun/raymond/v2 v2.0.48 h1:5dmlB680ZkFG2RN/0lvTAghrSxIESeu9/2aeDqACtjw=
-github.com/mailgun/raymond/v2 v2.0.48/go.mod h1:lsgvL50kgt1ylcFJYZiULi5fjPBkkhNfj4KA0W54Z18=
 github.com/mailru/easyjson v0.0.0-20190614124828-94de47d64c63/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
 github.com/mailru/easyjson v0.0.0-20190626092158-b2ccc519800e/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
-github.com/mailru/easyjson v0.7.7 h1:UGYAvKxe3sBsEDzO8ZeWOSlIQfWFlxbzLZe7hwFURr0=
-github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc=
 github.com/matryer/moq v0.0.0-20190312154309-6cfb0558e1bd/go.mod h1:9ELz6aaclSIGnZBoaSLZ3NAl1VTufbOrXBPvtcy6WiQ=
-github.com/matryer/try v0.0.0-20161228173917-9ac251b645a2/go.mod h1:0KeJpeMD6o+O4hW7qJOT7vyQPKrWmj26uf5wMc/IiIs=
 github.com/mattn/go-colorable v0.1.2/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
 github.com/mattn/go-colorable v0.1.7/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
 github.com/mattn/go-colorable v0.1.8/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
@@ -332,21 +316,12 @@ github.com/mattn/go-runewidth v0.0.3/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzp
 github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
 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/mattn/goveralls v0.0.2/go.mod h1:8d1ZMHsd7fW6IRPKQh46F2WRpyib5/X4FOpevwGNQEw=
 github.com/matttproud/golang_protobuf_extensions v1.0.4 h1:mmDVorXM7PCGKw94cs5zkfA9PSy5pEvNWRP0ET0TIVo=
 github.com/matttproud/golang_protobuf_extensions v1.0.4/go.mod h1:BSXmuO+STAnVfrANrmjBb36TMTDstsz7MSK+HVaYKv4=
 github.com/mediocregopher/radix/v3 v3.4.2/go.mod h1:8FL3F6UQRXHXIBSPUs5h0RybMF8i4n7wVopoX3x7Bv8=
-github.com/mediocregopher/radix/v3 v3.8.1 h1:rOkHflVuulFKlwsLY01/M2cM2tWCjDoETcMqKbAWu1M=
-github.com/mediocregopher/radix/v3 v3.8.1/go.mod h1:8FL3F6UQRXHXIBSPUs5h0RybMF8i4n7wVopoX3x7Bv8=
 github.com/microcosm-cc/bluemonday v1.0.2/go.mod h1:iVP4YcDBq+n/5fb23BhYFvIMq/leAFZyRl6bYmGDlGc=
-github.com/microcosm-cc/bluemonday v1.0.23 h1:SMZe2IGa0NuHvnVNAZ+6B38gsTbi5e4sViiWJyDDqFY=
-github.com/microcosm-cc/bluemonday v1.0.23/go.mod h1:mN70sk7UkkF8TUr2IGBpNN0jAgStuPzlK76QuruE/z4=
-github.com/minio/highwayhash v1.0.2 h1:Aak5U0nElisjDCfPSG79Tgzkn2gl66NxOMspRrKnA/g=
 github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
-github.com/mitchellh/go-wordwrap v1.0.1 h1:TLuKupo69TCn6TQSyGxwI1EblZZEsQ0vMlAFQflz0v0=
 github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
 github.com/mitchellh/mapstructure v1.4.1/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
 github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY=
@@ -357,25 +332,17 @@ github.com/mmcloughlin/addchain v0.4.0 h1:SobOdjm2xLj1KkXN5/n0xTIWyZA2+s99UCY1iP
 github.com/mmcloughlin/addchain v0.4.0/go.mod h1:A86O+tHqZLMNO4w6ZZ4FlVQEadcoqkyU72HC5wJ4RlU=
 github.com/mmcloughlin/profile v0.1.1/go.mod h1:IhHD7q1ooxgwTgjxQYkACGA77oFTDdFVejUS1/tS/qU=
 github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
 github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
 github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
 github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
 github.com/moul/http2curl v1.0.0/go.mod h1:8UbvGypXm98wA/IqH45anm5Y2Z6ep6O31QGOAZ3H0fQ=
-github.com/nats-io/jwt v0.3.0 h1:xdnzwFETV++jNc4W1mw//qFyJGb2ABOombmZJQS4+Qo=
 github.com/nats-io/jwt v0.3.0/go.mod h1:fRYCDE99xlTsqUzISS1Bi75UBJ6ljOJQOAAu5VglpSg=
-github.com/nats-io/jwt/v2 v2.3.0 h1:z2mA1a7tIf5ShggOFlR1oBPgd6hGqcDYsISxZByUzdI=
-github.com/nats-io/nats-server/v2 v2.9.11 h1:4y5SwWvWI59V5mcqtuoqKq6L9NDUydOP3Ekwuwl8cZI=
 github.com/nats-io/nats.go v1.9.1/go.mod h1:ZjDU1L/7fJ09jvUSRVBR2e7+RnLiiIQyqyzEE/Zbp4w=
-github.com/nats-io/nats.go v1.23.0 h1:lR28r7IX44WjYgdiKz9GmUeW0uh/m33uD3yEjLZ2cOE=
-github.com/nats-io/nats.go v1.23.0/go.mod h1:ki/Scsa23edbh8IRZbCuNXR9TDcbvfaSijKtaqQgw+Q=
 github.com/nats-io/nkeys v0.1.0/go.mod h1:xpnFELMwJABBLVhffcfd1MZx6VsNRFpEugbxziKVo7w=
-github.com/nats-io/nkeys v0.3.0 h1:cgM5tL53EvYRU+2YLXIK0G2mJtK12Ft9oeooSZMA2G8=
-github.com/nats-io/nkeys v0.3.0/go.mod h1:gvUNGjVcM2IPr5rCsRsC6Wb3Hr2CQAm08dsxtV6A5y4=
-github.com/nats-io/nuid v1.0.1 h1:5iA8DT8V7q8WK2EScv2padNa/rTESc1KdnPw4TC2paw=
 github.com/nats-io/nuid v1.0.1/go.mod h1:19wcPz3Ph3q0Jbyiqsd0kePYG7A95tJPxeL+1OSON2c=
-github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno=
 github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A=
 github.com/nxadm/tail v1.4.8 h1:nPr65rt6Y5JFSKQO7qToXr7pePgD6Gwiw05lkbyAQTE=
 github.com/nxadm/tail v1.4.8/go.mod h1:+ncqLTQzXmGhMZNUePPaPqPvBxHAIsmXswZKocGu+AU=
@@ -396,6 +363,9 @@ github.com/onsi/gomega v1.27.1/go.mod h1:aHX5xOykVYzWOV4WqQy0sy8BQptgukenXpCXfad
 github.com/opentracing/opentracing-go v1.1.0 h1:pWlfV3Bxv7k65HYwkikxat0+s3pV4bsqf19k25Ur8rU=
 github.com/opentracing/opentracing-go v1.1.0/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o=
 github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic=
+github.com/pelletier/go-toml/v2 v2.0.1/go.mod h1:r9LEWfGN8R5k0VXJ+0BkIe7MYkRdwZOjgMj2KwnJFUo=
+github.com/pelletier/go-toml/v2 v2.0.8 h1:0ctb6s9mE31h0/lhu+J6OPmVeDxJn+kYnJc2jZR9tGQ=
+github.com/pelletier/go-toml/v2 v2.0.8/go.mod h1:vuYfssBdrU2XDZ9bYydBu6t+6a6PYNcZljzZR9VXg+4=
 github.com/peterh/liner v1.1.1-0.20190123174540-a2c9a5303de7 h1:oYW+YCJ1pachXTQmzR3rNLYGGz4g/UgFcjb28p/viDM=
 github.com/peterh/liner v1.1.1-0.20190123174540-a2c9a5303de7/go.mod h1:CRroGNssyjTd/qIG2FyxByd2S8JEAZXBl4qUrZf8GS0=
 github.com/pingcap/errors v0.11.4 h1:lFuQV/oaUMGcD2tqt+01ROSmJs75VG1ToEOkZIZ4nE4=
@@ -422,6 +392,7 @@ github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJ
 github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis=
 github.com/rivo/uniseg v0.4.4/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
+github.com/rogpeppe/go-internal v1.8.0/go.mod h1:WmiCO8CzOY8rg0OYDC4/i/2WRWAB6poM+XZ2dLUbcbE=
 github.com/rogpeppe/go-internal v1.8.1/go.mod h1:JeRgkft04UBgHMgCIwADu4Pn6Mtm5d4nPKWu0nJ5d+o=
 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=
@@ -432,18 +403,11 @@ github.com/russross/blackfriday v1.5.2/go.mod h1:JO/DiYxRf+HjHt06OyowR9PTA263kcR
 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/ryanuber/columnize v2.1.0+incompatible/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts=
-github.com/sanity-io/litter v1.5.5 h1:iE+sBxPBzoK6uaEP5Lt3fHNgpKcHXc/A2HGETy0uJQo=
-github.com/schollz/closestmatch v2.1.0+incompatible h1:Uel2GXEpJqOWBrlyI+oY9LTiyyjYS17cCYRqP13/SHk=
 github.com/schollz/closestmatch v2.1.0+incompatible/go.mod h1:RtP1ddjLong6gTkbtmuhtR2uUrrJOpYzYRvbcPAid+g=
 github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo=
-github.com/sergi/go-diff v1.2.0 h1:XU+rvMAioB0UC3q1MFrIQy4Vo5/4VsRDQQXHsEya6xQ=
-github.com/sergi/go-diff v1.2.0/go.mod h1:STckp+ISIX8hZLjrqAeVduY0gWCT9IjLuqbuNXdaHfM=
 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/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
-github.com/sirupsen/logrus v1.8.1/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0=
-github.com/sirupsen/logrus v1.9.0 h1:trlNQbNUG3OdDrDil03MCb1H2o9nJ1x4/5LYw7byDE0=
-github.com/sirupsen/logrus v1.9.0/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
 github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
 github.com/smartystreets/goconvey v1.6.4/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA=
 github.com/spf13/afero v1.1.2/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ=
@@ -451,76 +415,71 @@ github.com/spf13/cast v1.3.0/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkU
 github.com/spf13/cobra v0.0.5/go.mod h1:3K3wKZymM7VvHMDS9+Akkh4K60UwM26emMESw8tLCHU=
 github.com/spf13/jwalterweatherman v1.0.0/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo=
 github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
-github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/spf13/viper v1.3.2/go.mod h1:ZiWeW+zYFKm7srdB9IoDzzZXaJaI5eL9QjNiN/DMA2s=
 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.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
 github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
 github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 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/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
 github.com/stretchr/testify v1.8.3 h1:RP3t2pwF7cMEbC1dqtB6poj3niw/9gnV4Cjg5oW5gtY=
 github.com/stretchr/testify v1.8.3/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
-github.com/supranational/blst v0.3.11-0.20230406105308-e9dfc5ee724b h1:u49mjRnygnB34h8OKbnNJFVUtWSKIKb1KukdV8bILUM=
-github.com/supranational/blst v0.3.11-0.20230406105308-e9dfc5ee724b/go.mod h1:jZJtfjgudtNl4en1tzwPIV3KjUnQUvG3/j+w+fVonLw=
+github.com/supranational/blst v0.3.11 h1:LyU6FolezeWAhvQk0k6O/d49jqgO52MSDDfYgbeoEm4=
+github.com/supranational/blst v0.3.11/go.mod h1:jZJtfjgudtNl4en1tzwPIV3KjUnQUvG3/j+w+fVonLw=
 github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 h1:epCh84lMvA70Z7CTTCmYQn2CKbY8j86K7/FAIr141uY=
 github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7/go.mod h1:q4W45IWZaF22tdD+VEXcAWRA037jwmWEB5VWYORlTpc=
-github.com/tdewolff/minify/v2 v2.12.4 h1:kejsHQMM17n6/gwdw53qsi6lg0TGddZADVyQOz1KMdE=
-github.com/tdewolff/minify/v2 v2.12.4/go.mod h1:h+SRvSIX3kwgwTFOpSckvSxgax3uy8kZTSF1Ojrr3bk=
-github.com/tdewolff/parse/v2 v2.6.4 h1:KCkDvNUMof10e3QExio9OPZJT8SbdKojLBumw8YZycQ=
-github.com/tdewolff/parse/v2 v2.6.4/go.mod h1:woz0cgbLwFdtbjJu8PIKxhW05KplTFQkOdX78o+Jgrs=
-github.com/tdewolff/test v1.0.7 h1:8Vs0142DmPFW/bQeHRP3MV19m1gvndjUb1sn8yy74LM=
-github.com/tdewolff/test v1.0.7/go.mod h1:6DAvZliBAAnD7rhVgwaM7DE5/d9NMOAJ09SqYqeK4QE=
 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/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI=
+github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
 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/ugorji/go v1.1.4/go.mod h1:uQMGLiO92mf5W77hV/PUCpI3pbzQx3CRekS0kk+RGrc=
 github.com/ugorji/go v1.1.7/go.mod h1:kZn38zHttfInRq0xu/PH0az30d+z6vm202qpg1oXVMw=
+github.com/ugorji/go v1.2.7/go.mod h1:nF9osbDWLy6bDVv/Rtoh6QgnvNDpmCalQV5urGCCS6M=
 github.com/ugorji/go/codec v0.0.0-20181204163529-d75b2dcb6bc8/go.mod h1:VFNgLljTbGfSG7qAOspJ7OScBnGdDN/yBr0sguwnwf0=
 github.com/ugorji/go/codec v1.1.7/go.mod h1:Ax+UKWsSmolVDwsd+7N3ZtXu+yMGCf907BLYF3GoBXY=
+github.com/ugorji/go/codec v1.2.7/go.mod h1:WGN1fab3R1fzQlVQTkfxVtIBhWDRqOviHU95kRgeqEY=
+github.com/ugorji/go/codec v1.2.11 h1:BMaWp1Bb6fHwEtbplGBGJ498wD+LKlNSl25MjdZY4dU=
+github.com/ugorji/go/codec v1.2.11/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg=
 github.com/urfave/cli/v2 v2.25.7 h1:VAzn5oq403l5pHjc4OhD54+XGO9cdKVL/7lDjF+iKUs=
 github.com/urfave/cli/v2 v2.25.7/go.mod h1:8qnjx1vcq5s2/wpsqoZFndg2CE5tNFyrTvS6SinrnYQ=
 github.com/urfave/negroni v1.0.0/go.mod h1:Meg73S6kFm/4PpbYdq35yYWoCZ9mS/YSx+lKnmiohz4=
-github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
 github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
 github.com/valyala/fasthttp v1.6.0/go.mod h1:FstJa9V+Pj9vQ7OJie2qMHdwemEDaDiSdBnvPM1Su9w=
 github.com/valyala/fasttemplate v1.0.1/go.mod h1:UQGH1tvbgY+Nz5t2n7tXsz52dQxojPUpymEIMZ47gx8=
 github.com/valyala/fasttemplate v1.2.1/go.mod h1:KHLXt3tVN2HBp8eijSv/kGJopbvo7S+qRAEEKiv+SiQ=
 github.com/valyala/tcplisten v0.0.0-20161114210144-ceec8f93295a/go.mod h1:v3UYOV9WzVtRmSR+PDvWpU/qWl4Wa5LApYYX4ZtKbio=
-github.com/vmihailenco/msgpack/v5 v5.3.5 h1:5gO0H1iULLWGhs2H5tbAHIZTV8/cYafcFOr9znI5mJU=
-github.com/vmihailenco/msgpack/v5 v5.3.5/go.mod h1:7xyJ9e+0+9SaZT0Wt1RGleJXzli6Q/V5KbhBonMG9jc=
-github.com/vmihailenco/tagparser/v2 v2.0.0 h1:y09buUbR+b5aycVFQs/g70pqKVZNBmxwAhO7/IwNM9g=
-github.com/vmihailenco/tagparser/v2 v2.0.0/go.mod h1:Wri+At7QHww0WTrCBeu4J6bNtoV6mEfg5OIWRZA9qds=
 github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f/go.mod h1:N2zxlSyiKSe5eX1tZViRH5QA0qijqEDrYZiPEAiq3wU=
-github.com/xeipuuv/gojsonpointer v0.0.0-20190905194746-02993c407bfb h1:zGWFAtiMcyryUHoUjUJX0/lt1H2+i2Ka2n+D3DImSNo=
-github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415 h1:EzJWgHovont7NscjpAxXsDA8S8BMYve8Y5+7cuRE7R0=
 github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415/go.mod h1:GwrjFmJcFw6At/Gs6z4yjiIwzuJ1/+UwLxMQDVQXShQ=
-github.com/xeipuuv/gojsonschema v1.2.0 h1:LhYJRs+L4fBtjZUfuSZIKGeVu0QRy8e5Xi7D17UxZ74=
 github.com/xeipuuv/gojsonschema v1.2.0/go.mod h1:anYRn/JVcOK2ZgGU+IjEV4nwlhoK5sQluxsYJ78Id3Y=
 github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q=
 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/yalp/jsonpath v0.0.0-20180802001716-5cc68e5049a0 h1:6fRhSjgLCkTD3JnJxvaJ4Sj+TYblw757bqYgZaOq5ZY=
 github.com/yalp/jsonpath v0.0.0-20180802001716-5cc68e5049a0/go.mod h1:/LWChgwKmvncFJFHJ7Gvn9wZArjbV5/FppcK2fKk/tI=
-github.com/yosssi/ace v0.0.5 h1:tUkIP/BLdKqrlrPwcmH0shwEEhTRHoGnc1wFIWmaBUA=
-github.com/yosssi/ace v0.0.5/go.mod h1:ALfIzm2vT7t5ZE7uoIZqF3TQ7SAOyupFZnkrF5id+K0=
-github.com/yudai/gojsondiff v1.0.0 h1:27cbfqXLVEJ1o8I6v3y9lg8Ydm53EKqHXAOMxEGlCOA=
 github.com/yudai/gojsondiff v1.0.0/go.mod h1:AY32+k2cwILAkW1fbgxQ5mUmMiZFgLIV+FBNExI05xg=
-github.com/yudai/golcs v0.0.0-20170316035057-ecda9a501e82 h1:BHyfKlQyqbsFN5p3IfnEUduWvb9is428/nNb5L3U01M=
 github.com/yudai/golcs v0.0.0-20170316035057-ecda9a501e82/go.mod h1:lgjkn3NuSvDfVJdfcVVdX+jpBxNmX4rDAzaS45IcYoM=
 github.com/yudai/pp v2.0.1+incompatible/go.mod h1:PuxR/8QJ7cyCkFp/aUDS+JY727OFEZkTdatxwunjIkc=
 github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
-github.com/yuin/goldmark v1.4.1/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
+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/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
+golang.org/x/arch v0.4.0 h1:A8WCeEWhLwPBKNbFi5Wv5UTCBx5zzubnXDlMOFAzFMc=
+golang.org/x/arch v0.4.0/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
 golang.org/x/crypto v0.0.0-20170930174604-9419663f5a44/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20181203042331-505ab145d0a9/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
@@ -530,14 +489,15 @@ golang.org/x/crypto v0.0.0-20191227163750-53104e6ec876/go.mod h1:LzIPMQfyMNhhGPh
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20200820211705-5c72a883971a/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20201221181555-eec23a3978ad/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I=
-golang.org/x/crypto v0.0.0-20210314154223-e6e6c4f2bb5b/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4=
 golang.org/x/crypto v0.0.0-20210322153248-0c34fe9e7dc2/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4=
+golang.org/x/crypto v0.0.0-20210711020723-a769d52b0f97/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
-golang.org/x/crypto v0.11.0 h1:6Ewdq3tDic1mg5xRO4milcWCfMVQhI4NkqWWvqejpuA=
-golang.org/x/crypto v0.11.0/go.mod h1:xgJhtzW8F9jGdVFWZESrid1U1bjeNy4zgy5cRr/CIio=
+golang.org/x/crypto v0.6.0/go.mod h1:OFC/31mSvZgRz0V1QTNCzfAI1aIRzbiufJtkMIlEp58=
+golang.org/x/crypto v0.12.0 h1:tFM/ta59kqch6LlvYnPa0yx5a83cL2nHflFhYKvv9Yk=
+golang.org/x/crypto v0.12.0/go.mod h1:NF0Gs7EO5K4qLn+Ylc+fih8BSTeIjAP05siRnAh98yw=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
-golang.org/x/exp v0.0.0-20230206171751-46f607a40771 h1:xP7rWLUr1e1n2xkK5YB4LI0hPEy3LJC6Wk+D4pGlOJg=
-golang.org/x/exp v0.0.0-20230206171751-46f607a40771/go.mod h1:CxIveKay+FTh1D0yPZemJVgC/95VzuuOLq5Qi4xnoYc=
+golang.org/x/exp v0.0.0-20230810033253-352e893a4cad h1:g0bG7Z4uG+OgH2QDODnjp6ggkk1bJDsINcuWmJN1iJU=
+golang.org/x/exp v0.0.0-20230810033253-352e893a4cad/go.mod h1:FXUEEKJgO7OQYeo8N01OfiKP8RXMtf6e8aTskBGqWdc=
 golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
 golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
 golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
@@ -546,7 +506,7 @@ golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzB
 golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.5.1/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro=
+golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
 golang.org/x/mod v0.12.0 h1:rmsUpXtvNzj340zd98LZ4KntptpfRHwpFOHG188oHXc=
 golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
@@ -569,9 +529,10 @@ golang.org/x/net v0.0.0-20210119194325-5f4716e94777/go.mod h1:m0MpNAwzfU5UDzcl9v
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
 golang.org/x/net v0.0.0-20211008194852-3b03d305991f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/net v0.0.0-20211015210444-4f30a5c0130f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/net v0.12.0 h1:cfawfvKITfUsFCeJIHJrbSxpeu/E81khclypR0GVT50=
-golang.org/x/net v0.12.0/go.mod h1:zEVYFnQC7m/vmpQFELhcD1EWkZlX69l4oqgmer6hfKA=
+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/net v0.14.0 h1:BONx9s002vGdD9umnlX1Po8vOZmrgH34qlHcD1MfK14=
+golang.org/x/net v0.14.0/go.mod h1:PpSgVXXLK0OxS0F31C1/tv6XNguvCrnXIDrFMspZIUI=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
@@ -581,6 +542,8 @@ golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJ
 golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/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/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.3.0 h1:ftCYgMx6zT/asHUrPw8BLLscYtGznsLAnjq5RH9P66E=
 golang.org/x/sync v0.3.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y=
 golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
@@ -604,7 +567,6 @@ golang.org/x/sys v0.0.0-20200814200057-3d37ad5750ed/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20200826173525-f9321e4c35a6/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20201207223542-d4d67f95c62d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210112080510-489259a85091/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210324051608-47abb6519492/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -614,28 +576,32 @@ golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210806184541-e5e7981a1069/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20211007075335-d3039528d8ac/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20211019181941-9d821ace8654/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220209214540-3681064d5158/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220412211240-33da011f77ad/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/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.0.0-20220908164124-27713097b956/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.10.0 h1:SqMFp9UcQJZa+pmYuAKjd9xq1f0j5rLcDIk0mj4qAsA=
-golang.org/x/sys v0.10.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.11.0 h1:eG7RXZHdqOJ1i+0lgLgCpSXAp6M3LYlAo6osgSi0xOM=
+golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
 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.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
-golang.org/x/text v0.11.0 h1:LAntKIrcmeSKERyiOh0XMV39LXS8IE9UL2yP7+f5ij4=
-golang.org/x/text v0.11.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
+golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
+golang.org/x/text v0.12.0 h1:k+n5B8goJNdU7hSvEtMUz3d1Q6D/XW4COJSJR6fN0mc=
+golang.org/x/text v0.12.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
 golang.org/x/time v0.0.0-20201208040808-7e3f01d25324/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20210220033141-f8bda1e9f3ba/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.3.0 h1:rg5rLMjNzMS1RkNLzCG38eapWhnYLFYXDXj2gOlr8j4=
@@ -655,15 +621,13 @@ golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roY
 golang.org/x/tools v0.0.0-20201224043029-2b0845dc783e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
 golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
 golang.org/x/tools v0.1.3/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
-golang.org/x/tools v0.1.9/go.mod h1:nABZi5QlRsZVlzPpHl034qft6wpY4eDcsTt5AaioBiU=
+golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
 golang.org/x/tools v0.11.0 h1:EMCa6U9S2LtZXLAMoWiR/R8dAQFRqbAitmbJ2UKhoi8=
 golang.org/x/tools v0.11.0/go.mod h1:anzJrxPjNtfgiYQYirP2CPGzGLxrH2u2QBhn6Bf3qY8=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20220517211312-f3a8303e98df h1:5Pf6pFKu98ODmgnpvkJ3kFUOQGGLIzLIkbzUHp47618=
-golang.org/x/xerrors v0.0.0-20220517211312-f3a8303e98df/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8=
 google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
 google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
 google.golang.org/genproto v0.0.0-20180518175338-11a468237815/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
@@ -688,20 +652,19 @@ google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpAD
 google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
 google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
 google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
+google.golang.org/protobuf v1.28.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
 google.golang.org/protobuf v1.31.0 h1:g0LDEJHgrBl9N9r17Ru3sqWhkIx2NB67okBHPwC7hs8=
 google.golang.org/protobuf v1.31.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
 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-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20200902074654-038fdea0a05b/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/go-playground/assert.v1 v1.2.1/go.mod h1:9RXL0bg/zibRAgZUYszZSwO/z8Y/a8bDuhia5mkpMnE=
 gopkg.in/go-playground/validator.v8 v8.18.2/go.mod h1:RX2a/7Ha8BgOhfk7j780h4/u/RRjR0eouCJSH80/M2Y=
 gopkg.in/ini.v1 v1.51.1/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
-gopkg.in/ini.v1 v1.67.0 h1:Dgnx+6+nfE+IfzjUEISNeydPJh9AXNNsWbGP9KzCsOA=
-gopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
 gopkg.in/mgo.v2 v2.0.0-20180705113604-9856a29383ce/go.mod h1:yeKp02qBN3iKW1OzL3MGk2IdtZzaj7SFntXj72NppTA=
 gopkg.in/natefinch/lumberjack.v2 v2.0.0 h1:1Lc07Kr7qY4U2YPouBjpCLxpiyxIVoxqXgkXLknAOE8=
 gopkg.in/natefinch/lumberjack.v2 v2.0.0/go.mod h1:l0ndWWf7gzL7RNwBG7wST/UCcT4T24xpD6X8LsfU/+k=
@@ -720,6 +683,11 @@ gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C
 gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/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.2 h1:gs1o6Vsa+oVKG/a9ElL3XgyGfghFfkKA2SInQaCyMho=
+gorm.io/gorm v1.25.2/go.mod h1:L4uxeKpfBml98NYqVqwAdmV1a2nBtAec/cf3fpucW/k=
 honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 lukechampine.com/uint128 v1.2.0 h1:mBi/5l91vocEN8otkC5bDLhi2KdCticRiwbdB0O+rjI=
@@ -732,6 +700,6 @@ 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=
-moul.io/http2curl/v2 v2.3.0 h1:9r3JfDzWPcbIklMOs2TnIFzDYvfAZvjeavG6EzP7jYs=
+rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4=
 rsc.io/tmplfunc v0.0.3 h1:53XFQh69AfOa8Tw0Jm7t+GV7KZhOi6jzsCzTtKbMvzU=
 rsc.io/tmplfunc v0.0.3/go.mod h1:AG3sTPzElb1Io3Yg4voV9AGZJuleGAwaVRxL9M49PhA=

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

@@ -0,0 +1,37 @@
+package controller
+
+import (
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+
+	"bridge-history-api/internal/logic"
+	"bridge-history-api/internal/types"
+)
+
+// BatchController contains the query claimable txs service
+type BatchController struct {
+	batchLogic *logic.BatchLogic
+}
+
+// NewBatchController return NewBatchController instance
+func NewBatchController(db *gorm.DB) *BatchController {
+	return &BatchController{
+		batchLogic: logic.NewBatchLogic(db),
+	}
+}
+
+// GetWithdrawRootByBatchIndex defines the http get method behavior
+func (b *BatchController) GetWithdrawRootByBatchIndex(ctx *gin.Context) {
+	var req types.QueryByBatchIndexRequest
+	if err := ctx.ShouldBind(&req); err != nil {
+		types.RenderFailure(ctx, types.ErrParameterInvalidNo, err)
+		return
+	}
+	result, err := b.batchLogic.GetWithdrawRootByBatchIndex(ctx, req.BatchIndex)
+	if err != nil {
+		types.RenderFailure(ctx, types.ErrGetWithdrawRootByBatchIndexFailure, err)
+		return
+	}
+
+	types.RenderSuccess(ctx, result)
+}

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

@@ -0,0 +1,30 @@
+package controller
+
+import (
+	"sync"
+
+	"gorm.io/gorm"
+)
+
+var (
+	// HistoryCtrler is controller instance
+	HistoryCtrler *HistoryController
+	// BatchCtrler is controller instance
+	BatchCtrler *BatchController
+	// HealthCheck the health check controller
+	HealthCheck *HealthCheckController
+	// Ready the ready controller
+	Ready *ReadyController
+
+	initControllerOnce sync.Once
+)
+
+// InitController inits Controller with database
+func InitController(db *gorm.DB) {
+	initControllerOnce.Do(func() {
+		HistoryCtrler = NewHistoryController(db)
+		BatchCtrler = NewBatchController(db)
+		HealthCheck = NewHealthCheckController(db)
+		Ready = NewReadyController()
+	})
+}

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

@@ -0,0 +1,30 @@
+package controller
+
+import (
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+
+	"bridge-history-api/internal/types"
+	"bridge-history-api/utils"
+)
+
+// HealthCheckController is health check API
+type HealthCheckController struct {
+	db *gorm.DB
+}
+
+// NewHealthCheckController returns an HealthCheckController instance
+func NewHealthCheckController(db *gorm.DB) *HealthCheckController {
+	return &HealthCheckController{
+		db: db,
+	}
+}
+
+// HealthCheck the api controller for coordinator health check
+func (a *HealthCheckController) HealthCheck(c *gin.Context) {
+	if _, err := utils.Ping(a.db); err != nil {
+		types.RenderFatal(c, err)
+		return
+	}
+	types.RenderSuccess(c, nil)
+}

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

@@ -0,0 +1,72 @@
+package controller
+
+import (
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+
+	"bridge-history-api/internal/logic"
+	"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) *HistoryController {
+	return &HistoryController{
+		historyLogic: logic.NewHistoryLogic(db),
+	}
+}
+
+// GetAllClaimableTxsByAddr defines the http get method behavior
+func (c *HistoryController) GetAllClaimableTxsByAddr(ctx *gin.Context) {
+	var req types.QueryByAddressRequest
+	if err := ctx.ShouldBind(&req); err != nil {
+		types.RenderFailure(ctx, types.ErrParameterInvalidNo, err)
+		return
+	}
+	offset := (req.Page - 1) * req.PageSize
+	limit := req.PageSize
+	txs, total, err := c.historyLogic.GetClaimableTxsByAddress(ctx, common.HexToAddress(req.Address), offset, limit)
+	if err != nil {
+		types.RenderFailure(ctx, types.ErrGetClaimablesFailure, err)
+		return
+	}
+
+	types.RenderSuccess(ctx, &types.ResultData{Result: txs, Total: total})
+}
+
+// GetAllTxsByAddr defines the http get method behavior
+func (c *HistoryController) GetAllTxsByAddr(ctx *gin.Context) {
+	var req types.QueryByAddressRequest
+	if err := ctx.ShouldBind(&req); err != nil {
+		types.RenderJSON(ctx, types.ErrParameterInvalidNo, err, nil)
+		return
+	}
+	offset := (req.Page - 1) * req.PageSize
+	limit := req.PageSize
+	message, total, err := c.historyLogic.GetTxsByAddress(ctx, common.HexToAddress(req.Address), offset, limit)
+	if err != nil {
+		types.RenderFailure(ctx, types.ErrGetTxsByAddrFailure, err)
+		return
+	}
+	types.RenderSuccess(ctx, &types.ResultData{Result: message, Total: total})
+}
+
+// PostQueryTxsByHash defines the http post method behavior
+func (c *HistoryController) PostQueryTxsByHash(ctx *gin.Context) {
+	var req types.QueryByHashRequest
+	if err := ctx.ShouldBindJSON(&req); err != nil {
+		types.RenderFailure(ctx, types.ErrParameterInvalidNo, err)
+		return
+	}
+	result, err := c.historyLogic.GetTxsByHashes(ctx, req.Txs)
+	if err != nil {
+		types.RenderFailure(ctx, types.ErrGetTxsByHashFailure, err)
+		return
+	}
+	types.RenderSuccess(ctx, &types.ResultData{Result: result, Total: 0})
+}

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

@@ -0,0 +1,21 @@
+package controller
+
+import (
+	"github.com/gin-gonic/gin"
+
+	"bridge-history-api/internal/types"
+)
+
+// ReadyController ready API
+type ReadyController struct {
+}
+
+// NewReadyController returns an ReadyController instance
+func NewReadyController() *ReadyController {
+	return &ReadyController{}
+}
+
+// Ready the api controller for coordinator ready
+func (r *ReadyController) Ready(c *gin.Context) {
+	types.RenderSuccess(c, nil)
+}

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

@@ -0,0 +1,35 @@
+package logic
+
+import (
+	"context"
+
+	"github.com/ethereum/go-ethereum/log"
+	"gorm.io/gorm"
+
+	"bridge-history-api/orm"
+)
+
+// BatchLogic example service.
+type BatchLogic struct {
+	rollupOrm *orm.RollupBatch
+}
+
+// NewBatchLogic returns services backed with a "db"
+func NewBatchLogic(db *gorm.DB) *BatchLogic {
+	logic := &BatchLogic{rollupOrm: orm.NewRollupBatch(db)}
+	return logic
+}
+
+// GetWithdrawRootByBatchIndex get withdraw root by batch index from db
+func (b *BatchLogic) GetWithdrawRootByBatchIndex(ctx context.Context, batchIndex uint64) (string, error) {
+	batch, err := b.rollupOrm.GetRollupBatchByIndex(ctx, batchIndex)
+	if err != nil {
+		log.Debug("getWithdrawRootByBatchIndex failed", "error", err)
+		return "", err
+	}
+	if batch == nil {
+		log.Debug("getWithdrawRootByBatchIndex failed", "error", "batch not found")
+		return "", nil
+	}
+	return batch.WithdrawRoot, nil
+}

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

@@ -0,0 +1,212 @@
+package logic
+
+import (
+	"context"
+	"strconv"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/log"
+	"gorm.io/gorm"
+
+	"bridge-history-api/internal/types"
+	"bridge-history-api/orm"
+)
+
+// HistoryLogic example service.
+type HistoryLogic struct {
+	db *gorm.DB
+}
+
+// NewHistoryLogic returns services backed with a "db"
+func NewHistoryLogic(db *gorm.DB) *HistoryLogic {
+	logic := &HistoryLogic{db: db}
+	return logic
+}
+
+// getCrossTxClaimInfo get UserClaimInfos by address
+func getCrossTxClaimInfo(ctx context.Context, msgHash string, db *gorm.DB) *types.UserClaimInfo {
+	l2SentMsgOrm := orm.NewL2SentMsg(db)
+	rollupOrm := orm.NewRollupBatch(db)
+	l2sentMsg, err := l2SentMsgOrm.GetL2SentMsgByHash(ctx, msgHash)
+	if err != nil || l2sentMsg == nil {
+		log.Debug("getCrossTxClaimInfo failed", "error", err)
+		return &types.UserClaimInfo{}
+	}
+	batch, err := rollupOrm.GetRollupBatchByIndex(ctx, l2sentMsg.BatchIndex)
+	if err != nil {
+		log.Debug("getCrossTxClaimInfo failed", "error", err)
+		return &types.UserClaimInfo{}
+	}
+	return &types.UserClaimInfo{
+		From:       l2sentMsg.Sender,
+		To:         l2sentMsg.Target,
+		Value:      l2sentMsg.Value,
+		Nonce:      strconv.FormatUint(l2sentMsg.Nonce, 10),
+		Message:    l2sentMsg.MsgData,
+		Proof:      "0x" + l2sentMsg.MsgProof,
+		BatchHash:  batch.BatchHash,
+		BatchIndex: strconv.FormatUint(l2sentMsg.BatchIndex, 10),
+	}
+
+}
+
+func updateCrossTxHash(ctx context.Context, msgHash string, txInfo *types.TxHistoryInfo, db *gorm.DB) {
+	relayed := orm.NewRelayedMsg(db)
+	relayed, err := relayed.GetRelayedMsgByHash(ctx, msgHash)
+	if err != nil {
+		log.Debug("updateCrossTxHash failed", "error", err)
+		return
+	}
+	if relayed == nil {
+		return
+	}
+	if relayed.Layer1Hash != "" {
+		txInfo.FinalizeTx.Hash = relayed.Layer1Hash
+		txInfo.FinalizeTx.BlockNumber = relayed.Height
+		return
+	}
+	if relayed.Layer2Hash != "" {
+		txInfo.FinalizeTx.Hash = relayed.Layer2Hash
+		txInfo.FinalizeTx.BlockNumber = relayed.Height
+		return
+	}
+
+}
+
+// GetClaimableTxsByAddress get all claimable txs under given address
+func (h *HistoryLogic) GetClaimableTxsByAddress(ctx context.Context, address common.Address, offset int, limit int) ([]*types.TxHistoryInfo, uint64, error) {
+	var txHistories []*types.TxHistoryInfo
+	l2SentMsgOrm := orm.NewL2SentMsg(h.db)
+	l2CrossMsgOrm := orm.NewCrossMsg(h.db)
+	total, err := l2SentMsgOrm.GetClaimableL2SentMsgByAddressTotalNum(ctx, address.Hex())
+	if err != nil || total == 0 {
+		return txHistories, 0, err
+	}
+	results, err := l2SentMsgOrm.GetClaimableL2SentMsgByAddressWithOffset(ctx, address.Hex(), offset, limit)
+	if err != nil || len(results) == 0 {
+		return txHistories, 0, err
+	}
+	var msgHashList []string
+	for _, result := range results {
+		msgHashList = append(msgHashList, result.MsgHash)
+	}
+	crossMsgs, err := l2CrossMsgOrm.GetL2CrossMsgByMsgHashList(ctx, msgHashList)
+	// crossMsgs can be empty, because they can be emitted by user directly call contract
+	if err != nil {
+		return txHistories, 0, err
+	}
+	crossMsgMap := make(map[string]*orm.CrossMsg)
+	for _, crossMsg := range crossMsgs {
+		crossMsgMap[crossMsg.MsgHash] = crossMsg
+	}
+	for _, result := range results {
+		txInfo := &types.TxHistoryInfo{
+			Hash:        result.TxHash,
+			IsL1:        false,
+			BlockNumber: result.Height,
+			FinalizeTx:  &types.Finalized{},
+			ClaimInfo:   getCrossTxClaimInfo(ctx, result.MsgHash, h.db),
+		}
+		if crossMsg, exist := crossMsgMap[result.MsgHash]; exist {
+			txInfo.Amount = crossMsg.Amount
+			txInfo.To = crossMsg.Target
+			txInfo.BlockTimestamp = crossMsg.Timestamp
+			txInfo.CreatedAt = crossMsg.CreatedAt
+			txInfo.L1Token = crossMsg.Layer1Token
+			txInfo.L2Token = crossMsg.Layer2Token
+		}
+		txHistories = append(txHistories, txInfo)
+	}
+	return txHistories, total, err
+}
+
+// GetTxsByAddress get all txs under given address
+func (h *HistoryLogic) GetTxsByAddress(ctx context.Context, address common.Address, offset int, limit int) ([]*types.TxHistoryInfo, uint64, error) {
+	var txHistories []*types.TxHistoryInfo
+	utilOrm := orm.NewCrossMsg(h.db)
+	total, err := utilOrm.GetTotalCrossMsgCountByAddress(ctx, address.String())
+	if err != nil || total == 0 {
+		return txHistories, 0, err
+	}
+	result, err := utilOrm.GetCrossMsgsByAddressWithOffset(ctx, address.String(), offset, limit)
+
+	if err != nil {
+		return nil, 0, err
+	}
+	for _, msg := range result {
+		txHistory := &types.TxHistoryInfo{
+			Hash:           msg.Layer1Hash + msg.Layer2Hash,
+			Amount:         msg.Amount,
+			To:             msg.Target,
+			L1Token:        msg.Layer1Token,
+			L2Token:        msg.Layer2Token,
+			IsL1:           msg.MsgType == int(orm.Layer1Msg),
+			BlockNumber:    msg.Height,
+			BlockTimestamp: msg.Timestamp,
+			CreatedAt:      msg.CreatedAt,
+			FinalizeTx: &types.Finalized{
+				Hash: "",
+			},
+			ClaimInfo: getCrossTxClaimInfo(ctx, msg.MsgHash, h.db),
+		}
+		updateCrossTxHash(ctx, msg.MsgHash, txHistory, h.db)
+		txHistories = append(txHistories, txHistory)
+	}
+	return txHistories, total, nil
+}
+
+// GetTxsByHashes get tx infos under given tx hashes
+func (h *HistoryLogic) GetTxsByHashes(ctx context.Context, hashes []string) ([]*types.TxHistoryInfo, error) {
+	txHistories := make([]*types.TxHistoryInfo, 0)
+	CrossMsgOrm := orm.NewCrossMsg(h.db)
+	for _, hash := range hashes {
+		l1result, err := CrossMsgOrm.GetL1CrossMsgByHash(ctx, common.HexToHash(hash))
+		if err != nil {
+			return nil, err
+		}
+		if l1result != nil {
+			txHistory := &types.TxHistoryInfo{
+				Hash:           l1result.Layer1Hash,
+				Amount:         l1result.Amount,
+				To:             l1result.Target,
+				IsL1:           true,
+				L1Token:        l1result.Layer1Token,
+				L2Token:        l1result.Layer2Token,
+				BlockNumber:    l1result.Height,
+				BlockTimestamp: l1result.Timestamp,
+				CreatedAt:      l1result.CreatedAt,
+				FinalizeTx: &types.Finalized{
+					Hash: "",
+				},
+			}
+			updateCrossTxHash(ctx, l1result.MsgHash, txHistory, h.db)
+			txHistories = append(txHistories, txHistory)
+			continue
+		}
+		l2result, err := CrossMsgOrm.GetL2CrossMsgByHash(ctx, common.HexToHash(hash))
+		if err != nil {
+			return nil, err
+		}
+		if l2result != nil {
+			txHistory := &types.TxHistoryInfo{
+				Hash:           l2result.Layer2Hash,
+				Amount:         l2result.Amount,
+				To:             l2result.Target,
+				IsL1:           false,
+				L1Token:        l2result.Layer1Token,
+				L2Token:        l2result.Layer2Token,
+				BlockNumber:    l2result.Height,
+				BlockTimestamp: l2result.Timestamp,
+				CreatedAt:      l2result.CreatedAt,
+				FinalizeTx: &types.Finalized{
+					Hash: "",
+				},
+				ClaimInfo: getCrossTxClaimInfo(ctx, l2result.MsgHash, h.db),
+			}
+			updateCrossTxHash(ctx, l2result.MsgHash, txHistory, h.db)
+			txHistories = append(txHistories, txHistory)
+			continue
+		}
+	}
+	return txHistories, nil
+}

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

@@ -0,0 +1,30 @@
+package route
+
+import (
+	"time"
+
+	"github.com/gin-contrib/cors"
+	"github.com/gin-gonic/gin"
+
+	"bridge-history-api/config"
+	"bridge-history-api/internal/controller"
+)
+
+// Route routes the APIs
+func Route(router *gin.Engine, conf *config.Config) {
+	router.Use(cors.New(cors.Config{
+		AllowOrigins:     []string{"*"},
+		AllowMethods:     []string{"GET", "POST", "PUT", "DELETE"},
+		AllowHeaders:     []string{"Origin", "Content-Type", "Authorization"},
+		AllowCredentials: true,
+		MaxAge:           12 * time.Hour,
+	}))
+
+	r := router.Group("api/")
+	r.GET("/txs", controller.HistoryCtrler.GetAllTxsByAddr)
+	r.POST("/txsbyhashes", controller.HistoryCtrler.PostQueryTxsByHash)
+	r.GET("/claimable", controller.HistoryCtrler.GetAllClaimableTxsByAddr)
+	r.GET("/withdraw_root", controller.BatchCtrler.GetWithdrawRootByBatchIndex)
+	r.GET("/health", controller.HealthCheck.HealthCheck)
+	r.GET("/ready", controller.Ready.Ready)
+}

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

@@ -0,0 +1,132 @@
+package types
+
+import (
+	"net/http"
+	"time"
+
+	"github.com/gin-gonic/gin"
+)
+
+const (
+	// Success shows OK.
+	Success = 0
+	// InternalServerError shows a fatal error in the server
+	InternalServerError = 500
+	// ErrParameterInvalidNo is invalid params
+	ErrParameterInvalidNo = 40001
+	// ErrGetClaimablesFailure is getting all claimables txs error
+	ErrGetClaimablesFailure = 40002
+	// ErrGetTxsByHashFailure is getting txs by hash list error
+	ErrGetTxsByHashFailure = 40003
+	// ErrGetTxsByAddrFailure is getting txs by address error
+	ErrGetTxsByAddrFailure = 40004
+	// ErrGetWithdrawRootByBatchIndexFailure is getting withdraw root by batch index error
+	ErrGetWithdrawRootByBatchIndexFailure = 40005
+)
+
+// QueryByAddressRequest the request parameter of address api
+type QueryByAddressRequest struct {
+	Address  string `form:"address" binding:"required"`
+	Page     int    `form:"page" binding:"required"`
+	PageSize int    `form:"page_size" binding:"required"`
+}
+
+// QueryByHashRequest the request parameter of hash api
+type QueryByHashRequest struct {
+	Txs []string `raw:"txs" binding:"required"`
+}
+
+// QueryByBatchIndexRequest the request parameter of batch index api
+type QueryByBatchIndexRequest struct {
+	// BatchIndex can not be 0, because we dont decode the genesis block
+	BatchIndex uint64 `form:"batch_index" binding:"required"`
+}
+
+// ResultData contains return txs and total
+type ResultData struct {
+	Result []*TxHistoryInfo `json:"result"`
+	Total  uint64           `json:"total"`
+}
+
+// Response the response schema
+type Response struct {
+	ErrCode int         `json:"errcode"`
+	ErrMsg  string      `json:"errmsg"`
+	Data    interface{} `json:"data"`
+}
+
+// Finalized the schema of tx finalized infos
+type Finalized struct {
+	Hash           string     `json:"hash"`
+	Amount         string     `json:"amount"`
+	To             string     `json:"to"` // useless
+	IsL1           bool       `json:"isL1"`
+	BlockNumber    uint64     `json:"blockNumber"`
+	BlockTimestamp *time.Time `json:"blockTimestamp"` // uselesss
+}
+
+// UserClaimInfo the schema of tx claim infos
+type UserClaimInfo struct {
+	From       string `json:"from"`
+	To         string `json:"to"`
+	Value      string `json:"value"`
+	Nonce      string `json:"nonce"`
+	BatchHash  string `json:"batch_hash"`
+	Message    string `json:"message"`
+	Proof      string `json:"proof"`
+	BatchIndex string `json:"batch_index"`
+}
+
+// TxHistoryInfo the schema of tx history infos
+type TxHistoryInfo struct {
+	Hash           string         `json:"hash"`
+	Amount         string         `json:"amount"`
+	To             string         `json:"to"` // useless
+	IsL1           bool           `json:"isL1"`
+	L1Token        string         `json:"l1Token"`
+	L2Token        string         `json:"l2Token"`
+	BlockNumber    uint64         `json:"blockNumber"`
+	BlockTimestamp *time.Time     `json:"blockTimestamp"` // useless
+	FinalizeTx     *Finalized     `json:"finalizeTx"`
+	ClaimInfo      *UserClaimInfo `json:"claimInfo"`
+	CreatedAt      *time.Time     `json:"createdTime"`
+}
+
+// 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/model/request.go

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

bridge-history-api/model/response.go

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

bridge-history-api/orm/batch.go

@@ -0,0 +1,104 @@
+package orm
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/ethereum/go-ethereum/log"
+	"gorm.io/gorm"
+)
+
+// RollupBatch is the struct for rollup_batch table
+type RollupBatch struct {
+	db *gorm.DB `gorm:"column:-"`
+
+	ID               uint64         `json:"id" gorm:"column:id"`
+	BatchIndex       uint64         `json:"batch_index" gorm:"column:batch_index"`
+	BatchHash        string         `json:"batch_hash" gorm:"column:batch_hash"`
+	CommitHeight     uint64         `json:"commit_height" gorm:"column:commit_height"`
+	StartBlockNumber uint64         `json:"start_block_number" gorm:"column:start_block_number"`
+	EndBlockNumber   uint64         `json:"end_block_number" gorm:"column:end_block_number"`
+	WithdrawRoot     string         `json:"withdraw_root" gorm:"column:withdraw_root;default:NULL"`
+	CreatedAt        *time.Time     `json:"created_at" gorm:"column:created_at"`
+	UpdatedAt        *time.Time     `json:"updated_at" gorm:"column:updated_at"`
+	DeletedAt        gorm.DeletedAt `json:"deleted_at" gorm:"column:deleted_at;default:NULL"`
+}
+
+// NewRollupBatch create an RollupBatch instance
+func NewRollupBatch(db *gorm.DB) *RollupBatch {
+	return &RollupBatch{db: db}
+}
+
+// TableName returns the table name for the Batch model.
+func (*RollupBatch) TableName() string {
+	return "rollup_batch"
+}
+
+// GetLatestRollupBatchProcessedHeight return latest processed height from rollup_batch table
+func (r *RollupBatch) GetLatestRollupBatchProcessedHeight(ctx context.Context) (uint64, error) {
+	var result RollupBatch
+	err := r.db.WithContext(ctx).Unscoped().Select("commit_height").Order("id desc").First(&result).Error
+	if err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return 0, nil
+		}
+		return 0, fmt.Errorf("RollupBatch.GetLatestRollupBatchProcessedHeight error: %w", err)
+	}
+	return result.CommitHeight, nil
+}
+
+// GetLatestRollupBatch return the latest rollup batch in db
+func (r *RollupBatch) GetLatestRollupBatch(ctx context.Context) (*RollupBatch, error) {
+	var result RollupBatch
+	err := r.db.WithContext(ctx).Model(&RollupBatch{}).Where("batch_hash is not NULL").Order("batch_index desc").First(&result).Error
+	if err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return nil, nil
+		}
+		return nil, fmt.Errorf("RollupBatch.GetLatestRollupBatch error: %w", err)
+	}
+	return &result, nil
+}
+
+// GetRollupBatchByIndex return the rollup batch by index
+func (r *RollupBatch) GetRollupBatchByIndex(ctx context.Context, index uint64) (*RollupBatch, error) {
+	var result RollupBatch
+	err := r.db.WithContext(ctx).Model(&RollupBatch{}).Where("batch_index = ?", index).First(&result).Error
+	if err != nil {
+		return nil, fmt.Errorf("RollupBatch.GetRollupBatchByIndex error: %w", err)
+	}
+	return &result, nil
+}
+
+// InsertRollupBatch batch insert rollup batch into db and return the transaction
+func (r *RollupBatch) InsertRollupBatch(ctx context.Context, batches []*RollupBatch, dbTx ...*gorm.DB) error {
+	if len(batches) == 0 {
+		return nil
+	}
+	db := r.db
+	if len(dbTx) > 0 && dbTx[0] != nil {
+		db = dbTx[0]
+	}
+	err := db.WithContext(ctx).Model(&RollupBatch{}).Create(&batches).Error
+	if err != nil {
+		batchIndexes := make([]uint64, 0, len(batches))
+		heights := make([]uint64, 0, len(batches))
+		for _, batch := range batches {
+			batchIndexes = append(batchIndexes, batch.BatchIndex)
+			heights = append(heights, batch.CommitHeight)
+		}
+		log.Error("failed to insert rollup batch", "batchIndexes", batchIndexes, "heights", heights)
+		return fmt.Errorf("RollupBatch.InsertRollupBatch error: %w", err)
+	}
+	return nil
+}
+
+// UpdateRollupBatchWithdrawRoot updates the withdraw_root column in rollup_batch table
+func (r *RollupBatch) UpdateRollupBatchWithdrawRoot(ctx context.Context, batchIndex uint64, withdrawRoot string) error {
+	err := r.db.WithContext(ctx).Model(&RollupBatch{}).Where("batch_index = ?", batchIndex).Update("withdraw_root", withdrawRoot).Error
+	if err != nil {
+		return fmt.Errorf("RollupBatch.UpdateRuollupBatch error: %w", err)
+	}
+	return nil
+}

bridge-history-api/orm/cross_msg.go

@@ -0,0 +1,370 @@
+package orm
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/log"
+	"gorm.io/gorm"
+)
+
+// AssetType can be ETH/ERC20/ERC1155/ERC721
+type AssetType int
+
+// MsgType can be layer1/layer2 msg
+type MsgType int
+
+func (a AssetType) String() string {
+	switch a {
+	case ETH:
+		return "ETH"
+	case ERC20:
+		return "ERC20"
+	case ERC1155:
+		return "ERC1155"
+	case ERC721:
+		return "ERC721"
+	}
+	return "Unknown Asset Type"
+}
+
+const (
+	// ETH = 0
+	ETH AssetType = iota
+	// ERC20 = 1
+	ERC20
+	// ERC721 = 2
+	ERC721
+	// ERC1155 = 3
+	ERC1155
+)
+
+const (
+	// UnknownMsg = 0
+	UnknownMsg MsgType = iota
+	// Layer1Msg = 1
+	Layer1Msg
+	// Layer2Msg = 2
+	Layer2Msg
+)
+
+// CrossMsg represents a cross message from layer 1 to layer 2
+type CrossMsg struct {
+	db *gorm.DB `gorm:"column:-"`
+
+	ID           uint64         `json:"id" gorm:"column:id"`
+	MsgHash      string         `json:"msg_hash" gorm:"column:msg_hash"`
+	Height       uint64         `json:"height" gorm:"column:height"`
+	Sender       string         `json:"sender" gorm:"column:sender"`
+	Target       string         `json:"target" gorm:"column:target"`
+	Amount       string         `json:"amount" gorm:"column:amount"`
+	Layer1Hash   string         `json:"layer1_hash" gorm:"column:layer1_hash;default:''"`
+	Layer2Hash   string         `json:"layer2_hash" gorm:"column:layer2_hash;default:''"`
+	Layer1Token  string         `json:"layer1_token" gorm:"column:layer1_token;default:''"`
+	Layer2Token  string         `json:"layer2_token" gorm:"column:layer2_token;default:''"`
+	TokenIDs     string         `json:"token_ids" gorm:"column:token_ids;default:''"`
+	TokenAmounts string         `json:"token_amounts" gorm:"column:token_amounts;default:''"`
+	Asset        int            `json:"asset" gorm:"column:asset"`
+	MsgType      int            `json:"msg_type" gorm:"column:msg_type"`
+	Timestamp    *time.Time     `json:"timestamp" gorm:"column:block_timestamp;default;NULL"`
+	CreatedAt    *time.Time     `json:"created_at" gorm:"column:created_at"`
+	UpdatedAt    *time.Time     `json:"updated_at" gorm:"column:updated_at"`
+	DeletedAt    gorm.DeletedAt `json:"deleted_at" gorm:"column:deleted_at;default:NULL"`
+}
+
+// TableName returns the table name for the CrossMsg model.
+func (*CrossMsg) TableName() string {
+	return "cross_message"
+}
+
+// NewCrossMsg returns a new instance of CrossMsg.
+func NewCrossMsg(db *gorm.DB) *CrossMsg {
+	return &CrossMsg{db: db}
+}
+
+// L1 Cross Msgs Operations
+
+// GetL1CrossMsgByHash returns layer1 cross message by given hash
+func (c *CrossMsg) GetL1CrossMsgByHash(ctx context.Context, l1Hash common.Hash) (*CrossMsg, error) {
+	var result CrossMsg
+	err := c.db.WithContext(ctx).Model(&CrossMsg{}).Where("layer1_hash = ? AND msg_type = ?", l1Hash.String(), Layer1Msg).First(&result).Error
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+		return nil, fmt.Errorf("CrossMsg.GetL1CrossMsgByHash error: %w", err)
+	}
+	return &result, nil
+}
+
+// GetLatestL1ProcessedHeight returns the latest processed height of layer1 cross messages
+func (c *CrossMsg) GetLatestL1ProcessedHeight(ctx context.Context) (uint64, error) {
+	var result CrossMsg
+	err := c.db.WithContext(ctx).Model(&CrossMsg{}).Where("msg_type = ?", Layer1Msg).
+		Select("height").
+		Order("id DESC").
+		First(&result).
+		Error
+	if err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return 0, nil
+		}
+		return 0, fmt.Errorf("CrossMsg.GetLatestL1ProcessedHeight error: %w", err)
+	}
+	return result.Height, nil
+}
+
+// GetL1EarliestNoBlockTimestampHeight returns the earliest layer1 cross message height which has no block timestamp
+func (c *CrossMsg) GetL1EarliestNoBlockTimestampHeight(ctx context.Context) (uint64, error) {
+	var result CrossMsg
+	err := c.db.WithContext(ctx).Model(&CrossMsg{}).
+		Where("block_timestamp IS NULL AND msg_type = ?", Layer1Msg).
+		Select("height").
+		Order("height ASC").
+		First(&result).
+		Error
+	if err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return 0, nil
+		}
+		return 0, fmt.Errorf("CrossMsg.GetL1EarliestNoBlockTimestampHeight error: %w", err)
+	}
+	return result.Height, nil
+}
+
+// InsertL1CrossMsg batch insert layer1 cross messages into db
+func (c *CrossMsg) InsertL1CrossMsg(ctx context.Context, messages []*CrossMsg, dbTx ...*gorm.DB) error {
+	if len(messages) == 0 {
+		return nil
+	}
+	db := c.db
+	if len(dbTx) > 0 && dbTx[0] != nil {
+		db = dbTx[0]
+	}
+	db.WithContext(ctx)
+	err := db.Model(&CrossMsg{}).Create(&messages).Error
+	if err != nil {
+		l1hashes := make([]string, 0, len(messages))
+		heights := make([]uint64, 0, len(messages))
+		for _, msg := range messages {
+			l1hashes = append(l1hashes, msg.Layer1Hash)
+			heights = append(heights, msg.Height)
+		}
+		log.Error("failed to insert l1 cross messages", "l1hashes", l1hashes, "heights", heights, "err", err)
+		return fmt.Errorf("CrossMsg.InsertL1CrossMsg error: %w", err)
+	}
+	return nil
+}
+
+// UpdateL1CrossMsgHash update l1 cross msg hash in db, no need to check msg_type since layer1_hash wont be empty if its layer1 msg
+func (c *CrossMsg) UpdateL1CrossMsgHash(ctx context.Context, l1Hash, msgHash common.Hash, dbTx ...*gorm.DB) error {
+	db := c.db
+	if len(dbTx) > 0 && dbTx[0] != nil {
+		db = dbTx[0]
+	}
+	db.WithContext(ctx)
+	err := c.db.Model(&CrossMsg{}).Where("layer1_hash = ?", l1Hash.Hex()).Update("msg_hash", msgHash.Hex()).Error
+	if err != nil {
+		return fmt.Errorf("CrossMsg.UpdateL1CrossMsgHash error: %w", err)
+	}
+	return nil
+
+}
+
+// UpdateL1BlockTimestamp update layer1 block timestamp
+func (c *CrossMsg) UpdateL1BlockTimestamp(ctx context.Context, height uint64, timestamp time.Time) error {
+	err := c.db.WithContext(ctx).Model(&CrossMsg{}).
+		Where("height = ? AND msg_type = ?", height, Layer1Msg).
+		Update("block_timestamp", timestamp).Error
+	if err != nil {
+		return fmt.Errorf("CrossMsg.UpdateL1BlockTimestamp error: %w", err)
+	}
+	return err
+}
+
+// DeleteL1CrossMsgAfterHeight soft delete layer1 cross messages after given height
+func (c *CrossMsg) DeleteL1CrossMsgAfterHeight(ctx context.Context, height uint64, dbTx ...*gorm.DB) error {
+	db := c.db
+	if len(dbTx) > 0 && dbTx[0] != nil {
+		db = dbTx[0]
+	}
+	db.WithContext(ctx)
+	err := db.Delete(&CrossMsg{}, "height > ? AND msg_type = ?", height, Layer1Msg).Error
+	if err != nil {
+		return fmt.Errorf("CrossMsg.DeleteL1CrossMsgAfterHeight error: %w", err)
+	}
+	return nil
+}
+
+// L2 Cross Msgs Operations
+
+// GetL2CrossMsgByHash returns layer2 cross message by given hash
+func (c *CrossMsg) GetL2CrossMsgByHash(ctx context.Context, l2Hash common.Hash) (*CrossMsg, error) {
+	var result CrossMsg
+	err := c.db.WithContext(ctx).Model(&CrossMsg{}).Where("layer2_hash = ? AND msg_type = ?", l2Hash.String(), Layer2Msg).First(&result).Error
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+		return nil, fmt.Errorf("CrossMsg.GetL2CrossMsgByHash error: %w", err)
+	}
+	return &result, nil
+}
+
+// GetLatestL2ProcessedHeight returns the latest processed height of layer2 cross messages
+func (c *CrossMsg) GetLatestL2ProcessedHeight(ctx context.Context) (uint64, error) {
+	var result CrossMsg
+	err := c.db.WithContext(ctx).Model(&CrossMsg{}).
+		Select("height").
+		Where("msg_type = ?", Layer2Msg).
+		Order("id DESC").
+		First(&result).
+		Error
+	if err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return 0, nil
+		}
+		return 0, fmt.Errorf("CrossMsg.GetLatestL2ProcessedHeight error: %w", err)
+	}
+	return result.Height, nil
+}
+
+// GetL2CrossMsgByMsgHashList returns layer2 cross messages under given msg hashes
+func (c *CrossMsg) GetL2CrossMsgByMsgHashList(ctx context.Context, msgHashList []string) ([]*CrossMsg, error) {
+	var results []*CrossMsg
+	err := c.db.WithContext(ctx).Model(&CrossMsg{}).
+		Where("msg_hash IN (?) AND msg_type = ?", msgHashList, Layer2Msg).
+		Find(&results).
+		Error
+
+	if err != nil {
+		return nil, fmt.Errorf("CrossMsg.GetL2CrossMsgByMsgHashList error: %w", err)
+	}
+	if len(results) == 0 {
+		log.Debug("no CrossMsg under given msg hashes", "msg hash list", msgHashList)
+	}
+	return results, nil
+}
+
+// GetL2EarliestNoBlockTimestampHeight returns the earliest layer2 cross message height which has no block timestamp
+func (c *CrossMsg) GetL2EarliestNoBlockTimestampHeight(ctx context.Context) (uint64, error) {
+	var result CrossMsg
+	err := c.db.WithContext(ctx).Model(&CrossMsg{}).
+		Where("block_timestamp IS NULL AND msg_type = ?", Layer2Msg).
+		Select("height").
+		Order("height ASC").
+		First(&result).
+		Error
+	if err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return 0, nil
+		}
+		return 0, fmt.Errorf("CrossMsg.GetL2EarliestNoBlockTimestampHeight error: %w", err)
+	}
+	return result.Height, nil
+}
+
+// InsertL2CrossMsg batch insert layer2 cross messages
+func (c *CrossMsg) InsertL2CrossMsg(ctx context.Context, messages []*CrossMsg, dbTx ...*gorm.DB) error {
+	if len(messages) == 0 {
+		return nil
+	}
+	db := c.db
+	if len(dbTx) > 0 && dbTx[0] != nil {
+		db = dbTx[0]
+	}
+	db.WithContext(ctx)
+	err := db.Model(&CrossMsg{}).Create(&messages).Error
+	if err != nil {
+		l2hashes := make([]string, 0, len(messages))
+		heights := make([]uint64, 0, len(messages))
+		for _, msg := range messages {
+			l2hashes = append(l2hashes, msg.Layer2Hash)
+			heights = append(heights, msg.Height)
+		}
+		log.Error("failed to insert l2 cross messages", "l2hashes", l2hashes, "heights", heights, "err", err)
+		return fmt.Errorf("CrossMsg.InsertL2CrossMsg error: %w", err)
+	}
+	return nil
+}
+
+// UpdateL2CrossMsgHash update layer2 cross message hash
+func (c *CrossMsg) UpdateL2CrossMsgHash(ctx context.Context, l2Hash, msgHash common.Hash, dbTx ...*gorm.DB) error {
+	db := c.db
+	if len(dbTx) > 0 && dbTx[0] != nil {
+		db = dbTx[0]
+	}
+	db.WithContext(ctx)
+	err := db.Model(&CrossMsg{}).
+		Where("layer2_hash = ?", l2Hash.String()).
+		Update("msg_hash", msgHash.String()).
+		Error
+	if err != nil {
+		return fmt.Errorf("CrossMsg.UpdateL2CrossMsgHash error: %w", err)
+	}
+	return nil
+}
+
+// UpdateL2BlockTimestamp update layer2 cross message block timestamp
+func (c *CrossMsg) UpdateL2BlockTimestamp(ctx context.Context, height uint64, timestamp time.Time) error {
+	err := c.db.WithContext(ctx).Model(&CrossMsg{}).
+		Where("height = ? AND msg_type = ?", height, Layer2Msg).
+		Update("block_timestamp", timestamp).Error
+	if err != nil {
+		return fmt.Errorf("CrossMsg.UpdateL2BlockTimestamp error: %w", err)
+	}
+	return nil
+}
+
+// DeleteL2CrossMsgFromHeight delete layer2 cross messages from given height
+func (c *CrossMsg) DeleteL2CrossMsgFromHeight(ctx context.Context, height uint64, dbTx ...*gorm.DB) error {
+	db := c.db
+	if len(dbTx) > 0 && dbTx[0] != nil {
+		db = dbTx[0]
+	}
+	db.WithContext(ctx)
+	err := db.Model(&CrossMsg{}).Delete("height > ? AND msg_type = ?", height, Layer2Msg).Error
+	if err != nil {
+		return fmt.Errorf("CrossMsg.DeleteL2CrossMsgFromHeight error: %w", err)
+
+	}
+	return nil
+}
+
+// General Operations
+
+// GetTotalCrossMsgCountByAddress get total cross msg count by address
+func (c *CrossMsg) GetTotalCrossMsgCountByAddress(ctx context.Context, sender string) (uint64, error) {
+	var count int64
+	err := c.db.WithContext(ctx).Model(&CrossMsg{}).
+		Where("sender = ?", sender).
+		Count(&count).
+		Error
+	if err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return 0, nil
+		}
+		return 0, fmt.Errorf("CrossMsg.GetTotalCrossMsgCountByAddress error: %w", err)
+
+	}
+	return uint64(count), nil
+}
+
+// GetCrossMsgsByAddressWithOffset get cross msgs by address with offset
+func (c *CrossMsg) GetCrossMsgsByAddressWithOffset(ctx context.Context, sender string, offset int, limit int) ([]CrossMsg, error) {
+	var messages []CrossMsg
+	err := c.db.WithContext(ctx).Model(&CrossMsg{}).
+		Where("sender = ?", sender).
+		Order("block_timestamp DESC NULLS FIRST, id DESC").
+		Limit(limit).
+		Offset(offset).
+		Find(&messages).
+		Error
+	if err != nil {
+		return nil, fmt.Errorf("CrossMsg.GetCrossMsgsByAddressWithOffset error: %w", err)
+	}
+	return messages, nil
+}

bridge-history-api/orm/l2_sent_msg.go

@@ -0,0 +1,219 @@
+package orm
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/ethereum/go-ethereum/log"
+	"gorm.io/gorm"
+)
+
+// L2SentMsg defines the struct for l2_sent_msg table record
+type L2SentMsg struct {
+	db *gorm.DB `gorm:"column:-"`
+
+	ID             uint64         `json:"id" gorm:"column:id"`
+	OriginalSender string         `json:"original_sender" gorm:"column:original_sender;default:''"`
+	TxHash         string         `json:"tx_hash" gorm:"column:tx_hash"`
+	MsgHash        string         `json:"msg_hash" gorm:"column:msg_hash"`
+	Sender         string         `json:"sender" gorm:"column:sender"`
+	Target         string         `json:"target" gorm:"column:target"`
+	Value          string         `json:"value" gorm:"column:value"`
+	Height         uint64         `json:"height" gorm:"column:height"`
+	Nonce          uint64         `json:"nonce" gorm:"column:nonce"`
+	BatchIndex     uint64         `json:"batch_index" gorm:"column:batch_index;default:0"`
+	MsgProof       string         `json:"msg_proof" gorm:"column:msg_proof;default:''"`
+	MsgData        string         `json:"msg_data" gorm:"column:msg_data;default:''"`
+	CreatedAt      *time.Time     `json:"created_at" gorm:"column:created_at"`
+	UpdatedAt      *time.Time     `json:"updated_at" gorm:"column:updated_at"`
+	DeletedAt      gorm.DeletedAt `json:"deleted_at" gorm:"column:deleted_at;default:NULL"`
+}
+
+// NewL2SentMsg create an NewL2SentMsg instance
+func NewL2SentMsg(db *gorm.DB) *L2SentMsg {
+	return &L2SentMsg{db: db}
+}
+
+// TableName returns the table name for the L2SentMsg model.
+func (*L2SentMsg) TableName() string {
+	return "l2_sent_msg"
+}
+
+// GetL2SentMsgByHash get l2 sent msg by hash
+func (l *L2SentMsg) GetL2SentMsgByHash(ctx context.Context, msgHash string) (*L2SentMsg, error) {
+	var result L2SentMsg
+	err := l.db.WithContext(ctx).Model(&L2SentMsg{}).
+		Where("msg_hash = ?", msgHash).
+		First(&result).
+		Error
+	if err != nil {
+		return nil, fmt.Errorf("L2SentMsg.GetL2SentMsgByHash error: %w", err)
+	}
+	return &result, nil
+}
+
+// GetLatestSentMsgHeightOnL2 get latest sent msg height on l2
+func (l *L2SentMsg) GetLatestSentMsgHeightOnL2(ctx context.Context) (uint64, error) {
+	var result L2SentMsg
+	err := l.db.WithContext(ctx).Model(&L2SentMsg{}).
+		Select("height").
+		Order("nonce DESC").
+		First(&result).Error
+
+	if err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return 0, nil
+		}
+		return 0, fmt.Errorf("L2SentMsg.GetLatestSentMsgHeightOnL2 error: %w", err)
+
+	}
+	return result.Height, nil
+}
+
+// GetClaimableL2SentMsgByAddressWithOffset get claimable l2 sent msg by address with offset
+func (l *L2SentMsg) GetClaimableL2SentMsgByAddressWithOffset(ctx context.Context, address string, offset int, limit int) ([]*L2SentMsg, error) {
+	var results []*L2SentMsg
+	err := l.db.WithContext(ctx).Raw(`SELECT * FROM l2_sent_msg WHERE id NOT IN (SELECT l2_sent_msg.id FROM l2_sent_msg INNER JOIN relayed_msg ON l2_sent_msg.msg_hash = relayed_msg.msg_hash WHERE l2_sent_msg.deleted_at IS NULL AND relayed_msg.deleted_at IS NULL) AND (original_sender=$1 OR sender = $1) AND msg_proof !='' ORDER BY id DESC LIMIT $2 OFFSET $3;`, address, limit, offset).
+		Scan(&results).Error
+	if err != nil {
+		return nil, fmt.Errorf("L2SentMsg.GetClaimableL2SentMsgByAddressWithOffset error: %w", err)
+	}
+	return results, nil
+}
+
+// GetClaimableL2SentMsgByAddressTotalNum get claimable l2 sent msg by address total num
+func (l *L2SentMsg) GetClaimableL2SentMsgByAddressTotalNum(ctx context.Context, address string) (uint64, error) {
+	var count uint64
+	err := l.db.WithContext(ctx).Raw(`SELECT COUNT(*) FROM l2_sent_msg WHERE id NOT IN (SELECT l2_sent_msg.id FROM l2_sent_msg INNER JOIN relayed_msg ON l2_sent_msg.msg_hash = relayed_msg.msg_hash WHERE l2_sent_msg.deleted_at IS NULL AND relayed_msg.deleted_at IS NULL) AND (original_sender=$1 OR sender = $1) AND msg_proof !='';`, address).
+		Scan(&count).Error
+	if err != nil {
+		return 0, fmt.Errorf("L2SentMsg.GetClaimableL2SentMsgByAddressTotalNum error: %w", err)
+	}
+	return count, nil
+}
+
+// GetLatestL2SentMsgBatchIndex get latest l2 sent msg batch index
+func (l *L2SentMsg) GetLatestL2SentMsgBatchIndex(ctx context.Context) (int64, error) {
+	var result L2SentMsg
+	err := l.db.WithContext(ctx).Model(&L2SentMsg{}).
+		Where("batch_index != 0").
+		Order("batch_index DESC").
+		Select("batch_index").
+		First(&result).
+		Error
+	if err != nil && errors.Is(err, gorm.ErrRecordNotFound) {
+		return -1, nil
+	}
+	if err != nil {
+		return -1, fmt.Errorf("L2SentMsg.GetLatestL2SentMsgBatchIndex error: %w", err)
+	}
+	// Watch for overflow, tho its not likely to happen
+	return int64(result.BatchIndex), nil
+}
+
+// GetL2SentMsgMsgHashByHeightRange get l2 sent msg msg hash by height range
+func (l *L2SentMsg) GetL2SentMsgMsgHashByHeightRange(ctx context.Context, startHeight, endHeight uint64) ([]*L2SentMsg, error) {
+	var results []*L2SentMsg
+	err := l.db.WithContext(ctx).Model(&L2SentMsg{}).
+		Where("height >= ? AND height <= ?", startHeight, endHeight).
+		Order("nonce ASC").
+		Find(&results).
+		Error
+	if err != nil {
+		return nil, fmt.Errorf("L2SentMsg.GetL2SentMsgMsgHashByHeightRange error: %w", err)
+	}
+	return results, nil
+}
+
+// GetL2SentMessageByNonce get l2 sent message by nonce
+func (l *L2SentMsg) GetL2SentMessageByNonce(ctx context.Context, nonce uint64) (*L2SentMsg, error) {
+	var result L2SentMsg
+	err := l.db.WithContext(ctx).Model(&L2SentMsg{}).
+		Where("nonce = ?", nonce).
+		First(&result).
+		Error
+	if err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return nil, nil
+		}
+		return nil, fmt.Errorf("L2SentMsg.GetL2SentMessageByNonce error: %w", err)
+
+	}
+	return &result, nil
+}
+
+// GetLatestL2SentMsgLEHeight get latest l2 sent msg less than or equal to end block number
+func (l *L2SentMsg) GetLatestL2SentMsgLEHeight(ctx context.Context, endBlockNumber uint64) (*L2SentMsg, error) {
+	var result L2SentMsg
+	err := l.db.WithContext(ctx).Model(&L2SentMsg{}).
+		Where("height <= ?", endBlockNumber).
+		Order("nonce DESC").
+		First(&result).
+		Error
+	if err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return nil, nil
+		}
+		return nil, fmt.Errorf("L2SentMsg.GetLatestL2SentMsgLEHeight error: %w", err)
+
+	}
+	return &result, nil
+}
+
+// InsertL2SentMsg batch insert l2 sent msg
+func (l *L2SentMsg) InsertL2SentMsg(ctx context.Context, messages []*L2SentMsg, dbTx ...*gorm.DB) error {
+	if len(messages) == 0 {
+		return nil
+	}
+	db := l.db
+	if len(dbTx) > 0 && dbTx[0] != nil {
+		db = dbTx[0]
+	}
+	db.WithContext(ctx)
+	err := db.Model(&L2SentMsg{}).Create(&messages).Error
+	if err != nil {
+		l2hashes := make([]string, 0, len(messages))
+		heights := make([]uint64, 0, len(messages))
+		for _, msg := range messages {
+			l2hashes = append(l2hashes, msg.TxHash)
+			heights = append(heights, msg.Height)
+		}
+		log.Error("failed to insert l2 sent messages", "l2hashes", l2hashes, "heights", heights, "err", err)
+		return fmt.Errorf("L2SentMsg.InsertL2SentMsg error: %w", err)
+	}
+	return nil
+}
+
+// UpdateL2MessageProof update l2 message proof in db tx
+func (l *L2SentMsg) UpdateL2MessageProof(ctx context.Context, msgHash string, proof string, batchIndex uint64, dbTx ...*gorm.DB) error {
+	db := l.db
+	if len(dbTx) > 0 && dbTx[0] != nil {
+		db = dbTx[0]
+	}
+	db.WithContext(ctx)
+	err := db.Model(&L2SentMsg{}).
+		Where("msg_hash = ?", msgHash).
+		Updates(map[string]interface{}{
+			"msg_proof":   proof,
+			"batch_index": batchIndex,
+		}).Error
+	if err != nil {
+		return fmt.Errorf("L2SentMsg.UpdateL2MessageProof error: %w", err)
+	}
+	return nil
+}
+
+// DeleteL2SentMsgAfterHeight delete l2 sent msg after height
+func (l *L2SentMsg) DeleteL2SentMsgAfterHeight(ctx context.Context, height uint64, dbTx ...*gorm.DB) error {
+	db := l.db
+	if len(dbTx) > 0 && dbTx[0] != nil {
+		db = dbTx[0]
+	}
+	err := db.WithContext(ctx).Model(&L2SentMsg{}).Delete("height > ?", height).Error
+	if err != nil {
+		return fmt.Errorf("L2SentMsg.DeleteL2SentMsgAfterHeight error: %w", err)
+	}
+	return nil
+}

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

@@ -8,6 +8,7 @@ create table rollup_batch
     start_block_number  BIGINT NOT NULL,
     end_block_number    BIGINT NOT NULL,
     batch_hash          VARCHAR NOT NULL,
+    withdraw_root       TEXT 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

bridge-history-api/orm/relayed_msg.go

@@ -0,0 +1,142 @@
+package orm
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/ethereum/go-ethereum/log"
+	"gorm.io/gorm"
+)
+
+// RelayedMsg is the struct for relayed_msg table
+type RelayedMsg struct {
+	db *gorm.DB `gorm:"column:-"`
+
+	ID         uint64         `json:"id" gorm:"column:id"`
+	MsgHash    string         `json:"msg_hash" gorm:"column:msg_hash"`
+	Height     uint64         `json:"height" gorm:"column:height"`
+	Layer1Hash string         `json:"layer1_hash" gorm:"column:layer1_hash;default:''"`
+	Layer2Hash string         `json:"layer2_hash" gorm:"column:layer2_hash;default:''"`
+	CreatedAt  *time.Time     `json:"created_at" gorm:"column:created_at"`
+	UpdatedAt  *time.Time     `json:"updated_at" gorm:"column:updated_at"`
+	DeletedAt  gorm.DeletedAt `json:"deleted_at" gorm:"column:deleted_at;default:NULL"`
+}
+
+// NewRelayedMsg create an NewRelayedMsg instance
+func NewRelayedMsg(db *gorm.DB) *RelayedMsg {
+	return &RelayedMsg{db: db}
+}
+
+// TableName returns the table name for the RelayedMsg model.
+func (*RelayedMsg) TableName() string {
+	return "relayed_msg"
+}
+
+// GetRelayedMsgByHash get relayed msg by hash
+func (r *RelayedMsg) GetRelayedMsgByHash(ctx context.Context, msgHash string) (*RelayedMsg, error) {
+	var result RelayedMsg
+	err := r.db.WithContext(ctx).Model(&RelayedMsg{}).
+		Where("msg_hash = ?", msgHash).
+		First(&result).
+		Error
+	if err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return nil, nil
+		}
+		return nil, fmt.Errorf("RelayedMsg.GetRelayedMsgByHash error: %w", err)
+	}
+	return &result, nil
+}
+
+// GetLatestRelayedHeightOnL1 get latest relayed height on l1
+func (r *RelayedMsg) GetLatestRelayedHeightOnL1(ctx context.Context) (uint64, error) {
+	var result RelayedMsg
+	err := r.db.WithContext(ctx).Model(&RelayedMsg{}).
+		Select("height").
+		Where("layer1_hash != ''").
+		Order("height DESC").
+		First(&result).
+		Error
+	if err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return 0, nil
+		}
+		return 0, fmt.Errorf("RelayedMsg.GetLatestRelayedHeightOnL1 error: %w", err)
+	}
+	return result.Height, err
+}
+
+// GetLatestRelayedHeightOnL2 get latest relayed height on l2
+func (r *RelayedMsg) GetLatestRelayedHeightOnL2(ctx context.Context) (uint64, error) {
+	var result RelayedMsg
+	err := r.db.WithContext(ctx).Model(&RelayedMsg{}).
+		Select("height").
+		Where("layer2_hash != ''").
+		Order("height DESC").
+		First(&result).
+		Error
+	if err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return 0, nil
+		}
+		return 0, fmt.Errorf("RelayedMsg.GetLatestRelayedHeightOnL2 error: %w", err)
+	}
+	return result.Height, nil
+}
+
+// InsertRelayedMsg batch insert relayed msg into db and return the transaction
+func (r *RelayedMsg) InsertRelayedMsg(ctx context.Context, messages []*RelayedMsg, dbTx ...*gorm.DB) error {
+	if len(messages) == 0 {
+		return nil
+	}
+	db := r.db
+	if len(dbTx) > 0 && dbTx[0] != nil {
+		db = dbTx[0]
+	}
+	db.WithContext(ctx)
+	err := db.Model(&RelayedMsg{}).Create(&messages).Error
+	if err != nil {
+		l2hashes := make([]string, 0, len(messages))
+		l1hashes := make([]string, 0, len(messages))
+		heights := make([]uint64, 0, len(messages))
+		for _, msg := range messages {
+			l2hashes = append(l2hashes, msg.Layer2Hash)
+			l1hashes = append(l1hashes, msg.Layer1Hash)
+			heights = append(heights, msg.Height)
+		}
+		log.Error("failed to insert l2 sent messages", "l2hashes", l2hashes, "l1hashes", l1hashes, "heights", heights, "err", err)
+		return fmt.Errorf("RelayedMsg.InsertRelayedMsg error: %w", err)
+	}
+	return nil
+}
+
+// DeleteL1RelayedHashAfterHeight delete l1 relayed hash after height
+func (r *RelayedMsg) DeleteL1RelayedHashAfterHeight(ctx context.Context, height uint64, dbTx ...*gorm.DB) error {
+	db := r.db
+	if len(dbTx) > 0 && dbTx[0] != nil {
+		db = dbTx[0]
+	}
+	db.WithContext(ctx)
+	err := db.Model(&RelayedMsg{}).
+		Delete("height > ? AND layer1_hash != ''", height).Error
+	if err != nil {
+		return fmt.Errorf("RelayedMsg.DeleteL1RelayedHashAfterHeight error: %w", err)
+	}
+	return nil
+}
+
+// DeleteL2RelayedHashAfterHeight delete l2 relayed hash after heights
+func (r *RelayedMsg) DeleteL2RelayedHashAfterHeight(ctx context.Context, height uint64, dbTx ...*gorm.DB) error {
+	db := r.db
+	if len(dbTx) > 0 && dbTx[0] != nil {
+		db = dbTx[0]
+	}
+	db.WithContext(ctx)
+	err := db.Model(&RelayedMsg{}).
+		Delete("height > ? AND layer2_hash != ''", height).Error
+	if err != nil {
+		return fmt.Errorf("RelayedMsg.DeleteL2RelayedHashAfterHeight error: %w", err)
+	}
+	return nil
+}

bridge-history-api/service/service.go

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

bridge-history-api/utils/database.go

@@ -0,0 +1,115 @@
+package utils
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"time"
+
+	"github.com/ethereum/go-ethereum/log"
+	"gorm.io/driver/postgres"
+	"gorm.io/gorm"
+	"gorm.io/gorm/logger"
+	"gorm.io/gorm/utils"
+
+	"bridge-history-api/config"
+)
+
+type gormLogger struct {
+	gethLogger log.Logger
+}
+
+func (g *gormLogger) LogMode(level logger.LogLevel) logger.Interface {
+	return g
+}
+
+func (g *gormLogger) Info(_ context.Context, msg string, data ...interface{}) {
+	infoMsg := fmt.Sprintf(msg, data...)
+	g.gethLogger.Info("gorm", "info message", infoMsg)
+}
+
+func (g *gormLogger) Warn(_ context.Context, msg string, data ...interface{}) {
+	warnMsg := fmt.Sprintf(msg, data...)
+	g.gethLogger.Warn("gorm", "warn message", warnMsg)
+}
+
+func (g *gormLogger) Error(_ context.Context, msg string, data ...interface{}) {
+	errMsg := fmt.Sprintf(msg, data...)
+	g.gethLogger.Error("gorm", "err message", errMsg)
+}
+
+func (g *gormLogger) Trace(_ context.Context, begin time.Time, fc func() (string, int64), err error) {
+	elapsed := time.Since(begin)
+	sql, rowsAffected := fc()
+	g.gethLogger.Debug("gorm", "line", utils.FileWithLineNum(), "cost", elapsed, "sql", sql, "rowsAffected", rowsAffected, "err", err)
+}
+
+// InitDB init the db handler
+func InitDB(config *config.DBConfig) (*gorm.DB, error) {
+	tmpGormLogger := gormLogger{
+		gethLogger: log.Root(),
+	}
+
+	db, err := gorm.Open(postgres.Open(config.DSN), &gorm.Config{
+		Logger: &tmpGormLogger,
+		NowFunc: func() time.Time {
+			// why set time to UTC.
+			// if now set this, the inserted data time will use local timezone. like 2023-07-18 18:24:00 CST+8
+			// but when inserted, store to postgres is 2023-07-18 18:24:00 UTC+0 the timezone is incorrect.
+			// As mysql dsn user:pass@tcp(127.0.0.1:3306)/dbname?charset=utf8mb4&parseTime=True&loc=Local, we cant set
+			// the timezone by loc=Local. but postgres's dsn don't have loc option to set timezone, so just need set the gorm option like that.
+			t, err := nowUTC()
+			if err != nil {
+				log.Error("Can not get UTC time: ", "err", err)
+			}
+			return t
+		},
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	sqlDB, pingErr := Ping(db)
+	if pingErr != nil {
+		return nil, pingErr
+	}
+
+	sqlDB.SetMaxOpenConns(config.MaxOpenNum)
+	sqlDB.SetMaxIdleConns(config.MaxIdleNum)
+
+	return db, nil
+}
+
+// Ping check db status
+func Ping(db *gorm.DB) (*sql.DB, error) {
+	sqlDB, err := db.DB()
+	if err != nil {
+		return nil, err
+	}
+
+	if err = sqlDB.Ping(); err != nil {
+		return nil, err
+	}
+	return sqlDB, nil
+}
+
+// CloseDB close the db handler. notice the db handler only can close when then program exit.
+func CloseDB(db *gorm.DB) error {
+	sqlDB, err := db.DB()
+	if err != nil {
+		return err
+	}
+	if err := sqlDB.Close(); err != nil {
+		return err
+	}
+	return nil
+}
+
+// nowUTC get the utc time.Now
+func nowUTC() (time.Time, error) {
+	utc, err := time.LoadLocation("")
+	if err != nil {
+		return time.Time{}, err
+	}
+	return time.Now().In(utc), nil
+}

bridge-history-api/utils/parse_event.go

@@ -11,7 +11,7 @@ import (
 	"github.com/ethereum/go-ethereum/log"
 
 	backendabi "bridge-history-api/abi"
-	"bridge-history-api/db/orm"
+	"bridge-history-api/orm"
 )
 
 // CachedParsedTxCalldata store parsed batch infos
@@ -46,6 +46,7 @@ func ParseBackendL1EventLogs(logs []types.Log) ([]*orm.CrossMsg, []*orm.RelayedM
 				Amount:     event.Amount.String(),
 				Asset:      int(orm.ETH),
 				Layer1Hash: vlog.TxHash.Hex(),
+				MsgType:    int(orm.Layer1Msg),
 				MsgHash:    msgHash,
 			})
 		case backendabi.L1DepositERC20Sig:
@@ -64,6 +65,7 @@ func ParseBackendL1EventLogs(logs []types.Log) ([]*orm.CrossMsg, []*orm.RelayedM
 				Layer1Hash:  vlog.TxHash.Hex(),
 				Layer1Token: event.L1Token.Hex(),
 				Layer2Token: event.L2Token.Hex(),
+				MsgType:     int(orm.Layer1Msg),
 				MsgHash:     msgHash,
 			})
 		case backendabi.L1DepositERC721Sig:
@@ -82,6 +84,7 @@ func ParseBackendL1EventLogs(logs []types.Log) ([]*orm.CrossMsg, []*orm.RelayedM
 				Layer1Token: event.L1Token.Hex(),
 				Layer2Token: event.L2Token.Hex(),
 				TokenIDs:    event.TokenID.String(),
+				MsgType:     int(orm.Layer1Msg),
 				MsgHash:     msgHash,
 			})
 		case backendabi.L1DepositERC1155Sig:
@@ -101,6 +104,7 @@ func ParseBackendL1EventLogs(logs []types.Log) ([]*orm.CrossMsg, []*orm.RelayedM
 				Layer2Token: event.L2Token.Hex(),
 				TokenIDs:    event.TokenID.String(),
 				Amount:      event.Amount.String(),
+				MsgType:     int(orm.Layer1Msg),
 				MsgHash:     msgHash,
 			})
 		case backendabi.L1SentMessageEventSignature:
@@ -128,6 +132,7 @@ func ParseBackendL1EventLogs(logs []types.Log) ([]*orm.CrossMsg, []*orm.RelayedM
 				Layer1Token: event.L1Token.Hex(),
 				Layer2Token: event.L2Token.Hex(),
 				TokenIDs:    convertBigIntArrayToString(event.TokenIDs),
+				MsgType:     int(orm.Layer1Msg),
 				MsgHash:     msgHash,
 			})
 		case backendabi.L1BatchDepositERC1155Sig:
@@ -147,6 +152,7 @@ func ParseBackendL1EventLogs(logs []types.Log) ([]*orm.CrossMsg, []*orm.RelayedM
 				Layer2Token:  event.L2Token.Hex(),
 				TokenIDs:     convertBigIntArrayToString(event.TokenIDs),
 				TokenAmounts: convertBigIntArrayToString(event.TokenAmounts),
+				MsgType:      int(orm.Layer1Msg),
 				MsgHash:      msgHash,
 			})
 		case backendabi.L1RelayedMessageEventSignature:
@@ -194,6 +200,7 @@ func ParseBackendL2EventLogs(logs []types.Log) ([]*orm.CrossMsg, []*orm.RelayedM
 				Amount:     event.Amount.String(),
 				Asset:      int(orm.ETH),
 				Layer2Hash: vlog.TxHash.Hex(),
+				MsgType:    int(orm.Layer2Msg),
 				MsgHash:    l2SentMsgs[len(l2SentMsgs)-1].MsgHash,
 			})
 		case backendabi.L2WithdrawERC20Sig:
@@ -213,6 +220,7 @@ func ParseBackendL2EventLogs(logs []types.Log) ([]*orm.CrossMsg, []*orm.RelayedM
 				Layer2Hash:  vlog.TxHash.Hex(),
 				Layer1Token: event.L1Token.Hex(),
 				Layer2Token: event.L2Token.Hex(),
+				MsgType:     int(orm.Layer2Msg),
 				MsgHash:     l2SentMsgs[len(l2SentMsgs)-1].MsgHash,
 			})
 		case backendabi.L2WithdrawERC721Sig:
@@ -232,6 +240,7 @@ func ParseBackendL2EventLogs(logs []types.Log) ([]*orm.CrossMsg, []*orm.RelayedM
 				Layer1Token: event.L1Token.Hex(),
 				Layer2Token: event.L2Token.Hex(),
 				TokenIDs:    event.TokenID.String(),
+				MsgType:     int(orm.Layer2Msg),
 				MsgHash:     l2SentMsgs[len(l2SentMsgs)-1].MsgHash,
 			})
 		case backendabi.L2WithdrawERC1155Sig:
@@ -252,6 +261,7 @@ func ParseBackendL2EventLogs(logs []types.Log) ([]*orm.CrossMsg, []*orm.RelayedM
 				Layer2Token: event.L2Token.Hex(),
 				TokenIDs:    event.TokenID.String(),
 				Amount:      event.Amount.String(),
+				MsgType:     int(orm.Layer2Msg),
 				MsgHash:     l2SentMsgs[len(l2SentMsgs)-1].MsgHash,
 			})
 		case backendabi.L2BatchWithdrawERC721Sig:
@@ -270,6 +280,7 @@ func ParseBackendL2EventLogs(logs []types.Log) ([]*orm.CrossMsg, []*orm.RelayedM
 				Layer1Hash:  vlog.TxHash.Hex(),
 				Layer1Token: event.L1Token.Hex(),
 				Layer2Token: event.L2Token.Hex(),
+				MsgType:     int(orm.Layer2Msg),
 				TokenIDs:    convertBigIntArrayToString(event.TokenIDs),
 				MsgHash:     l2SentMsgs[len(l2SentMsgs)-1].MsgHash,
 			})
@@ -289,6 +300,7 @@ func ParseBackendL2EventLogs(logs []types.Log) ([]*orm.CrossMsg, []*orm.RelayedM
 				Layer1Hash:   vlog.TxHash.Hex(),
 				Layer1Token:  event.L1Token.Hex(),
 				Layer2Token:  event.L2Token.Hex(),
+				MsgType:      int(orm.Layer2Msg),
 				TokenIDs:     convertBigIntArrayToString(event.TokenIDs),
 				TokenAmounts: convertBigIntArrayToString(event.TokenAmounts),
 				MsgHash:      l2SentMsgs[len(l2SentMsgs)-1].MsgHash,
@@ -334,7 +346,6 @@ func ParseBackendL2EventLogs(logs []types.Log) ([]*orm.CrossMsg, []*orm.RelayedM
 // ParseBatchInfoFromScrollChain parses ScrollChain events
 func ParseBatchInfoFromScrollChain(ctx context.Context, client *ethclient.Client, logs []types.Log) ([]*orm.RollupBatch, error) {
 	var rollupBatches []*orm.RollupBatch
-	cache := make(map[string]CachedParsedTxCalldata)
 	for _, vlog := range logs {
 		switch vlog.Topics[0] {
 		case backendabi.L1CommitBatchEventSignature:
@@ -344,42 +355,22 @@ func ParseBatchInfoFromScrollChain(ctx context.Context, client *ethclient.Client
 				log.Warn("Failed to unpack CommitBatch event", "err", err)
 				return rollupBatches, err
 			}
-			if _, ok := cache[vlog.TxHash.Hex()]; ok {
-				c := cache[vlog.TxHash.Hex()]
-				c.CallDataIndex++
-				rollupBatches = append(rollupBatches, &orm.RollupBatch{
-					CommitHeight:     vlog.BlockNumber,
-					BatchIndex:       c.BatchIndices[c.CallDataIndex],
-					BatchHash:        event.BatchHash.Hex(),
-					StartBlockNumber: c.StartBlocks[c.CallDataIndex],
-					EndBlockNumber:   c.EndBlocks[c.CallDataIndex],
-				})
-				cache[vlog.TxHash.Hex()] = c
-				continue
-			}
-
 			commitTx, isPending, err := client.TransactionByHash(ctx, vlog.TxHash)
 			if err != nil || isPending {
 				log.Warn("Failed to get commit Batch tx receipt or the tx is still pending", "err", err)
 				return rollupBatches, err
 			}
-			indices, startBlocks, endBlocks, err := GetBatchRangeFromCalldataV1(commitTx.Data())
+			index, startBlock, endBlock, err := GetBatchRangeFromCalldataV2(commitTx.Data())
 			if err != nil {
 				log.Warn("Failed to get batch range from calldata", "hash", commitTx.Hash().Hex(), "height", vlog.BlockNumber)
 				return rollupBatches, err
 			}
-			cache[vlog.TxHash.Hex()] = CachedParsedTxCalldata{
-				CallDataIndex: 0,
-				BatchIndices:  indices,
-				StartBlocks:   startBlocks,
-				EndBlocks:     endBlocks,
-			}
 			rollupBatches = append(rollupBatches, &orm.RollupBatch{
 				CommitHeight:     vlog.BlockNumber,
-				BatchIndex:       indices[0],
+				BatchIndex:       index,
 				BatchHash:        event.BatchHash.Hex(),
-				StartBlockNumber: startBlocks[0],
-				EndBlockNumber:   endBlocks[0],
+				StartBlockNumber: startBlock,
+				EndBlockNumber:   endBlock,
 			})
 
 		default:

bridge-history-api/utils/utils.go

@@ -1,7 +1,6 @@
 package utils
 
 import (
-	"bytes"
 	"context"
 	"encoding/binary"
 	"errors"
@@ -76,6 +75,14 @@ func GetBatchRangeFromCalldataV2(calldata []byte) (uint64, uint64, uint64, error
 	method := backendabi.ScrollChainV2ABI.Methods["commitBatch"]
 	values, err := method.Inputs.Unpack(calldata[4:])
 	if err != nil {
+		// special case: import genesis batch
+		method = backendabi.ScrollChainV2ABI.Methods["importGenesisBatch"]
+		_, err2 := method.Inputs.Unpack(calldata[4:])
+		if err2 == nil {
+			// genesis batch
+			return 0, 0, 0, nil
+		}
+		// none of "commitBatch" and "importGenesisBatch" match, give up
 		return 0, 0, 0, err
 	}
 	args := commitBatchArgs{}
@@ -110,48 +117,3 @@ func GetBatchRangeFromCalldataV2(calldata []byte) (uint64, uint64, uint64, error
 
 	return batchIndex, startBlock, finishBlock, err
 }
-
-// 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,7 +1,6 @@
 package utils_test
 
 import (
-	"os"
 	"testing"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -34,31 +33,11 @@ func TestGetBatchRangeFromCalldataV2(t *testing.T) {
 	assert.Equal(t, start, uint64(10))
 	assert.Equal(t, finish, uint64(20))
 	assert.Equal(t, batchIndex, uint64(2))
-}
 
-func TestGetBatchRangeFromCalldataV1(t *testing.T) {
-	calldata, err := os.ReadFile("../testdata/commit-batches-0x3095e91db7ba4a6fbf4654d607db322e58ff5579c502219c8024acaea74cf311.txt")
+	// genesis batch
+	batchIndex, start, finish, err = utils.GetBatchRangeFromCalldataV2(common.Hex2Bytes("3fdeecb200000000000000000000000000000000000000000000000000000000000000402dcb5308098d24a37fc1487a229fcedb09fa4343ede39cbad365bc925535bb09000000000000000000000000000000000000000000000000000000000000005900000000000000000000000000000000000000000000000000c252bc9780c4d83cf11f14b8cd03c92c4d18ce07710ba836d31d12da216c8330000000000000000000000000000000000000000000000000000000000000000000000000000000"))
 	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))
+	assert.Equal(t, start, uint64(0))
+	assert.Equal(t, finish, uint64(0))
+	assert.Equal(t, batchIndex, uint64(0))
 }

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/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/msg_relayer/app/app.go

@@ -1,93 +0,0 @@
-package app
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"os/signal"
-	"time"
-
-	"github.com/scroll-tech/go-ethereum/log"
-	"github.com/urfave/cli/v2"
-
-	"scroll-tech/common/database"
-	"scroll-tech/common/metrics"
-	"scroll-tech/common/utils"
-	"scroll-tech/common/version"
-
-	"scroll-tech/bridge/internal/config"
-	"scroll-tech/bridge/internal/controller/relayer"
-)
-
-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, utils.CommonFlags...)
-	app.Commands = []*cli.Command{}
-	app.Before = func(ctx *cli.Context) error {
-		return utils.LogSetup(ctx)
-	}
-	// Register `message-relayer-test` app for integration-test.
-	utils.RegisterSimulation(app, utils.MessageRelayerApp)
-}
-
-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)
-	}
-
-	subCtx, cancel := context.WithCancel(ctx.Context)
-	// Init db connection
-	db, err := database.InitDB(cfg.DBConfig)
-	if err != nil {
-		log.Crit("failed to init db connection", "err", err)
-	}
-	defer func() {
-		cancel()
-		if err = database.CloseDB(db); err != nil {
-			log.Error("can not close ormFactory", "error", err)
-		}
-	}()
-
-	// Start metrics server.
-	metrics.Serve(subCtx, ctx)
-
-	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
-	}
-
-	// Start l1relayer process
-	go utils.Loop(subCtx, 10*time.Second, l1relayer.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/main.go

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

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)
-}

bridge/internal/controller/sender/account_pool.go

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

bridge/internal/controller/watcher/batch_proposer.go

@@ -1,171 +0,0 @@
-package watcher
-
-import (
-	"context"
-	"fmt"
-	"time"
-
-	"github.com/scroll-tech/go-ethereum/log"
-	"gorm.io/gorm"
-
-	"scroll-tech/common/types"
-
-	"scroll-tech/bridge/internal/config"
-	"scroll-tech/bridge/internal/orm"
-)
-
-// BatchProposer proposes batches based on available unbatched chunks.
-type BatchProposer struct {
-	ctx context.Context
-	db  *gorm.DB
-
-	batchOrm   *orm.Batch
-	chunkOrm   *orm.Chunk
-	l2BlockOrm *orm.L2Block
-
-	maxChunkNumPerBatch             uint64
-	maxL1CommitGasPerBatch          uint64
-	maxL1CommitCalldataSizePerBatch uint32
-	minChunkNumPerBatch             uint64
-	batchTimeoutSec                 uint64
-}
-
-// NewBatchProposer creates a new BatchProposer instance.
-func NewBatchProposer(ctx context.Context, cfg *config.BatchProposerConfig, db *gorm.DB) *BatchProposer {
-	return &BatchProposer{
-		ctx:                             ctx,
-		db:                              db,
-		batchOrm:                        orm.NewBatch(db),
-		chunkOrm:                        orm.NewChunk(db),
-		l2BlockOrm:                      orm.NewL2Block(db),
-		maxChunkNumPerBatch:             cfg.MaxChunkNumPerBatch,
-		maxL1CommitGasPerBatch:          cfg.MaxL1CommitGasPerBatch,
-		maxL1CommitCalldataSizePerBatch: cfg.MaxL1CommitCalldataSizePerBatch,
-		minChunkNumPerBatch:             cfg.MinChunkNumPerBatch,
-		batchTimeoutSec:                 cfg.BatchTimeoutSec,
-	}
-}
-
-// TryProposeBatch tries to propose a new batches.
-func (p *BatchProposer) TryProposeBatch() {
-	dbChunks, err := p.proposeBatchChunks()
-	if err != nil {
-		log.Error("proposeBatchChunks failed", "err", err)
-		return
-	}
-	if err := p.updateBatchInfoInDB(dbChunks); err != nil {
-		log.Error("update batch info in db failed", "err", err)
-	}
-}
-
-func (p *BatchProposer) updateBatchInfoInDB(dbChunks []*orm.Chunk) error {
-	numChunks := len(dbChunks)
-	if numChunks <= 0 {
-		return nil
-	}
-	chunks, err := p.dbChunksToBridgeChunks(dbChunks)
-	if err != nil {
-		return err
-	}
-
-	startChunkIndex := dbChunks[0].Index
-	startChunkHash := dbChunks[0].Hash
-	endChunkIndex := dbChunks[numChunks-1].Index
-	endChunkHash := dbChunks[numChunks-1].Hash
-	err = p.db.Transaction(func(dbTX *gorm.DB) error {
-		batch, dbErr := p.batchOrm.InsertBatch(p.ctx, startChunkIndex, endChunkIndex, startChunkHash, endChunkHash, chunks, dbTX)
-		if dbErr != nil {
-			return dbErr
-		}
-		dbErr = p.chunkOrm.UpdateBatchHashInRange(p.ctx, startChunkIndex, endChunkIndex, batch.Hash, dbTX)
-		if dbErr != nil {
-			return dbErr
-		}
-		return nil
-	})
-	return err
-}
-
-func (p *BatchProposer) proposeBatchChunks() ([]*orm.Chunk, error) {
-	dbChunks, err := p.chunkOrm.GetUnbatchedChunks(p.ctx)
-	if err != nil {
-		return nil, err
-	}
-
-	if len(dbChunks) == 0 {
-		return nil, nil
-	}
-
-	firstChunk := dbChunks[0]
-	totalL1CommitCalldataSize := firstChunk.TotalL1CommitCalldataSize
-	totalL1CommitGas := firstChunk.TotalL1CommitGas
-	var totalChunks uint64 = 1
-
-	// Check if the first chunk breaks hard limits.
-	// If so, it indicates there are bugs in chunk-proposer, manual fix is needed.
-	if totalL1CommitGas > p.maxL1CommitGasPerBatch {
-		return nil, fmt.Errorf(
-			"the first chunk exceeds l1 commit gas limit; start block number: %v, end block number: %v, commit gas: %v, max commit gas limit: %v",
-			firstChunk.StartBlockNumber,
-			firstChunk.EndBlockNumber,
-			totalL1CommitGas,
-			p.maxL1CommitGasPerBatch,
-		)
-	}
-
-	if totalL1CommitCalldataSize > p.maxL1CommitCalldataSizePerBatch {
-		return nil, fmt.Errorf(
-			"the first chunk exceeds l1 commit calldata size limit; start block number: %v, end block number %v, calldata size: %v, max calldata size limit: %v",
-			firstChunk.StartBlockNumber,
-			firstChunk.EndBlockNumber,
-			totalL1CommitCalldataSize,
-			p.maxL1CommitCalldataSizePerBatch,
-		)
-	}
-
-	for i, chunk := range dbChunks[1:] {
-		totalChunks++
-		totalL1CommitCalldataSize += chunk.TotalL1CommitCalldataSize
-		totalL1CommitGas += chunk.TotalL1CommitGas
-		if totalChunks > p.maxChunkNumPerBatch ||
-			totalL1CommitCalldataSize > p.maxL1CommitCalldataSizePerBatch ||
-			totalL1CommitGas > p.maxL1CommitGasPerBatch {
-			return dbChunks[:i+1], nil
-		}
-	}
-
-	var hasChunkTimeout bool
-	currentTimeSec := uint64(time.Now().Unix())
-	if dbChunks[0].StartBlockTime+p.batchTimeoutSec < currentTimeSec {
-		log.Warn("first block timeout",
-			"start block number", dbChunks[0].StartBlockNumber,
-			"first block timestamp", dbChunks[0].StartBlockTime,
-			"chunk outdated time threshold", currentTimeSec,
-		)
-		hasChunkTimeout = true
-	}
-
-	if !hasChunkTimeout && uint64(len(dbChunks)) < p.minChunkNumPerBatch {
-		log.Warn("The chunk number of the batch is less than the minimum limit",
-			"chunk num", len(dbChunks), "minChunkNumPerBatch", p.minChunkNumPerBatch,
-		)
-		return nil, nil
-	}
-	return dbChunks, nil
-}
-
-func (p *BatchProposer) dbChunksToBridgeChunks(dbChunks []*orm.Chunk) ([]*types.Chunk, error) {
-	chunks := make([]*types.Chunk, len(dbChunks))
-	for i, c := range dbChunks {
-		wrappedBlocks, err := p.l2BlockOrm.GetL2BlocksInRange(p.ctx, c.StartBlockNumber, c.EndBlockNumber)
-		if err != nil {
-			log.Error("Failed to fetch wrapped blocks",
-				"start number", c.StartBlockNumber, "end number", c.EndBlockNumber, "error", err)
-			return nil, err
-		}
-		chunks[i] = &types.Chunk{
-			Blocks: wrappedBlocks,
-		}
-	}
-	return chunks, nil
-}

bridge/internal/controller/watcher/batch_proposer_test.go

@@ -1,71 +0,0 @@
-package watcher
-
-import (
-	"context"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-
-	"scroll-tech/common/database"
-	"scroll-tech/common/types"
-
-	"scroll-tech/bridge/internal/config"
-	"scroll-tech/bridge/internal/orm"
-)
-
-// TODO: Add unit tests that the limits are enforced correctly.
-func testBatchProposer(t *testing.T) {
-	db := setupDB(t)
-	defer database.CloseDB(db)
-
-	l2BlockOrm := orm.NewL2Block(db)
-	err := l2BlockOrm.InsertL2Blocks(context.Background(), []*types.WrappedBlock{wrappedBlock1, wrappedBlock2})
-	assert.NoError(t, err)
-
-	cp := NewChunkProposer(context.Background(), &config.ChunkProposerConfig{
-		MaxTxGasPerChunk:                1000000000,
-		MaxL2TxNumPerChunk:              10000,
-		MaxL1CommitGasPerChunk:          50000000000,
-		MaxL1CommitCalldataSizePerChunk: 1000000,
-		MinL1CommitCalldataSizePerChunk: 0,
-		ChunkTimeoutSec:                 300,
-	}, db)
-	cp.TryProposeChunk()
-
-	bp := NewBatchProposer(context.Background(), &config.BatchProposerConfig{
-		MaxChunkNumPerBatch:             10,
-		MaxL1CommitGasPerBatch:          50000000000,
-		MaxL1CommitCalldataSizePerBatch: 1000000,
-		MinChunkNumPerBatch:             1,
-		BatchTimeoutSec:                 300,
-	}, db)
-	bp.TryProposeBatch()
-
-	chunkOrm := orm.NewChunk(db)
-	chunks, err := chunkOrm.GetUnbatchedChunks(context.Background())
-	assert.NoError(t, err)
-	assert.Empty(t, chunks)
-
-	batchOrm := orm.NewBatch(db)
-	// get all batches.
-	batches, err := batchOrm.GetBatches(context.Background(), map[string]interface{}{}, []string{}, 0)
-	assert.NoError(t, err)
-	assert.Len(t, batches, 1)
-	assert.Equal(t, uint64(0), batches[0].StartChunkIndex)
-	assert.Equal(t, uint64(0), batches[0].EndChunkIndex)
-	assert.Equal(t, types.RollupPending, types.RollupStatus(batches[0].RollupStatus))
-	assert.Equal(t, types.ProvingTaskUnassigned, types.ProvingStatus(batches[0].ProvingStatus))
-
-	dbChunks, err := chunkOrm.GetChunksInRange(context.Background(), 0, 0)
-	assert.NoError(t, err)
-	assert.Len(t, batches, 1)
-	assert.Equal(t, batches[0].Hash, dbChunks[0].BatchHash)
-	assert.Equal(t, types.ProvingTaskUnassigned, types.ProvingStatus(dbChunks[0].ProvingStatus))
-
-	blockOrm := orm.NewL2Block(db)
-	blocks, err := blockOrm.GetL2Blocks(context.Background(), map[string]interface{}{}, []string{}, 0)
-	assert.NoError(t, err)
-	assert.Len(t, blocks, 2)
-	assert.Equal(t, dbChunks[0].Hash, blocks[0].ChunkHash)
-	assert.Equal(t, dbChunks[0].Hash, blocks[1].ChunkHash)
-}

bridge/internal/controller/watcher/chunk_proposer.go

@@ -1,169 +0,0 @@
-package watcher
-
-import (
-	"context"
-	"fmt"
-	"time"
-
-	"github.com/scroll-tech/go-ethereum/log"
-	"gorm.io/gorm"
-
-	"scroll-tech/common/types"
-
-	"scroll-tech/bridge/internal/config"
-	"scroll-tech/bridge/internal/orm"
-)
-
-// ChunkProposer proposes chunks based on available unchunked blocks.
-type ChunkProposer struct {
-	ctx context.Context
-	db  *gorm.DB
-
-	chunkOrm   *orm.Chunk
-	l2BlockOrm *orm.L2Block
-
-	maxTxGasPerChunk                uint64
-	maxL2TxNumPerChunk              uint64
-	maxL1CommitGasPerChunk          uint64
-	maxL1CommitCalldataSizePerChunk uint64
-	minL1CommitCalldataSizePerChunk uint64
-	chunkTimeoutSec                 uint64
-}
-
-// NewChunkProposer creates a new ChunkProposer instance.
-func NewChunkProposer(ctx context.Context, cfg *config.ChunkProposerConfig, db *gorm.DB) *ChunkProposer {
-	return &ChunkProposer{
-		ctx:                             ctx,
-		db:                              db,
-		chunkOrm:                        orm.NewChunk(db),
-		l2BlockOrm:                      orm.NewL2Block(db),
-		maxTxGasPerChunk:                cfg.MaxTxGasPerChunk,
-		maxL2TxNumPerChunk:              cfg.MaxL2TxNumPerChunk,
-		maxL1CommitGasPerChunk:          cfg.MaxL1CommitGasPerChunk,
-		maxL1CommitCalldataSizePerChunk: cfg.MaxL1CommitCalldataSizePerChunk,
-		minL1CommitCalldataSizePerChunk: cfg.MinL1CommitCalldataSizePerChunk,
-		chunkTimeoutSec:                 cfg.ChunkTimeoutSec,
-	}
-}
-
-// TryProposeChunk tries to propose a new chunk.
-func (p *ChunkProposer) TryProposeChunk() {
-	proposedChunk, err := p.proposeChunk()
-	if err != nil {
-		log.Error("propose new chunk failed", "err", err)
-		return
-	}
-
-	if err := p.updateChunkInfoInDB(proposedChunk); err != nil {
-		log.Error("update chunk info in orm failed", "err", err)
-	}
-}
-
-func (p *ChunkProposer) updateChunkInfoInDB(chunk *types.Chunk) error {
-	if chunk == nil {
-		return nil
-	}
-
-	err := p.db.Transaction(func(dbTX *gorm.DB) error {
-		dbChunk, err := p.chunkOrm.InsertChunk(p.ctx, chunk, dbTX)
-		if err != nil {
-			return err
-		}
-		if err := p.l2BlockOrm.UpdateChunkHashInRange(p.ctx, dbChunk.StartBlockNumber, dbChunk.EndBlockNumber, dbChunk.Hash, dbTX); err != nil {
-			log.Error("failed to update chunk_hash for l2_blocks", "chunk hash", chunk.Hash, "start block", 0, "end block", 0, "err", err)
-			return err
-		}
-		return nil
-	})
-	return err
-}
-
-func (p *ChunkProposer) proposeChunk() (*types.Chunk, error) {
-	blocks, err := p.l2BlockOrm.GetUnchunkedBlocks(p.ctx)
-	if err != nil {
-		return nil, err
-	}
-
-	if len(blocks) == 0 {
-		return nil, nil
-	}
-
-	firstBlock := blocks[0]
-	totalTxGasUsed := firstBlock.Header.GasUsed
-	totalL2TxNum := firstBlock.L2TxsNum()
-	totalL1CommitCalldataSize := firstBlock.EstimateL1CommitCalldataSize()
-	totalL1CommitGas := firstBlock.EstimateL1CommitGas()
-
-	// Check if the first block breaks hard limits.
-	// If so, it indicates there are bugs in sequencer, manual fix is needed.
-	if totalL2TxNum > p.maxL2TxNumPerChunk {
-		return nil, fmt.Errorf(
-			"the first block exceeds l2 tx number limit; block number: %v, number of transactions: %v, max transaction number limit: %v",
-			firstBlock.Header.Number,
-			totalL2TxNum,
-			p.maxL2TxNumPerChunk,
-		)
-	}
-
-	if totalL1CommitGas > p.maxL1CommitGasPerChunk {
-		return nil, fmt.Errorf(
-			"the first block exceeds l1 commit gas limit; block number: %v, commit gas: %v, max commit gas limit: %v",
-			firstBlock.Header.Number,
-			totalL1CommitGas,
-			p.maxL1CommitGasPerChunk,
-		)
-	}
-
-	if totalL1CommitCalldataSize > p.maxL1CommitCalldataSizePerChunk {
-		return nil, fmt.Errorf(
-			"the first block exceeds l1 commit calldata size limit; block number: %v, calldata size: %v, max calldata size limit: %v",
-			firstBlock.Header.Number,
-			totalL1CommitCalldataSize,
-			p.maxL1CommitCalldataSizePerChunk,
-		)
-	}
-
-	// Check if the first block breaks any soft limits.
-	if totalTxGasUsed > p.maxTxGasPerChunk {
-		log.Warn(
-			"The first block in chunk exceeds l2 tx gas limit",
-			"block number", firstBlock.Header.Number,
-			"gas used", totalTxGasUsed,
-			"max gas limit", p.maxTxGasPerChunk,
-		)
-	}
-
-	for i, block := range blocks[1:] {
-		totalTxGasUsed += block.Header.GasUsed
-		totalL2TxNum += block.L2TxsNum()
-		totalL1CommitCalldataSize += block.EstimateL1CommitCalldataSize()
-		totalL1CommitGas += block.EstimateL1CommitGas()
-		if totalTxGasUsed > p.maxTxGasPerChunk ||
-			totalL2TxNum > p.maxL2TxNumPerChunk ||
-			totalL1CommitCalldataSize > p.maxL1CommitCalldataSizePerChunk ||
-			totalL1CommitGas > p.maxL1CommitGasPerChunk {
-			blocks = blocks[:i+1]
-			break
-		}
-	}
-
-	var hasBlockTimeout bool
-	currentTimeSec := uint64(time.Now().Unix())
-	if blocks[0].Header.Time+p.chunkTimeoutSec < currentTimeSec {
-		log.Warn("first block timeout",
-			"block number", blocks[0].Header.Number,
-			"block timestamp", blocks[0].Header.Time,
-			"block outdated time threshold", currentTimeSec,
-		)
-		hasBlockTimeout = true
-	}
-
-	if !hasBlockTimeout && totalL1CommitCalldataSize < p.minL1CommitCalldataSizePerChunk {
-		log.Warn("The calldata size of the chunk is less than the minimum limit",
-			"totalL1CommitCalldataSize", totalL1CommitCalldataSize,
-			"minL1CommitCalldataSizePerChunk", p.minL1CommitCalldataSizePerChunk,
-		)
-		return nil, nil
-	}
-	return &types.Chunk{Blocks: blocks}, nil
-}

bridge/internal/controller/watcher/chunk_proposer_test.go

@@ -1,46 +0,0 @@
-package watcher
-
-import (
-	"context"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-
-	"scroll-tech/common/database"
-	"scroll-tech/common/types"
-
-	"scroll-tech/bridge/internal/config"
-	"scroll-tech/bridge/internal/orm"
-)
-
-// TODO: Add unit tests that the limits are enforced correctly.
-func testChunkProposer(t *testing.T) {
-	db := setupDB(t)
-	defer database.CloseDB(db)
-
-	l2BlockOrm := orm.NewL2Block(db)
-	err := l2BlockOrm.InsertL2Blocks(context.Background(), []*types.WrappedBlock{wrappedBlock1, wrappedBlock2})
-	assert.NoError(t, err)
-
-	cp := NewChunkProposer(context.Background(), &config.ChunkProposerConfig{
-		MaxTxGasPerChunk:                1000000000,
-		MaxL2TxNumPerChunk:              10000,
-		MaxL1CommitGasPerChunk:          50000000000,
-		MaxL1CommitCalldataSizePerChunk: 1000000,
-		MinL1CommitCalldataSizePerChunk: 0,
-		ChunkTimeoutSec:                 300,
-	}, db)
-	cp.TryProposeChunk()
-
-	expectedChunk := &types.Chunk{
-		Blocks: []*types.WrappedBlock{wrappedBlock1, wrappedBlock2},
-	}
-	expectedHash, err := expectedChunk.Hash(0)
-	assert.NoError(t, err)
-
-	chunkOrm := orm.NewChunk(db)
-	chunks, err := chunkOrm.GetUnbatchedChunks(context.Background())
-	assert.NoError(t, err)
-	assert.Len(t, chunks, 1)
-	assert.Equal(t, expectedHash.Hex(), chunks[0].Hash)
-}

bridge/tests/l1_message_relay_test.go

@@ -1,81 +0,0 @@
-package tests
-
-import (
-	"context"
-	"math/big"
-	"testing"
-
-	"github.com/scroll-tech/go-ethereum/accounts/abi/bind"
-	"github.com/scroll-tech/go-ethereum/common"
-	geth_types "github.com/scroll-tech/go-ethereum/core/types"
-	"github.com/scroll-tech/go-ethereum/rpc"
-	"github.com/stretchr/testify/assert"
-
-	"scroll-tech/common/database"
-	"scroll-tech/common/types"
-
-	"scroll-tech/bridge/internal/controller/relayer"
-	"scroll-tech/bridge/internal/controller/watcher"
-	"scroll-tech/bridge/internal/orm"
-)
-
-func testRelayL1MessageSucceed(t *testing.T) {
-	db := setupDB(t)
-	defer database.CloseDB(db)
-
-	prepareContracts(t)
-
-	l1Cfg := bridgeApp.Config.L1Config
-	l2Cfg := bridgeApp.Config.L2Config
-
-	// Create L1Relayer
-	l1Relayer, err := relayer.NewLayer1Relayer(context.Background(), db, l1Cfg.RelayerConfig)
-	assert.NoError(t, err)
-	// Create L1Watcher
-	confirmations := rpc.LatestBlockNumber
-	l1Watcher := watcher.NewL1WatcherClient(context.Background(), l1Client, 0, confirmations, l1Cfg.L1MessengerAddress, l1Cfg.L1MessageQueueAddress, l1Cfg.ScrollChainContractAddress, db)
-
-	// Create L2Watcher
-	l2Watcher := watcher.NewL2WatcherClient(context.Background(), l2Client, confirmations, l2Cfg.L2MessengerAddress, l2Cfg.L2MessageQueueAddress, l2Cfg.WithdrawTrieRootSlot, db)
-
-	// send message through l1 messenger contract
-	nonce, err := l1MessengerInstance.MessageNonce(&bind.CallOpts{})
-	assert.NoError(t, err)
-	sendTx, err := l1MessengerInstance.SendMessage(l1Auth, l2Auth.From, big.NewInt(0), common.Hex2Bytes("00112233"), big.NewInt(0))
-	assert.NoError(t, err)
-	sendReceipt, err := bind.WaitMined(context.Background(), l1Client, sendTx)
-	assert.NoError(t, err)
-	if sendReceipt.Status != geth_types.ReceiptStatusSuccessful || err != nil {
-		t.Fatalf("Call failed")
-	}
-
-	// l1 watch process events
-	l1Watcher.FetchContractEvent()
-
-	l1MessageOrm := orm.NewL1Message(db)
-	// check db status
-	msg, err := l1MessageOrm.GetL1MessageByQueueIndex(nonce.Uint64())
-	assert.NoError(t, err)
-	assert.Equal(t, types.MsgStatus(msg.Status), types.MsgPending)
-	assert.Equal(t, msg.Target, l2Auth.From.String())
-
-	// process l1 messages
-	l1Relayer.ProcessSavedEvents()
-
-	l1Message, err := l1MessageOrm.GetL1MessageByQueueIndex(nonce.Uint64())
-	assert.NoError(t, err)
-	assert.NotEmpty(t, l1Message.Layer2Hash)
-	assert.Equal(t, types.MsgStatus(l1Message.Status), types.MsgSubmitted)
-
-	relayTx, _, err := l2Client.TransactionByHash(context.Background(), common.HexToHash(l1Message.Layer2Hash))
-	assert.NoError(t, err)
-	relayTxReceipt, err := bind.WaitMined(context.Background(), l2Client, relayTx)
-	assert.NoError(t, err)
-	assert.Equal(t, len(relayTxReceipt.Logs), 1)
-
-	// fetch message relayed events
-	l2Watcher.FetchContractEvent()
-	msg, err = l1MessageOrm.GetL1MessageByQueueIndex(nonce.Uint64())
-	assert.NoError(t, err)
-	assert.Equal(t, types.MsgStatus(msg.Status), types.MsgConfirmed)
-}

build/.golangci.yml

@@ -75,6 +75,10 @@ linters-settings:
     # report about shadowed variables
     check-shadowing: true
 
+  gosec:
+    disable:
+      - G108
+
   golint:
     # minimal confidence for issues, default is 0.8
     min-confidence: 0.8
@@ -227,7 +231,12 @@ issues:
         - lll
       source: "^//go:generate "
       text: "long-lines"
-    
+
+    # Exclude gosec issues for G108: Profiling endpoint is automatically exposed
+    - linters:
+        - gosec
+      text: "G108"
+
     - linters:
         - wsl
       text: "return statements should not be cuddled if block has more than two lines"

build/dockerfiles/coordinator.Dockerfile

@@ -1,5 +1,5 @@
 # Build libzkp dependency
-FROM scrolltech/go-rust-builder:go-1.18-rust-nightly-2022-12-10 as chef
+FROM scrolltech/go-rust-builder:go-1.19-rust-nightly-2022-12-10 as chef
 WORKDIR app
 
 FROM chef as planner
@@ -17,14 +17,15 @@ RUN find ./ | grep libzktrie.so | xargs -I{} cp {} /app/target/release/
 
 
 # Download Go dependencies
-FROM scrolltech/go-rust-builder:go-1.18-rust-nightly-2022-12-10 as base
+FROM scrolltech/go-rust-builder:go-1.19-rust-nightly-2022-12-10 as base
 WORKDIR /src
 COPY go.work* ./
-COPY ./bridge/go.* ./bridge/
+COPY ./rollup/go.* ./rollup/
 COPY ./common/go.* ./common/
 COPY ./coordinator/go.* ./coordinator/
 COPY ./database/go.* ./database/
-COPY ./roller/go.* ./roller/
+COPY ./prover-stats-api/go.* ./prover-stats-api/
+COPY ./prover/go.* ./prover/
 COPY ./tests/integration-test/go.* ./tests/integration-test/
 COPY ./bridge-history-api/go.* ./bridge-history-api/
 RUN go mod download -x
@@ -33,18 +34,18 @@ RUN go mod download -x
 # Build coordinator
 FROM base as builder
 COPY . .
-RUN cp -r ./common/libzkp/interface ./coordinator/verifier/lib
-COPY --from=zkp-builder /app/target/release/libzkp.so ./coordinator/verifier/lib/
-COPY --from=zkp-builder /app/target/release/libzktrie.so ./coordinator/verifier/lib/
-RUN cd ./coordinator && go build -v -p 4 -o /bin/coordinator ./cmd && mv verifier/lib /bin/
+RUN cp -r ./common/libzkp/interface ./coordinator/internal/logic/verifier/lib
+COPY --from=zkp-builder /app/target/release/libzkp.so ./coordinator/internal/logic/verifier/lib/
+COPY --from=zkp-builder /app/target/release/libzktrie.so ./coordinator/internal/logic/verifier/lib/
+RUN cd ./coordinator && make coordinator_skip_libzkp && mv ./build/bin/coordinator /bin/coordinator && mv internal/logic/verifier/lib /bin/
 
 # Pull coordinator into a second stage deploy alpine container
 FROM ubuntu:20.04
-ENV LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/src/coordinator/verifier/lib
+ENV LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/src/coordinator/internal/logic/verifier/lib
 # ENV CHAIN_ID=534353
-RUN mkdir -p /src/coordinator/verifier/lib
-COPY --from=builder /bin/lib /src/coordinator/verifier/lib
+RUN mkdir -p /src/coordinator/internal/logic/verifier/lib
+COPY --from=builder /bin/lib /src/coordinator/internal/logic/verifier/lib
 COPY --from=builder /bin/coordinator /bin/
-
+RUN /bin/coordinator --version
 
 ENTRYPOINT ["/bin/coordinator"]

build/dockerfiles/db_cli.Dockerfile

@@ -1,13 +1,14 @@
 # Download Go dependencies
-FROM scrolltech/go-alpine-builder:1.18 as base
+FROM scrolltech/go-alpine-builder:1.19 as base
 
 WORKDIR /src
 COPY go.work* ./
-COPY ./bridge/go.* ./bridge/
+COPY ./rollup/go.* ./rollup/
 COPY ./common/go.* ./common/
 COPY ./coordinator/go.* ./coordinator/
 COPY ./database/go.* ./database/
-COPY ./roller/go.* ./roller/
+COPY ./prover-stats-api/go.* ./prover-stats-api/
+COPY ./prover/go.* ./prover/
 COPY ./tests/integration-test/go.* ./tests/integration-test/
 COPY ./bridge-history-api/go.* ./bridge-history-api/
 RUN go mod download -x

build/dockerfiles/event_watcher.Dockerfile

@@ -1,13 +1,14 @@
 # Download Go dependencies
-FROM scrolltech/go-alpine-builder:1.18 as base
+FROM scrolltech/go-alpine-builder:1.19 as base
 
 WORKDIR /src
 COPY go.work* ./
-COPY ./bridge/go.* ./bridge/
+COPY ./rollup/go.* ./rollup/
 COPY ./common/go.* ./common/
 COPY ./coordinator/go.* ./coordinator/
 COPY ./database/go.* ./database/
-COPY ./roller/go.* ./roller/
+COPY ./prover-stats-api/go.* ./prover-stats-api/
+COPY ./prover/go.* ./prover/
 COPY ./tests/integration-test/go.* ./tests/integration-test/
 COPY ./bridge-history-api/go.* ./bridge-history-api/
 RUN go mod download -x
@@ -17,7 +18,7 @@ FROM base as builder
 
 RUN --mount=target=. \
     --mount=type=cache,target=/root/.cache/go-build \
-    cd /src/bridge/cmd/event_watcher/ && go build -v -p 4 -o /bin/event_watcher
+    cd /src/rollup/cmd/event_watcher/ && go build -v -p 4 -o /bin/event_watcher
 
 # Pull event_watcher into a second stage deploy alpine container
 FROM alpine:latest

build/dockerfiles/gas_oracle.Dockerfile

@@ -1,13 +1,14 @@
 # Download Go dependencies
-FROM scrolltech/go-alpine-builder:1.18 as base
+FROM scrolltech/go-alpine-builder:1.19 as base
 
 WORKDIR /src
 COPY go.work* ./
-COPY ./bridge/go.* ./bridge/
+COPY ./rollup/go.* ./rollup/
 COPY ./common/go.* ./common/
 COPY ./coordinator/go.* ./coordinator/
 COPY ./database/go.* ./database/
-COPY ./roller/go.* ./roller/
+COPY ./prover-stats-api/go.* ./prover-stats-api/
+COPY ./prover/go.* ./prover/
 COPY ./tests/integration-test/go.* ./tests/integration-test/
 COPY ./bridge-history-api/go.* ./bridge-history-api/
 RUN go mod download -x
@@ -17,7 +18,7 @@ FROM base as builder
 
 RUN --mount=target=. \
     --mount=type=cache,target=/root/.cache/go-build \
-    cd /src/bridge/cmd/gas_oracle/ && go build -v -p 4 -o /bin/gas_oracle
+    cd /src/rollup/cmd/gas_oracle/ && go build -v -p 4 -o /bin/gas_oracle
 
 # Pull gas_oracle into a second stage deploy alpine container
 FROM alpine:latest

build/dockerfiles/local_testing.Dockerfile

@@ -1,5 +1,5 @@
 # Start from the latest golang base image
-FROM golang:1.18
+FROM golang:1.19
 
 # Install Docker
 RUN apt-get update && apt-get install -y docker.io

build/dockerfiles/msg_relayer.Dockerfile

@@ -1,27 +0,0 @@
-# Download Go dependencies
-FROM scrolltech/go-alpine-builder:1.18 as base
-
-WORKDIR /src
-COPY go.work* ./
-COPY ./bridge/go.* ./bridge/
-COPY ./common/go.* ./common/
-COPY ./coordinator/go.* ./coordinator/
-COPY ./database/go.* ./database/
-COPY ./roller/go.* ./roller/
-COPY ./tests/integration-test/go.* ./tests/integration-test/
-COPY ./bridge-history-api/go.* ./bridge-history-api/
-RUN go mod download -x
-
-# Build msg_relayer
-FROM base as builder
-
-RUN --mount=target=. \
-    --mount=type=cache,target=/root/.cache/go-build \
-    cd /src/bridge/cmd/msg_relayer/ && go build -v -p 4 -o /bin/msg_relayer
-
-# Pull msg_relayer into a second stage deploy alpine container
-FROM alpine:latest
-
-COPY --from=builder /bin/msg_relayer /bin/
-
-ENTRYPOINT ["msg_relayer"]

build/dockerfiles/msg_relayer.Dockerfile.dockerignore

@@ -1,5 +0,0 @@
-assets/
-docs/
-l2geth/
-rpc-gateway/
-*target/*

build/dockerfiles/prover-stats-api.Dockerfile

@@ -0,0 +1,31 @@
+# Download Go dependencies
+FROM scrolltech/go-alpine-builder:1.19 as base
+
+WORKDIR /src
+COPY go.work* ./
+COPY ./rollup/go.* ./rollup/
+COPY ./common/go.* ./common/
+COPY ./coordinator/go.* ./coordinator/
+COPY ./database/go.* ./database/
+COPY ./prover-stats-api/go.* ./prover-stats-api/
+COPY ./prover/go.* ./prover/
+COPY ./tests/integration-test/go.* ./tests/integration-test/
+COPY ./bridge-history-api/go.* ./bridge-history-api/
+# Support mainland environment.
+#ENV GOPROXY="https://goproxy.cn,direct"
+RUN go mod download -x
+
+
+# Build prover-stats-api
+FROM base as builder
+
+RUN --mount=target=. \
+    --mount=type=cache,target=/root/.cache/go-build \
+    cd /src/prover-stats-api/cmd/ && go build -v -p 4 -o /bin/prover-stats-api
+
+# Pull prover-stats-api into a second stage deploy alpine container \
+FROM alpine:latest
+
+COPY --from=builder /bin/prover-stats-api /bin/
+
+ENTRYPOINT ["prover-stats-api"]

build/dockerfiles/rollup_relayer.Dockerfile

@@ -1,13 +1,14 @@
 # Download Go dependencies
-FROM scrolltech/go-alpine-builder:1.18 as base
+FROM scrolltech/go-alpine-builder:1.19 as base
 
 WORKDIR /src
 COPY go.work* ./
-COPY ./bridge/go.* ./bridge/
+COPY ./rollup/go.* ./rollup/
 COPY ./common/go.* ./common/
 COPY ./coordinator/go.* ./coordinator/
 COPY ./database/go.* ./database/
-COPY ./roller/go.* ./roller/
+COPY ./prover-stats-api/go.* ./prover-stats-api/
+COPY ./prover/go.* ./prover/
 COPY ./tests/integration-test/go.* ./tests/integration-test/
 COPY ./bridge-history-api/go.* ./bridge-history-api/
 RUN go mod download -x
@@ -17,7 +18,7 @@ FROM base as builder
 
 RUN --mount=target=. \
     --mount=type=cache,target=/root/.cache/go-build \
-    cd /src/bridge/cmd/rollup_relayer/ && go build -v -p 4 -o /bin/rollup_relayer
+    cd /src/rollup/cmd/rollup_relayer/ && go build -v -p 4 -o /bin/rollup_relayer
 
 # Pull rollup_relayer into a second stage deploy alpine container
 FROM alpine:latest

build/run_tests.sh

@@ -3,7 +3,7 @@ set -uex
 
 profile_name=$1
 
-exclude_dirs=("scroll-tech/bridge/cmd" "scroll-tech/bridge/tests" "scroll-tech/bridge/mock_bridge" "scroll-tech/coordinator/cmd" "scroll-tech/coordinator/verifier")
+exclude_dirs=("scroll-tech/rollup/cmd" "scroll-tech/rollup/tests" "scroll-tech/rollup/mock_bridge" "scroll-tech/coordinator/cmd" "scroll-tech/coordinator/internal/logic/verifier")
 
 all_packages=$(go list ./... | grep -v "^scroll-tech/${profile_name}$")
 coverpkg="scroll-tech/${profile_name}"

codecov.yml

@@ -6,7 +6,7 @@ flag_management:
   default_rules:
     carryforward: true
   individual_flags:
-    - name: bridge
+    - name: rollup
       statuses:
         - type: project
           target: auto
@@ -31,7 +31,7 @@ flag_management:
         - type: project
           target: auto
           threshold: 1%
-    - name: roller
+    - name: prover
       statuses:
         - type: project
           target: auto

common/cmd/cmd.go

@@ -5,8 +5,9 @@ import (
 	"os"
 	"os/exec"
 	"strings"
-	"sync"
+	"sync/atomic"
 
+	"github.com/docker/docker/pkg/reexec"
 	cmap "github.com/orcaman/concurrent-map"
 )
 
@@ -26,8 +27,9 @@ type Cmd struct {
 	name string
 	args []string
 
-	mu  sync.Mutex
-	cmd *exec.Cmd
+	isRunning uint64
+	cmd       *exec.Cmd
+	app       *exec.Cmd
 
 	checkFuncs cmap.ConcurrentMap //map[string]checkFunc
 
@@ -38,13 +40,23 @@ type Cmd struct {
 }
 
 // NewCmd create Cmd instance.
-func NewCmd(name string, args ...string) *Cmd {
-	return &Cmd{
+func NewCmd(name string, params ...string) *Cmd {
+	cmd := &Cmd{
 		checkFuncs: cmap.New(),
 		name:       name,
-		args:       args,
+		args:       params,
 		ErrChan:    make(chan error, 10),
+		cmd:        exec.Command(name, params...),
+		app: &exec.Cmd{
+			Path: reexec.Self(),
+			Args: append([]string{name}, params...),
+		},
 	}
+	cmd.cmd.Stdout = cmd
+	cmd.cmd.Stderr = cmd
+	cmd.app.Stdout = cmd
+	cmd.app.Stderr = cmd
+	return cmd
 }
 
 // RegistFunc register check func
@@ -58,15 +70,14 @@ func (c *Cmd) UnRegistFunc(key string) {
 }
 
 func (c *Cmd) runCmd() {
-	cmd := exec.Command(c.args[0], c.args[1:]...) //nolint:gosec
-	cmd.Stdout = c
-	cmd.Stderr = c
-	c.ErrChan <- cmd.Run()
+	fmt.Println("cmd:", append([]string{c.name}, c.args...))
+	if atomic.CompareAndSwapUint64(&c.isRunning, 0, 1) {
+		c.ErrChan <- c.cmd.Run()
+	}
 }
 
 // RunCmd parallel running when parallel is true.
 func (c *Cmd) RunCmd(parallel bool) {
-	fmt.Println("cmd:", c.args)
 	if parallel {
 		go c.runCmd()
 	} else {
@@ -83,7 +94,9 @@ func (c *Cmd) Write(data []byte) (int, error) {
 	out := string(data)
 	if verbose || c.openLog {
 		fmt.Printf("%s:\n\t%v", c.name, out)
-	} else if strings.Contains(out, "error") || strings.Contains(out, "warning") {
+	} else if strings.Contains(strings.ToLower(out), "error") ||
+		strings.Contains(strings.ToLower(out), "warning") ||
+		strings.Contains(strings.ToLower(out), "info") {
 		fmt.Printf("%s:\n\t%v", c.name, out)
 	}
 	go c.checkFuncs.IterCb(func(_ string, value interface{}) {

common/cmd/cmd_app.go

@@ -3,41 +3,45 @@ package cmd
 import (
 	"fmt"
 	"os"
-	"os/exec"
 	"strings"
+	"sync/atomic"
+	"syscall"
 	"testing"
 	"time"
 
-	"github.com/docker/docker/pkg/reexec"
 	"github.com/stretchr/testify/assert"
 )
 
+// IsRunning 1 started, 0 not started.
+func (c *Cmd) IsRunning() bool {
+	return atomic.LoadUint64(&c.isRunning) == 1
+}
+
+func (c *Cmd) runApp() {
+	fmt.Println("cmd:", append([]string{c.name}, c.args...))
+	if atomic.CompareAndSwapUint64(&c.isRunning, 0, 1) {
+		c.ErrChan <- c.app.Run()
+	}
+}
+
 // RunApp exec's the current binary using name as argv[0] which will trigger the
 // reexec init function for that name (e.g. "geth-test" in cmd/geth/run_test.go)
 func (c *Cmd) RunApp(waitResult func() bool) {
-	fmt.Println("cmd: ", append([]string{c.name}, c.args...))
-	cmd := &exec.Cmd{
-		Path:   reexec.Self(),
-		Args:   append([]string{c.name}, c.args...),
-		Stderr: c,
-		Stdout: c,
-	}
 	if waitResult != nil {
 		go func() {
-			_ = cmd.Run()
+			c.runApp()
 		}()
 		waitResult()
 	} else {
-		_ = cmd.Run()
+		c.runApp()
 	}
-
-	c.mu.Lock()
-	c.cmd = cmd
-	c.mu.Unlock()
 }
 
 // WaitExit wait util process exit.
 func (c *Cmd) WaitExit() {
+	if atomic.LoadUint64(&c.isRunning) == 0 {
+		return
+	}
 	// Wait all the check functions are finished, interrupt loop when appear error.
 	var err error
 	for err == nil && !c.checkFuncs.IsEmpty() {
@@ -52,20 +56,18 @@ func (c *Cmd) WaitExit() {
 	}
 
 	// Send interrupt signal.
-	c.mu.Lock()
-	_ = c.cmd.Process.Signal(os.Interrupt)
-	// should use `_ = c.cmd.Process.Wait()` here, but we have some bugs in coordinator's graceful exit,
+	_ = c.app.Process.Signal(os.Interrupt)
+	// should use `_ = c.app.Process.Wait()` here, but we have some bugs in coordinator's graceful exit,
 	// so we use `Kill` as a temp workaround. And since `WaitExit` is only used in integration tests, so
 	// it won't really affect our functionalities.
-	_ = c.cmd.Process.Kill()
-	c.mu.Unlock()
+	if err = c.app.Process.Signal(syscall.SIGTERM); err != nil {
+		_ = c.app.Process.Kill()
+	}
 }
 
 // Interrupt send interrupt signal.
 func (c *Cmd) Interrupt() {
-	c.mu.Lock()
-	c.ErrChan <- c.cmd.Process.Signal(os.Interrupt)
-	c.mu.Unlock()
+	c.ErrChan <- c.app.Process.Signal(os.Interrupt)
 }
 
 // WaitResult return true when get the keyword during timeout.

common/cmd/cmd_test.go

@@ -12,7 +12,7 @@ import (
 )
 
 func TestCmd(t *testing.T) {
-	app := cmd.NewCmd("curTime", "date", "+%Y-%m-%d")
+	app := cmd.NewCmd("date", "+%Y-%m-%d")
 
 	tm := time.Now()
 	curTime := fmt.Sprintf("%d-%02d-%02d", tm.Year(), tm.Month(), tm.Day())

common/database/db.go

@@ -2,6 +2,7 @@ package database
 
 import (
 	"context"
+	"database/sql"
 	"fmt"
 	"time"
 
@@ -10,6 +11,8 @@ import (
 	"gorm.io/gorm"
 	"gorm.io/gorm/logger"
 	"gorm.io/gorm/utils"
+
+	cutils "scroll-tech/common/utils"
 )
 
 type gormLogger struct {
@@ -49,21 +52,27 @@ func InitDB(config *Config) (*gorm.DB, error) {
 
 	db, err := gorm.Open(postgres.Open(config.DSN), &gorm.Config{
 		Logger: &tmpGormLogger,
+		NowFunc: func() time.Time {
+			// why set time to UTC.
+			// if now set this, the inserted data time will use local timezone. like 2023-07-18 18:24:00 CST+8
+			// but when inserted, store to postgres is 2023-07-18 18:24:00 UTC+0 the timezone is incorrect.
+			// As mysql dsn user:pass@tcp(127.0.0.1:3306)/dbname?charset=utf8mb4&parseTime=True&loc=Local, we cant set
+			// the timezone by loc=Local. but postgres's dsn don't have loc option to set timezone, so just need set the gorm option like that.
+			return cutils.NowUTC()
+		},
 	})
 	if err != nil {
 		return nil, err
 	}
-	sqlDB, err := db.DB()
-	if err != nil {
-		return nil, err
+
+	sqlDB, pingErr := Ping(db)
+	if pingErr != nil {
+		return nil, pingErr
 	}
 
 	sqlDB.SetMaxOpenConns(config.MaxOpenNum)
 	sqlDB.SetMaxIdleConns(config.MaxIdleNum)
 
-	if err = sqlDB.Ping(); err != nil {
-		return nil, err
-	}
 	return db, nil
 }
 
@@ -78,3 +87,16 @@ func CloseDB(db *gorm.DB) error {
 	}
 	return nil
 }
+
+// Ping check db status
+func Ping(db *gorm.DB) (*sql.DB, error) {
+	sqlDB, err := db.DB()
+	if err != nil {
+		return nil, err
+	}
+
+	if err = sqlDB.Ping(); err != nil {
+		return nil, err
+	}
+	return sqlDB, nil
+}

common/database/db_test.go

@@ -11,6 +11,10 @@ import (
 	"github.com/mattn/go-colorable"
 	"github.com/mattn/go-isatty"
 	"github.com/scroll-tech/go-ethereum/log"
+	"github.com/stretchr/testify/assert"
+
+	"scroll-tech/common/docker"
+	"scroll-tech/common/version"
 )
 
 func TestGormLogger(t *testing.T) {
@@ -33,3 +37,26 @@ func TestGormLogger(t *testing.T) {
 	gl.Info(context.Background(), "test %s warn:%v", "testInfo", errors.New("test info"))
 	gl.Trace(context.Background(), time.Now(), func() (string, int64) { return "test trace", 1 }, nil)
 }
+
+func TestDB(t *testing.T) {
+	version.Version = "v4.1.98-aaa-bbb-ccc"
+	base := docker.NewDockerApp()
+	base.RunDBImage(t)
+
+	dbCfg := &Config{
+		DSN:        base.DBConfig.DSN,
+		DriverName: base.DBConfig.DriverName,
+		MaxOpenNum: base.DBConfig.MaxOpenNum,
+		MaxIdleNum: base.DBConfig.MaxIdleNum,
+	}
+
+	var err error
+	db, err := InitDB(dbCfg)
+	assert.NoError(t, err)
+
+	sqlDB, err := Ping(db)
+	assert.NoError(t, err)
+	assert.NotNil(t, sqlDB)
+
+	assert.NoError(t, CloseDB(db))
+}

common/docker/docker_app.go

@@ -27,6 +27,7 @@ var (
 
 // AppAPI app interface.
 type AppAPI interface {
+	IsRunning() bool
 	WaitResult(t *testing.T, timeout time.Duration, keyword string) bool
 	RunApp(waitResult func() bool)
 	WaitExit()

common/docker/docker_db.go

@@ -7,6 +7,7 @@ import (
 	"time"
 
 	"github.com/docker/docker/api/types"
+	"github.com/docker/docker/api/types/container"
 
 	"scroll-tech/common/cmd"
 	"scroll-tech/common/utils"
@@ -35,7 +36,7 @@ func NewImgDB(image, password, dbName string, port int) ImgInstance {
 		dbName:   dbName,
 		port:     port,
 	}
-	img.cmd = cmd.NewCmd(img.name, img.prepare()...)
+	img.cmd = cmd.NewCmd("docker", img.prepare()...)
 	return img
 }
 
@@ -65,8 +66,12 @@ func (i *ImgDB) Stop() error {
 	if i.id == "" {
 		i.id = GetContainerID(i.name)
 	}
-	timeout := time.Second * 3
-	if err := cli.ContainerStop(ctx, i.id, &timeout); err != nil {
+
+	timeoutSec := 3
+	timeout := container.StopOptions{
+		Timeout: &timeoutSec,
+	}
+	if err := cli.ContainerStop(ctx, i.id, timeout); err != nil {
 		return err
 	}
 	// remove the stopped container.
@@ -84,7 +89,7 @@ func (i *ImgDB) IsRunning() bool {
 }
 
 func (i *ImgDB) prepare() []string {
-	cmd := []string{"docker", "run", "--rm", "--name", i.name, "-p", fmt.Sprintf("%d:5432", i.port)}
+	cmd := []string{"run", "--rm", "--name", i.name, "-p", fmt.Sprintf("%d:5432", i.port)}
 	envs := []string{
 		"-e", "POSTGRES_PASSWORD=" + i.password,
 		"-e", fmt.Sprintf("POSTGRES_DB=%s", i.dbName),

common/docker/docker_geth.go

@@ -9,6 +9,7 @@ import (
 	"time"
 
 	"github.com/docker/docker/api/types"
+	"github.com/docker/docker/api/types/container"
 	"github.com/scroll-tech/go-ethereum/ethclient"
 
 	"scroll-tech/common/cmd"
@@ -41,7 +42,7 @@ func NewImgGeth(image, volume, ipc string, hPort, wPort int) GethImgInstance {
 		httpPort: hPort,
 		wsPort:   wPort,
 	}
-	img.cmd = cmd.NewCmd(img.name, img.prepare()...)
+	img.cmd = cmd.NewCmd("docker", img.params()...)
 	return img
 }
 
@@ -135,8 +136,11 @@ func (i *ImgGeth) Stop() error {
 	// check if container is running, stop the running container.
 	id := GetContainerID(i.name)
 	if id != "" {
-		timeout := time.Second * 3
-		if err := cli.ContainerStop(ctx, id, &timeout); err != nil {
+		timeoutSec := 3
+		timeout := container.StopOptions{
+			Timeout: &timeoutSec,
+		}
+		if err := cli.ContainerStop(ctx, id, timeout); err != nil {
 			return err
 		}
 		i.id = id
@@ -145,8 +149,8 @@ func (i *ImgGeth) Stop() error {
 	return cli.ContainerRemove(ctx, i.id, types.ContainerRemoveOptions{})
 }
 
-func (i *ImgGeth) prepare() []string {
-	cmds := []string{"docker", "run", "--rm", "--name", i.name}
+func (i *ImgGeth) params() []string {
+	cmds := []string{"run", "--rm", "--name", i.name}
 	var ports []string
 	if i.httpPort != 0 {
 		ports = append(ports, []string{"-p", strconv.Itoa(i.httpPort) + ":8545"}...)

common/docker/l2geth/Dockerfile

@@ -1,4 +1,4 @@
-FROM scrolltech/l2geth:scroll-v4.1.0
+FROM scrolltech/l2geth:scroll-v4.3.55
 
 RUN mkdir -p /l2geth/keystore
 

common/docker/l2geth/genesis.json

@@ -12,6 +12,8 @@
     "istanbulBlock": 0,
     "berlinBlock": 0,
     "londonBlock": 0,
+    "archimedesBlock": 0,
+    "shanghaiBlock": 0,
     "clique": {
       "period": 3,
       "epoch": 30000
@@ -19,6 +21,7 @@
     "scroll": {
       "useZktrie": true,
       "maxTxPerBlock": 44,
+      "maxTxPayloadBytesPerBlock": 122880,
       "feeVaultAddress": "0x5300000000000000000000000000000000000005",
       "enableEIP2718": false,
       "enableEIP1559": false