From 509a587a5fa347dabd900a07f40079acb9199fde Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Toni=20Ram=C3=ADrez?= <58293609+ToniRamirezM@users.noreply.github.com> Date: Fri, 12 Jan 2024 09:03:06 +0100 Subject: [PATCH] First implementation (#1) * wip * wip * wip * wip * wip * ci * linter * finish WIP * fix gha * fix gha * fix gha --- .github/ISSUE_TEMPLATE/bug.md | 31 + .github/ISSUE_TEMPLATE/feature.md | 17 + .github/ISSUE_TEMPLATE/question.md | 9 + .github/dependabot.yml | 7 + .github/hooks/pre-commit | 7 + .github/pull_request_template.md | 22 + .github/workflows/lint.yml | 24 + .github/workflows/push-docker-develop.yml | 32 + .github/workflows/push-docker-tagged.yml | 33 + .github/workflows/release.yml | 61 + .github/workflows/test.yml | 33 + .gitignore | 25 +- .golangci.yml | 32 + .goreleaser.yaml | 22 + Dockerfile | 20 + LICENSE | 636 ++ Makefile | 92 + aggregator/prover/aggregator.pb.go | 2471 ++++++++ aggregator/prover/aggregator_grpc.pb.go | 141 + cmd/main.go | 96 + cmd/run.go | 207 + cmd/version.go | 13 + config/config.go | 126 + config/default.go | 36 + .../local/local.ethtxmanager.config.toml | 34 + .../local/local.genesis.config.json | 100 + .../mainnet/ethtxmanager.config.toml | 34 + config/environments/mainnet/example.env | 7 + config/environments/mainnet/postgresql.conf | 815 +++ .../environments/mainnet/prover.config.json | 117 + .../testnet/ethtxmanager.config.toml | 34 + config/environments/testnet/example.env | 7 + config/environments/testnet/postgresql.conf | 815 +++ .../environments/testnet/prover.config.json | 117 + config/example.keystore | 1 + config/genesis.go | 26 + config/mainnetgenesis.go | 107 + config/network.go | 177 + config/testnetgenesis.go | 108 + config/types/duration.go | 40 + config/types/duration_test.go | 54 + config/types/keystore.go | 10 + db/config.go | 25 + db/db.go | 123 + db/logger.go | 27 + db/migrations/0001.sql | 25 + docker-compose.yml | 52 + encoding/encoding.go | 110 + etherman/config.go | 17 + etherman/errors.go | 48 + etherman/etherman.go | 1754 ++++++ etherman/etherscan/etherscan.go | 77 + etherman/etherscan/etherscan_test.go | 39 + etherman/ethgasstation/ethgasstation.go | 64 + etherman/ethgasstation/ethgasstation_test.go | 37 + etherman/metrics/metrics.go | 120 + .../abi/mockpolygonrollupmanager.abi | 1983 ++++++ etherman/smartcontracts/abi/mockverifier.abi | 26 + .../smartcontracts/abi/oldpolygonzkevm.abi | 1709 ++++++ .../abi/oldpolygonzkevmbridge.abi | 774 +++ .../abi/oldpolygonzkevmglobalexitroot.abi | 139 + etherman/smartcontracts/abi/pol.abi | 408 ++ .../abi/polygonrollupmanager.abi | 1945 ++++++ etherman/smartcontracts/abi/polygonzkevm.abi | 1118 ++++ .../smartcontracts/abi/polygonzkevmbridge.abi | 981 +++ .../abi/polygonzkevmglobalexitroot.abi | 262 + .../bin/mockpolygonrollupmanager.bin | 1 + etherman/smartcontracts/bin/mockverifier.bin | 1 + .../smartcontracts/bin/oldpolygonzkevm.bin | 1 + .../bin/oldpolygonzkevmbridge.bin | 1 + .../bin/oldpolygonzkevmglobalexitroot.bin | 1 + etherman/smartcontracts/bin/pol.bin | 1 + .../bin/polygonrollupmanager.bin | 1 + etherman/smartcontracts/bin/polygonzkevm.bin | 1 + .../smartcontracts/bin/polygonzkevmbridge.bin | 1 + .../bin/polygonzkevmglobalexitroot.bin | 1 + .../mockpolygonrollupmanager.go | 5048 ++++++++++++++++ .../mockverifier/mockverifier.go | 234 + .../oldpolygonzkevm/oldpolygonzkevm.go | 5308 +++++++++++++++++ .../oldpolygonzkevmbridge.go | 1666 ++++++ .../oldpolygonzkevmglobalexitroot.go | 563 ++ etherman/smartcontracts/pol/pol.go | 1504 +++++ .../polygonrollupmanager.go | 5027 ++++++++++++++++ .../polygonzkevm/polygonzkevm.go | 3099 ++++++++++ .../polygonzkevmbridge/polygonzkevmbridge.go | 1904 ++++++ .../polygonzkevmglobalexitroot.go | 718 +++ etherman/smartcontracts/script.sh | 20 + etherman/types.go | 84 + etherman/types/finalproofinputs.go | 10 + etherman/types/sequence.go | 25 + etherman/wait.go | 175 + ethtxmanager/config.go | 56 + ethtxmanager/ethtxmanager.go | 727 +++ ethtxmanager/interfaces.go | 32 + ethtxmanager/monitoredtx.go | 195 + ethtxmanager/monitoredtx_test.go | 38 + ethtxmanager/pgstorage.go | 278 + go.mod | 123 + go.sum | 1196 ++++ hex/hex.go | 121 + hex/hex_test.go | 52 + log/config.go | 13 + log/log.go | 320 + log/log_test.go | 37 + metrics/api.go | 16 + metrics/config.go | 17 + metrics/prometheus.go | 677 +++ metrics/prometheus_test.go | 371 ++ test/Makefile | 92 + test/aggregator.keystore | 1 + test/config/test.ethtxmanager.config.toml | 35 + test/config/test.genesis.config.json | 100 + test/docker-compose.yml | 82 + test/sequencer.keystore | 1 + version.go | 25 + version.mk | 4 + 116 files changed, 48644 insertions(+), 19 deletions(-) create mode 100644 .github/ISSUE_TEMPLATE/bug.md create mode 100644 .github/ISSUE_TEMPLATE/feature.md create mode 100644 .github/ISSUE_TEMPLATE/question.md create mode 100644 .github/dependabot.yml create mode 100755 .github/hooks/pre-commit create mode 100644 .github/pull_request_template.md create mode 100644 .github/workflows/lint.yml create mode 100644 .github/workflows/push-docker-develop.yml create mode 100644 .github/workflows/push-docker-tagged.yml create mode 100644 .github/workflows/release.yml create mode 100644 .github/workflows/test.yml create mode 100644 .golangci.yml create mode 100644 .goreleaser.yaml create mode 100644 Dockerfile create mode 100644 LICENSE create mode 100644 Makefile create mode 100644 aggregator/prover/aggregator.pb.go create mode 100644 aggregator/prover/aggregator_grpc.pb.go create mode 100644 cmd/main.go create mode 100644 cmd/run.go create mode 100644 cmd/version.go create mode 100644 config/config.go create mode 100644 config/default.go create mode 100644 config/environments/local/local.ethtxmanager.config.toml create mode 100644 config/environments/local/local.genesis.config.json create mode 100644 config/environments/mainnet/ethtxmanager.config.toml create mode 100644 config/environments/mainnet/example.env create mode 100644 config/environments/mainnet/postgresql.conf create mode 100644 config/environments/mainnet/prover.config.json create mode 100644 config/environments/testnet/ethtxmanager.config.toml create mode 100644 config/environments/testnet/example.env create mode 100644 config/environments/testnet/postgresql.conf create mode 100644 config/environments/testnet/prover.config.json create mode 100644 config/example.keystore create mode 100644 config/genesis.go create mode 100644 config/mainnetgenesis.go create mode 100644 config/network.go create mode 100644 config/testnetgenesis.go create mode 100644 config/types/duration.go create mode 100644 config/types/duration_test.go create mode 100644 config/types/keystore.go create mode 100644 db/config.go create mode 100644 db/db.go create mode 100644 db/logger.go create mode 100644 db/migrations/0001.sql create mode 100644 docker-compose.yml create mode 100644 encoding/encoding.go create mode 100644 etherman/config.go create mode 100644 etherman/errors.go create mode 100644 etherman/etherman.go create mode 100644 etherman/etherscan/etherscan.go create mode 100644 etherman/etherscan/etherscan_test.go create mode 100644 etherman/ethgasstation/ethgasstation.go create mode 100644 etherman/ethgasstation/ethgasstation_test.go create mode 100644 etherman/metrics/metrics.go create mode 100644 etherman/smartcontracts/abi/mockpolygonrollupmanager.abi create mode 100644 etherman/smartcontracts/abi/mockverifier.abi create mode 100644 etherman/smartcontracts/abi/oldpolygonzkevm.abi create mode 100644 etherman/smartcontracts/abi/oldpolygonzkevmbridge.abi create mode 100644 etherman/smartcontracts/abi/oldpolygonzkevmglobalexitroot.abi create mode 100644 etherman/smartcontracts/abi/pol.abi create mode 100644 etherman/smartcontracts/abi/polygonrollupmanager.abi create mode 100644 etherman/smartcontracts/abi/polygonzkevm.abi create mode 100644 etherman/smartcontracts/abi/polygonzkevmbridge.abi create mode 100644 etherman/smartcontracts/abi/polygonzkevmglobalexitroot.abi create mode 100644 etherman/smartcontracts/bin/mockpolygonrollupmanager.bin create mode 100644 etherman/smartcontracts/bin/mockverifier.bin create mode 100644 etherman/smartcontracts/bin/oldpolygonzkevm.bin create mode 100644 etherman/smartcontracts/bin/oldpolygonzkevmbridge.bin create mode 100644 etherman/smartcontracts/bin/oldpolygonzkevmglobalexitroot.bin create mode 100644 etherman/smartcontracts/bin/pol.bin create mode 100644 etherman/smartcontracts/bin/polygonrollupmanager.bin create mode 100644 etherman/smartcontracts/bin/polygonzkevm.bin create mode 100644 etherman/smartcontracts/bin/polygonzkevmbridge.bin create mode 100644 etherman/smartcontracts/bin/polygonzkevmglobalexitroot.bin create mode 100644 etherman/smartcontracts/mockpolygonrollupmanager/mockpolygonrollupmanager.go create mode 100644 etherman/smartcontracts/mockverifier/mockverifier.go create mode 100644 etherman/smartcontracts/oldpolygonzkevm/oldpolygonzkevm.go create mode 100644 etherman/smartcontracts/oldpolygonzkevmbridge/oldpolygonzkevmbridge.go create mode 100644 etherman/smartcontracts/oldpolygonzkevmglobalexitroot/oldpolygonzkevmglobalexitroot.go create mode 100644 etherman/smartcontracts/pol/pol.go create mode 100644 etherman/smartcontracts/polygonrollupmanager/polygonrollupmanager.go create mode 100644 etherman/smartcontracts/polygonzkevm/polygonzkevm.go create mode 100644 etherman/smartcontracts/polygonzkevmbridge/polygonzkevmbridge.go create mode 100644 etherman/smartcontracts/polygonzkevmglobalexitroot/polygonzkevmglobalexitroot.go create mode 100755 etherman/smartcontracts/script.sh create mode 100644 etherman/types.go create mode 100644 etherman/types/finalproofinputs.go create mode 100644 etherman/types/sequence.go create mode 100644 etherman/wait.go create mode 100644 ethtxmanager/config.go create mode 100644 ethtxmanager/ethtxmanager.go create mode 100644 ethtxmanager/interfaces.go create mode 100644 ethtxmanager/monitoredtx.go create mode 100644 ethtxmanager/monitoredtx_test.go create mode 100644 ethtxmanager/pgstorage.go create mode 100644 go.mod create mode 100644 go.sum create mode 100644 hex/hex.go create mode 100644 hex/hex_test.go create mode 100644 log/config.go create mode 100644 log/log.go create mode 100644 log/log_test.go create mode 100644 metrics/api.go create mode 100644 metrics/config.go create mode 100644 metrics/prometheus.go create mode 100644 metrics/prometheus_test.go create mode 100644 test/Makefile create mode 100644 test/aggregator.keystore create mode 100644 test/config/test.ethtxmanager.config.toml create mode 100644 test/config/test.genesis.config.json create mode 100644 test/docker-compose.yml create mode 100644 test/sequencer.keystore create mode 100644 version.go create mode 100644 version.mk diff --git a/.github/ISSUE_TEMPLATE/bug.md b/.github/ISSUE_TEMPLATE/bug.md new file mode 100644 index 0000000..7439c1c --- /dev/null +++ b/.github/ISSUE_TEMPLATE/bug.md @@ -0,0 +1,31 @@ +--- +name: Report a bug +about: Something with Polygon zkEVM Eth Tx Manager is not working as expected +title: '' +labels: 'type:bug' +assignees: '' +--- + +#### System information + +zkEVM Node version: `v0.0.X-RCXX` +OS & Version: `Windows/Linux/OSX` +Commit hash : (if `develop`) +Network: `Mainnet/Testnet` + +#### Expected behaviour + + +#### Actual behaviour + + +#### Steps to reproduce the behaviour + + +#### Backtrace + +```` +[backtrace] +```` + +When submitting logs: please submit them as text and not screenshots. \ No newline at end of file diff --git a/.github/ISSUE_TEMPLATE/feature.md b/.github/ISSUE_TEMPLATE/feature.md new file mode 100644 index 0000000..aacd885 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/feature.md @@ -0,0 +1,17 @@ +--- +name: Request a feature +about: Report a missing feature - e.g. as a step before submitting a PR +title: '' +labels: 'type:feature' +assignees: '' +--- + +# Rationale + +Why should this feature exist? +What are the use-cases? + +# Implementation + +Do you have ideas regarding the implementation of this feature? +Are you willing to implement this feature? \ No newline at end of file diff --git a/.github/ISSUE_TEMPLATE/question.md b/.github/ISSUE_TEMPLATE/question.md new file mode 100644 index 0000000..2d06858 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/question.md @@ -0,0 +1,9 @@ +--- +name: Ask a question +about: Something is unclear +title: '' +labels: 'type:question' +assignees: '' +--- + +This should only be used in very rare cases e.g. if you are not 100% sure if something is a bug or asking a question that leads to improving the documentation. diff --git a/.github/dependabot.yml b/.github/dependabot.yml new file mode 100644 index 0000000..a48452c --- /dev/null +++ b/.github/dependabot.yml @@ -0,0 +1,7 @@ +--- +version: 2 +updates: + - package-ecosystem: "gomod" + directory: "/" + schedule: + interval: "daily" diff --git a/.github/hooks/pre-commit b/.github/hooks/pre-commit new file mode 100755 index 0000000..6fad7fc --- /dev/null +++ b/.github/hooks/pre-commit @@ -0,0 +1,7 @@ +#!/bin/bash + +# Only run lint if .go files changed +git diff --cached --name-only | if grep --quiet ".*go$" +then + make lint +fi diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md new file mode 100644 index 0000000..a801ce1 --- /dev/null +++ b/.github/pull_request_template.md @@ -0,0 +1,22 @@ +Closes #. + +### What does this PR do? + + + +### Reviewers + +Main reviewers: + + + +- @John +- @Doe + +Codeowner reviewers: + + + +- @-Alice +- @-Bob diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml new file mode 100644 index 0000000..3b38076 --- /dev/null +++ b/.github/workflows/lint.yml @@ -0,0 +1,24 @@ +name: Lint +on: + push: + branches: + - main + - master + - develop + - update-external-dependencies + - 'release/**' + pull_request: +jobs: + lint: + runs-on: ubuntu-latest + steps: + - name: Install Go + uses: actions/setup-go@v3 + with: + go-version: 1.21.x + - name: Checkout code + uses: actions/checkout@v3 + - name: Lint + run: | + make install-linter + make lint diff --git a/.github/workflows/push-docker-develop.yml b/.github/workflows/push-docker-develop.yml new file mode 100644 index 0000000..e2a0297 --- /dev/null +++ b/.github/workflows/push-docker-develop.yml @@ -0,0 +1,32 @@ +on: + push: + branches: + - main + +jobs: + build: + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v3 + + - name: Set up QEMU + uses: docker/setup-qemu-action@v3 + + - name: Set up Docker Buildx + uses: docker/setup-buildx-action@v3 + + - name: Login to DockerHub + uses: docker/login-action@v3 + with: + username: ${{ secrets.DOCKERHUB_USERNAME }} + password: ${{ secrets.DOCKERHUB_TOKEN }} + + - name: Build and push + id: docker_build + uses: docker/build-push-action@v5 + with: + platforms: linux/amd64,linux/arm64 + push: true + tags: | + hermeznetwork/zkevm-ethtx-manager:main diff --git a/.github/workflows/push-docker-tagged.yml b/.github/workflows/push-docker-tagged.yml new file mode 100644 index 0000000..9075f64 --- /dev/null +++ b/.github/workflows/push-docker-tagged.yml @@ -0,0 +1,33 @@ +on: + push: + tags: + - 'v[0-9]+.[0-9]+.[0-9]+*' # this action will only run on tags that follow semver + +jobs: + build: + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v3 + + - name: Set up QEMU + uses: docker/setup-qemu-action@v3 + + - name: Set up Docker Buildx + uses: docker/setup-buildx-action@v3 + + - name: Login to DockerHub + uses: docker/login-action@v3 + with: + username: ${{ secrets.DOCKERHUB_USERNAME }} + password: ${{ secrets.DOCKERHUB_TOKEN }} + + - name: Build and push + id: docker_build + uses: docker/build-push-action@v5 + with: + context: . + platforms: linux/amd64,linux/arm64 + push: true + tags: | + hermeznetwork/zkevm-ethtx-manager:${{ github.ref_name }} diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml new file mode 100644 index 0000000..c6aa72d --- /dev/null +++ b/.github/workflows/release.yml @@ -0,0 +1,61 @@ +name: release + +on: + push: + tags: + - 'v[0-9]+.[0-9]+.[0-9]+' # this action will only run on tags that follow semver +jobs: + releaser: + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v3 + with: + fetch-depth: 0 + + - name: Set up Go + uses: actions/setup-go@v3 + with: + go-version: 1.21 + + - name: Get packr + run: go install github.com/gobuffalo/packr/v2/packr2@v2.8.3 + + - name: Run GoReleaser + uses: goreleaser/goreleaser-action@v4 + with: + version: latest + args: release --clean + env: + GITHUB_TOKEN: ${{ secrets.TOKEN_RELEASE }} + + - name: Get tag + uses: olegtarasov/get-tag@v2.1.2 + id: tagName + + - name: Put testnet and mainnet artifacts into a single zip + run: | + # TESTNET + mkdir -p testnet/config/environments/testnet + cp config/environments/testnet/* testnet/config/environments/testnet + cp docker-compose.yml testnet + sed -i 's/\/config\/environments\/${ZKEVM_NETWORK}/\/config\/environments\/testnet/g' testnet/docker-compose.yml + mv testnet/config/environments/testnet/example.env testnet + sed -i -e "s/image: zkevm-ethtx-manager/image: hermeznetwork\/zkevm-ethtx-manager:$GIT_TAG_NAME/g" testnet/docker-compose.yml + zip -r testnet.zip testnet + # MAINNET + mkdir -p mainnet/config/environments/mainnet + cp config/environments/mainnet/* mainnet/config/environments/mainnet + cp docker-compose.yml mainnet + sed -i 's/\/config\/environments\/${ZKEVM_NETWORK}/\/config\/environments\/mainnet/g' mainnet/docker-compose.yml + mv mainnet/config/environments/mainnet/example.env mainnet + sed -i -e "s/image: zkevm-ethtx-manager/image: hermeznetwork\/zkevm-ethtx-manager:$GIT_TAG_NAME/g" mainnet/docker-compose.yml + zip -r mainnet.zip mainnet + + - name: Publish testnet and mainnet zip into release + uses: AButler/upload-release-assets@v2.0 + with: + files: 'testnet.zip;mainnet.zip' + repo-token: ${{ secrets.TOKEN_RELEASE }} + release-tag: ${{ steps.tagName.outputs.tag }} + diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml new file mode 100644 index 0000000..d550261 --- /dev/null +++ b/.github/workflows/test.yml @@ -0,0 +1,33 @@ +--- +name: Test +on: + push: + branches: + - main + - master + - develop + - update-external-dependencies + - 'release/**' + pull_request: + +jobs: + test: + strategy: + matrix: + go-version: [ 1.21.x ] + goarch: [ "amd64" ] + runs-on: ubuntu-latest + steps: + - name: Checkout code + uses: actions/checkout@v3 + + - name: Install Go + uses: actions/setup-go@v3 + with: + go-version: ${{ matrix.go-version }} + env: + GOARCH: ${{ matrix.goarch }} + + - name: Test + run: make test + working-directory: test diff --git a/.gitignore b/.gitignore index 3b735ec..eef4013 100644 --- a/.gitignore +++ b/.gitignore @@ -1,21 +1,8 @@ -# If you prefer the allow list template instead of the deny list, see community template: -# https://github.com/github/gitignore/blob/main/community/Golang/Go.AllowList.gitignore -# -# Binaries for programs and plugins -*.exe -*.exe~ -*.dll -*.so -*.dylib +/dist/ -# Test binary, built with `go test -c` -*.test +/test/*.bin -# Output of the go coverage tool, specifically when used with LiteIDE -*.out - -# Dependency directories (remove the comment below to include it) -# vendor/ - -# Go workspace file -go.work +**/.DS_Store +.vscode +.idea/ +.env \ No newline at end of file diff --git a/.golangci.yml b/.golangci.yml new file mode 100644 index 0000000..7014abc --- /dev/null +++ b/.golangci.yml @@ -0,0 +1,32 @@ +--- +run: + timeout: 5m + skip-dirs: + - state/runtime/fakevm + - state/runtime/instrumentation + - test + - ci + +linters: + enable: + - whitespace + - gosec + - gci + - misspell + - gomnd + - gofmt + - goimports + - revive + - unconvert + +linters-settings: + revive: + rules: + - name: exported + arguments: + - disableStutteringCheck + +issues: + include: + - EXC0012 # EXC0012 revive: Annoying issue about not having a comment. The rare codebase has such comments + - EXC0014 # EXC0014 revive: Annoying issue about not having a comment. The rare codebase has such comments diff --git a/.goreleaser.yaml b/.goreleaser.yaml new file mode 100644 index 0000000..d7cfaf5 --- /dev/null +++ b/.goreleaser.yaml @@ -0,0 +1,22 @@ +# .goreleaser.yaml +builds: +- main: ./cmd/ + goos: + - linux + - darwin + goarch: + - amd64 + - arm64 + env: + - CGO_ENABLED=0 + ldflags: + - -X github.com/0xPolygonHermez/zkevm-ethtx-manager.Version={{.Version}} + - -X github.com/0xPolygonHermez/zkevm-ethtx-manager.GitRev={{.Commit}} + - -X github.com/0xPolygonHermez/zkevm-ethtx-manager.BuildDate={{.Date}} + - -X github.com/0xPolygonHermez/zkevm-ethtx-manager.GitBranch={{.Branch}} +release: + # If set to auto, will mark the release as not ready for production + # in case there is an indicator for this in the tag e.g. v1.0.0-rc1 + # If set to true, will mark the release as not ready for production. + # Default is false. + prerelease: true diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..5b7f025 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,20 @@ +# CONTAINER FOR BUILDING BINARY +FROM golang:1.21 AS build + +# INSTALL DEPENDENCIES +RUN go install github.com/gobuffalo/packr/v2/packr2@v2.8.3 +COPY go.mod go.sum /src/ +RUN cd /src && go mod download + +# BUILD BINARY +COPY . /src +RUN cd /src/db && packr2 +RUN cd /src && make build + +# CONTAINER FOR RUNNING BINARY +FROM alpine:3.18.4 +COPY --from=build /src/dist/zkevm-ethtx-manager /app/zkevm-ethtx-manager +COPY --from=build /src/config/environments/testnet/ethtxmanager.config.toml /app/example.config.toml +RUN apk update && apk add postgresql15-client +EXPOSE 8123 +CMD ["/bin/sh", "-c", "/app/zkevm-ethtx-manager run"] diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..6b7dcd6 --- /dev/null +++ b/LICENSE @@ -0,0 +1,636 @@ +Polygon zkEVM Mainnet Beta +Copyright (C) 2023 Catenable AG + + This program is free software: you can redistribute it and/or modify it +under the terms of the GNU Affero General Public License as published +by the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. + + This program is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY +or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public +License for more details. + + You should have received a copy of the GNU Affero General Public License +along with this program. If not, see . + + + GNU AFFERO GENERAL PUBLIC LICENSE + Version 3, 19 November 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU Affero General Public License is a free, copyleft license for +software and other kinds of works, specifically designed to ensure +cooperation with the community in the case of network server software. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +our General Public Licenses are intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + Developers that use our General Public Licenses protect your rights +with two steps: (1) assert copyright on the software, and (2) offer +you this License which gives you legal permission to copy, distribute +and/or modify the software. + + A secondary benefit of defending all users' freedom is that +improvements made in alternate versions of the program, if they +receive widespread use, become available for other developers to +incorporate. Many developers of free software are heartened and +encouraged by the resulting cooperation. However, in the case of +software used on network servers, this result may fail to come about. +The GNU General Public License permits making a modified version and +letting the public access it on a server without ever releasing its +source code to the public. + + The GNU Affero General Public License is designed specifically to +ensure that, in such cases, the modified source code becomes available +to the community. It requires the operator of a network server to +provide the source code of the modified version running there to the +users of that server. Therefore, public use of a modified version, on +a publicly accessible server, gives the public access to the source +code of the modified version. + + An older license, called the Affero General Public License and +published by Affero, was designed to accomplish similar goals. This is +a different license, not a version of the Affero GPL, but Affero has +released a new version of the Affero GPL which permits relicensing under +this license. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU Affero General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Remote Network Interaction; Use with the GNU General Public License. + + Notwithstanding any other provision of this License, if you modify the +Program, your modified version must prominently offer all users +interacting with it remotely through a computer network (if your version +supports such interaction) an opportunity to receive the Corresponding +Source of your version by providing access to the Corresponding Source +from a network server at no charge, through some standard or customary +means of facilitating copying of software. This Corresponding Source +shall include the Corresponding Source for any work covered by version 3 +of the GNU General Public License that is incorporated pursuant to the +following paragraph. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the work with which it is combined will remain governed by version +3 of the GNU General Public License. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU Affero General Public License from time to time. Such new versions +will be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU Affero General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU Affero General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU Affero General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..6c8b31b --- /dev/null +++ b/Makefile @@ -0,0 +1,92 @@ +include version.mk + +ARCH := $(shell arch) + +ifeq ($(ARCH),x86_64) + ARCH = amd64 +else + ifeq ($(ARCH),aarch64) + ARCH = arm64 + endif +endif +GOBASE := $(shell pwd) +GOBIN := $(GOBASE)/dist +GOENVVARS := GOBIN=$(GOBIN) CGO_ENABLED=0 GOOS=linux GOARCH=$(ARCH) +GOBINARY := zkevm-ethtx-manager +GOCMD := $(GOBASE)/cmd + +LDFLAGS += -X 'github.com/0xPolygonHermez/zkevm-ethtx-manager.Version=$(VERSION)' +LDFLAGS += -X 'github.com/0xPolygonHermez/zkevm-ethtx-manager=$(GITREV)' +LDFLAGS += -X 'github.com/0xPolygonHermez/zkevm-ethtx-manager=$(GITBRANCH)' +LDFLAGS += -X 'github.com/0xPolygonHermez/zkevm-ethtx-manager=$(DATE)' + +# Check dependencies +# Check for Go +.PHONY: check-go +check-go: + @which go > /dev/null || (echo "Error: Go is not installed" && exit 1) + +# Check for Docker +.PHONY: check-docker +check-docker: + @which docker > /dev/null || (echo "Error: docker is not installed" && exit 1) + +# Check for Docker-compose +.PHONY: check-docker-compose +check-docker-compose: + @which docker-compose > /dev/null || (echo "Error: docker-compose is not installed" && exit 1) + +# Check for Curl +.PHONY: check-curl +check-curl: + @which curl > /dev/null || (echo "Error: curl is not installed" && exit 1) + +# Targets that require the checks +build: check-go +lint: check-go +build-docker: check-docker +build-docker-nc: check-docker +run: check-docker check-docker-compose +stop: check-docker check-docker-compose +install-linter: check-go check-curl + +.PHONY: build +build: ## Builds the binary locally into ./dist + $(GOENVVARS) go build -ldflags "all=$(LDFLAGS)" -o $(GOBIN)/$(GOBINARY) $(GOCMD) + +.PHONY: build-docker +build-docker: ## Builds a docker image with the binary + docker build -t zkevm-ethtx-manager -f ./Dockerfile . + +.PHONY: build-docker-nc +build-docker-nc: ## Builds a docker image with the binary - but without build cache + docker build --no-cache=true -t zkevm-ethtx-manager -f ./Dockerfile . + +.PHONY: run-ethtxmanager +run: ## Runs the eth tx manager + docker-compose up -d zkevm-ethtx-manager-db + sleep 2 + docker-compose up -d zkevm-ethtx-manager + +.PHONY: stop +stop: ## Stops all services + docker-compose down + +.PHONY: install-linter +install-linter: ## Installs the linter + curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s -- -b $$(go env GOPATH)/bin v1.54.2 + +.PHONY: lint +lint: ## Runs the linter + export "GOROOT=$$(go env GOROOT)" && $$(go env GOPATH)/bin/golangci-lint run + +## Help display. +## Pulls comments from beside commands and prints a nicely formatted +## display with the commands and their usage information. +.DEFAULT_GOAL := help + +.PHONY: help +help: ## Prints this help + @grep -h -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) \ + | sort \ + | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}' diff --git a/aggregator/prover/aggregator.pb.go b/aggregator/prover/aggregator.pb.go new file mode 100644 index 0000000..aae6814 --- /dev/null +++ b/aggregator/prover/aggregator.pb.go @@ -0,0 +1,2471 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.31.0 +// protoc v4.25.1 +// source: aggregator.proto + +package prover + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +// * +// @dev Result +// - OK: succesfully completed +// - ERROR: request is not correct, i.e. input data is wrong +// - INTERNAL_ERROR: internal server error when delivering the response +type Result int32 + +const ( + Result_RESULT_UNSPECIFIED Result = 0 + Result_RESULT_OK Result = 1 + Result_RESULT_ERROR Result = 2 + Result_RESULT_INTERNAL_ERROR Result = 3 +) + +// Enum value maps for Result. +var ( + Result_name = map[int32]string{ + 0: "RESULT_UNSPECIFIED", + 1: "RESULT_OK", + 2: "RESULT_ERROR", + 3: "RESULT_INTERNAL_ERROR", + } + Result_value = map[string]int32{ + "RESULT_UNSPECIFIED": 0, + "RESULT_OK": 1, + "RESULT_ERROR": 2, + "RESULT_INTERNAL_ERROR": 3, + } +) + +func (x Result) Enum() *Result { + p := new(Result) + *p = x + return p +} + +func (x Result) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (Result) Descriptor() protoreflect.EnumDescriptor { + return file_aggregator_proto_enumTypes[0].Descriptor() +} + +func (Result) Type() protoreflect.EnumType { + return &file_aggregator_proto_enumTypes[0] +} + +func (x Result) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use Result.Descriptor instead. +func (Result) EnumDescriptor() ([]byte, []int) { + return file_aggregator_proto_rawDescGZIP(), []int{0} +} + +type GetStatusResponse_Status int32 + +const ( + GetStatusResponse_STATUS_UNSPECIFIED GetStatusResponse_Status = 0 + GetStatusResponse_STATUS_BOOTING GetStatusResponse_Status = 1 + GetStatusResponse_STATUS_COMPUTING GetStatusResponse_Status = 2 + GetStatusResponse_STATUS_IDLE GetStatusResponse_Status = 3 + GetStatusResponse_STATUS_HALT GetStatusResponse_Status = 4 +) + +// Enum value maps for GetStatusResponse_Status. +var ( + GetStatusResponse_Status_name = map[int32]string{ + 0: "STATUS_UNSPECIFIED", + 1: "STATUS_BOOTING", + 2: "STATUS_COMPUTING", + 3: "STATUS_IDLE", + 4: "STATUS_HALT", + } + GetStatusResponse_Status_value = map[string]int32{ + "STATUS_UNSPECIFIED": 0, + "STATUS_BOOTING": 1, + "STATUS_COMPUTING": 2, + "STATUS_IDLE": 3, + "STATUS_HALT": 4, + } +) + +func (x GetStatusResponse_Status) Enum() *GetStatusResponse_Status { + p := new(GetStatusResponse_Status) + *p = x + return p +} + +func (x GetStatusResponse_Status) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (GetStatusResponse_Status) Descriptor() protoreflect.EnumDescriptor { + return file_aggregator_proto_enumTypes[1].Descriptor() +} + +func (GetStatusResponse_Status) Type() protoreflect.EnumType { + return &file_aggregator_proto_enumTypes[1] +} + +func (x GetStatusResponse_Status) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use GetStatusResponse_Status.Descriptor instead. +func (GetStatusResponse_Status) EnumDescriptor() ([]byte, []int) { + return file_aggregator_proto_rawDescGZIP(), []int{9, 0} +} + +type GetProofResponse_Result int32 + +const ( + GetProofResponse_RESULT_UNSPECIFIED GetProofResponse_Result = 0 + GetProofResponse_RESULT_COMPLETED_OK GetProofResponse_Result = 1 + GetProofResponse_RESULT_ERROR GetProofResponse_Result = 2 + GetProofResponse_RESULT_COMPLETED_ERROR GetProofResponse_Result = 3 + GetProofResponse_RESULT_PENDING GetProofResponse_Result = 4 + GetProofResponse_RESULT_INTERNAL_ERROR GetProofResponse_Result = 5 + GetProofResponse_RESULT_CANCEL GetProofResponse_Result = 6 +) + +// Enum value maps for GetProofResponse_Result. +var ( + GetProofResponse_Result_name = map[int32]string{ + 0: "RESULT_UNSPECIFIED", + 1: "RESULT_COMPLETED_OK", + 2: "RESULT_ERROR", + 3: "RESULT_COMPLETED_ERROR", + 4: "RESULT_PENDING", + 5: "RESULT_INTERNAL_ERROR", + 6: "RESULT_CANCEL", + } + GetProofResponse_Result_value = map[string]int32{ + "RESULT_UNSPECIFIED": 0, + "RESULT_COMPLETED_OK": 1, + "RESULT_ERROR": 2, + "RESULT_COMPLETED_ERROR": 3, + "RESULT_PENDING": 4, + "RESULT_INTERNAL_ERROR": 5, + "RESULT_CANCEL": 6, + } +) + +func (x GetProofResponse_Result) Enum() *GetProofResponse_Result { + p := new(GetProofResponse_Result) + *p = x + return p +} + +func (x GetProofResponse_Result) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (GetProofResponse_Result) Descriptor() protoreflect.EnumDescriptor { + return file_aggregator_proto_enumTypes[2].Descriptor() +} + +func (GetProofResponse_Result) Type() protoreflect.EnumType { + return &file_aggregator_proto_enumTypes[2] +} + +func (x GetProofResponse_Result) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use GetProofResponse_Result.Descriptor instead. +func (GetProofResponse_Result) EnumDescriptor() ([]byte, []int) { + return file_aggregator_proto_rawDescGZIP(), []int{14, 0} +} + +type Version struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + V0_0_1 string `protobuf:"bytes,1,opt,name=v0_0_1,json=v001,proto3" json:"v0_0_1,omitempty"` +} + +func (x *Version) Reset() { + *x = Version{} + if protoimpl.UnsafeEnabled { + mi := &file_aggregator_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Version) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Version) ProtoMessage() {} + +func (x *Version) ProtoReflect() protoreflect.Message { + mi := &file_aggregator_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Version.ProtoReflect.Descriptor instead. +func (*Version) Descriptor() ([]byte, []int) { + return file_aggregator_proto_rawDescGZIP(), []int{0} +} + +func (x *Version) GetV0_0_1() string { + if x != nil { + return x.V0_0_1 + } + return "" +} + +type AggregatorMessage struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + // Types that are assignable to Request: + // + // *AggregatorMessage_GetStatusRequest + // *AggregatorMessage_GenBatchProofRequest + // *AggregatorMessage_GenAggregatedProofRequest + // *AggregatorMessage_GenFinalProofRequest + // *AggregatorMessage_CancelRequest + // *AggregatorMessage_GetProofRequest + Request isAggregatorMessage_Request `protobuf_oneof:"request"` +} + +func (x *AggregatorMessage) Reset() { + *x = AggregatorMessage{} + if protoimpl.UnsafeEnabled { + mi := &file_aggregator_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *AggregatorMessage) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AggregatorMessage) ProtoMessage() {} + +func (x *AggregatorMessage) ProtoReflect() protoreflect.Message { + mi := &file_aggregator_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AggregatorMessage.ProtoReflect.Descriptor instead. +func (*AggregatorMessage) Descriptor() ([]byte, []int) { + return file_aggregator_proto_rawDescGZIP(), []int{1} +} + +func (x *AggregatorMessage) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (m *AggregatorMessage) GetRequest() isAggregatorMessage_Request { + if m != nil { + return m.Request + } + return nil +} + +func (x *AggregatorMessage) GetGetStatusRequest() *GetStatusRequest { + if x, ok := x.GetRequest().(*AggregatorMessage_GetStatusRequest); ok { + return x.GetStatusRequest + } + return nil +} + +func (x *AggregatorMessage) GetGenBatchProofRequest() *GenBatchProofRequest { + if x, ok := x.GetRequest().(*AggregatorMessage_GenBatchProofRequest); ok { + return x.GenBatchProofRequest + } + return nil +} + +func (x *AggregatorMessage) GetGenAggregatedProofRequest() *GenAggregatedProofRequest { + if x, ok := x.GetRequest().(*AggregatorMessage_GenAggregatedProofRequest); ok { + return x.GenAggregatedProofRequest + } + return nil +} + +func (x *AggregatorMessage) GetGenFinalProofRequest() *GenFinalProofRequest { + if x, ok := x.GetRequest().(*AggregatorMessage_GenFinalProofRequest); ok { + return x.GenFinalProofRequest + } + return nil +} + +func (x *AggregatorMessage) GetCancelRequest() *CancelRequest { + if x, ok := x.GetRequest().(*AggregatorMessage_CancelRequest); ok { + return x.CancelRequest + } + return nil +} + +func (x *AggregatorMessage) GetGetProofRequest() *GetProofRequest { + if x, ok := x.GetRequest().(*AggregatorMessage_GetProofRequest); ok { + return x.GetProofRequest + } + return nil +} + +type isAggregatorMessage_Request interface { + isAggregatorMessage_Request() +} + +type AggregatorMessage_GetStatusRequest struct { + GetStatusRequest *GetStatusRequest `protobuf:"bytes,2,opt,name=get_status_request,json=getStatusRequest,proto3,oneof"` +} + +type AggregatorMessage_GenBatchProofRequest struct { + GenBatchProofRequest *GenBatchProofRequest `protobuf:"bytes,3,opt,name=gen_batch_proof_request,json=genBatchProofRequest,proto3,oneof"` +} + +type AggregatorMessage_GenAggregatedProofRequest struct { + GenAggregatedProofRequest *GenAggregatedProofRequest `protobuf:"bytes,4,opt,name=gen_aggregated_proof_request,json=genAggregatedProofRequest,proto3,oneof"` +} + +type AggregatorMessage_GenFinalProofRequest struct { + GenFinalProofRequest *GenFinalProofRequest `protobuf:"bytes,5,opt,name=gen_final_proof_request,json=genFinalProofRequest,proto3,oneof"` +} + +type AggregatorMessage_CancelRequest struct { + CancelRequest *CancelRequest `protobuf:"bytes,6,opt,name=cancel_request,json=cancelRequest,proto3,oneof"` +} + +type AggregatorMessage_GetProofRequest struct { + GetProofRequest *GetProofRequest `protobuf:"bytes,7,opt,name=get_proof_request,json=getProofRequest,proto3,oneof"` +} + +func (*AggregatorMessage_GetStatusRequest) isAggregatorMessage_Request() {} + +func (*AggregatorMessage_GenBatchProofRequest) isAggregatorMessage_Request() {} + +func (*AggregatorMessage_GenAggregatedProofRequest) isAggregatorMessage_Request() {} + +func (*AggregatorMessage_GenFinalProofRequest) isAggregatorMessage_Request() {} + +func (*AggregatorMessage_CancelRequest) isAggregatorMessage_Request() {} + +func (*AggregatorMessage_GetProofRequest) isAggregatorMessage_Request() {} + +type ProverMessage struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + // Types that are assignable to Response: + // + // *ProverMessage_GetStatusResponse + // *ProverMessage_GenBatchProofResponse + // *ProverMessage_GenAggregatedProofResponse + // *ProverMessage_GenFinalProofResponse + // *ProverMessage_CancelResponse + // *ProverMessage_GetProofResponse + Response isProverMessage_Response `protobuf_oneof:"response"` +} + +func (x *ProverMessage) Reset() { + *x = ProverMessage{} + if protoimpl.UnsafeEnabled { + mi := &file_aggregator_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ProverMessage) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ProverMessage) ProtoMessage() {} + +func (x *ProverMessage) ProtoReflect() protoreflect.Message { + mi := &file_aggregator_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ProverMessage.ProtoReflect.Descriptor instead. +func (*ProverMessage) Descriptor() ([]byte, []int) { + return file_aggregator_proto_rawDescGZIP(), []int{2} +} + +func (x *ProverMessage) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (m *ProverMessage) GetResponse() isProverMessage_Response { + if m != nil { + return m.Response + } + return nil +} + +func (x *ProverMessage) GetGetStatusResponse() *GetStatusResponse { + if x, ok := x.GetResponse().(*ProverMessage_GetStatusResponse); ok { + return x.GetStatusResponse + } + return nil +} + +func (x *ProverMessage) GetGenBatchProofResponse() *GenBatchProofResponse { + if x, ok := x.GetResponse().(*ProverMessage_GenBatchProofResponse); ok { + return x.GenBatchProofResponse + } + return nil +} + +func (x *ProverMessage) GetGenAggregatedProofResponse() *GenAggregatedProofResponse { + if x, ok := x.GetResponse().(*ProverMessage_GenAggregatedProofResponse); ok { + return x.GenAggregatedProofResponse + } + return nil +} + +func (x *ProverMessage) GetGenFinalProofResponse() *GenFinalProofResponse { + if x, ok := x.GetResponse().(*ProverMessage_GenFinalProofResponse); ok { + return x.GenFinalProofResponse + } + return nil +} + +func (x *ProverMessage) GetCancelResponse() *CancelResponse { + if x, ok := x.GetResponse().(*ProverMessage_CancelResponse); ok { + return x.CancelResponse + } + return nil +} + +func (x *ProverMessage) GetGetProofResponse() *GetProofResponse { + if x, ok := x.GetResponse().(*ProverMessage_GetProofResponse); ok { + return x.GetProofResponse + } + return nil +} + +type isProverMessage_Response interface { + isProverMessage_Response() +} + +type ProverMessage_GetStatusResponse struct { + GetStatusResponse *GetStatusResponse `protobuf:"bytes,2,opt,name=get_status_response,json=getStatusResponse,proto3,oneof"` +} + +type ProverMessage_GenBatchProofResponse struct { + GenBatchProofResponse *GenBatchProofResponse `protobuf:"bytes,3,opt,name=gen_batch_proof_response,json=genBatchProofResponse,proto3,oneof"` +} + +type ProverMessage_GenAggregatedProofResponse struct { + GenAggregatedProofResponse *GenAggregatedProofResponse `protobuf:"bytes,4,opt,name=gen_aggregated_proof_response,json=genAggregatedProofResponse,proto3,oneof"` +} + +type ProverMessage_GenFinalProofResponse struct { + GenFinalProofResponse *GenFinalProofResponse `protobuf:"bytes,5,opt,name=gen_final_proof_response,json=genFinalProofResponse,proto3,oneof"` +} + +type ProverMessage_CancelResponse struct { + CancelResponse *CancelResponse `protobuf:"bytes,6,opt,name=cancel_response,json=cancelResponse,proto3,oneof"` +} + +type ProverMessage_GetProofResponse struct { + GetProofResponse *GetProofResponse `protobuf:"bytes,7,opt,name=get_proof_response,json=getProofResponse,proto3,oneof"` +} + +func (*ProverMessage_GetStatusResponse) isProverMessage_Response() {} + +func (*ProverMessage_GenBatchProofResponse) isProverMessage_Response() {} + +func (*ProverMessage_GenAggregatedProofResponse) isProverMessage_Response() {} + +func (*ProverMessage_GenFinalProofResponse) isProverMessage_Response() {} + +func (*ProverMessage_CancelResponse) isProverMessage_Response() {} + +func (*ProverMessage_GetProofResponse) isProverMessage_Response() {} + +// * +// @dev GetStatusRequest +type GetStatusRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *GetStatusRequest) Reset() { + *x = GetStatusRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_aggregator_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetStatusRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetStatusRequest) ProtoMessage() {} + +func (x *GetStatusRequest) ProtoReflect() protoreflect.Message { + mi := &file_aggregator_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetStatusRequest.ProtoReflect.Descriptor instead. +func (*GetStatusRequest) Descriptor() ([]byte, []int) { + return file_aggregator_proto_rawDescGZIP(), []int{3} +} + +// * +// @dev GenBatchProofRequest +// @param {input} - input prover +type GenBatchProofRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Input *InputProver `protobuf:"bytes,1,opt,name=input,proto3" json:"input,omitempty"` +} + +func (x *GenBatchProofRequest) Reset() { + *x = GenBatchProofRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_aggregator_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GenBatchProofRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GenBatchProofRequest) ProtoMessage() {} + +func (x *GenBatchProofRequest) ProtoReflect() protoreflect.Message { + mi := &file_aggregator_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GenBatchProofRequest.ProtoReflect.Descriptor instead. +func (*GenBatchProofRequest) Descriptor() ([]byte, []int) { + return file_aggregator_proto_rawDescGZIP(), []int{4} +} + +func (x *GenBatchProofRequest) GetInput() *InputProver { + if x != nil { + return x.Input + } + return nil +} + +// * +// @dev GenAggregatedProofRequest +// @param {recursive_proof_1} - proof json of the first batch to aggregate +// @param {recursive_proof_2} - proof json of the second batch to aggregate +type GenAggregatedProofRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + RecursiveProof_1 string `protobuf:"bytes,1,opt,name=recursive_proof_1,json=recursiveProof1,proto3" json:"recursive_proof_1,omitempty"` + RecursiveProof_2 string `protobuf:"bytes,2,opt,name=recursive_proof_2,json=recursiveProof2,proto3" json:"recursive_proof_2,omitempty"` +} + +func (x *GenAggregatedProofRequest) Reset() { + *x = GenAggregatedProofRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_aggregator_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GenAggregatedProofRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GenAggregatedProofRequest) ProtoMessage() {} + +func (x *GenAggregatedProofRequest) ProtoReflect() protoreflect.Message { + mi := &file_aggregator_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GenAggregatedProofRequest.ProtoReflect.Descriptor instead. +func (*GenAggregatedProofRequest) Descriptor() ([]byte, []int) { + return file_aggregator_proto_rawDescGZIP(), []int{5} +} + +func (x *GenAggregatedProofRequest) GetRecursiveProof_1() string { + if x != nil { + return x.RecursiveProof_1 + } + return "" +} + +func (x *GenAggregatedProofRequest) GetRecursiveProof_2() string { + if x != nil { + return x.RecursiveProof_2 + } + return "" +} + +// * +// @dev GenFinalProofRequest +// @param {recursive_proof} - proof json of the batch or aggregated proof to finalise +// @param {aggregator_addr} - address of the aggregator +type GenFinalProofRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + RecursiveProof string `protobuf:"bytes,1,opt,name=recursive_proof,json=recursiveProof,proto3" json:"recursive_proof,omitempty"` + AggregatorAddr string `protobuf:"bytes,2,opt,name=aggregator_addr,json=aggregatorAddr,proto3" json:"aggregator_addr,omitempty"` +} + +func (x *GenFinalProofRequest) Reset() { + *x = GenFinalProofRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_aggregator_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GenFinalProofRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GenFinalProofRequest) ProtoMessage() {} + +func (x *GenFinalProofRequest) ProtoReflect() protoreflect.Message { + mi := &file_aggregator_proto_msgTypes[6] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GenFinalProofRequest.ProtoReflect.Descriptor instead. +func (*GenFinalProofRequest) Descriptor() ([]byte, []int) { + return file_aggregator_proto_rawDescGZIP(), []int{6} +} + +func (x *GenFinalProofRequest) GetRecursiveProof() string { + if x != nil { + return x.RecursiveProof + } + return "" +} + +func (x *GenFinalProofRequest) GetAggregatorAddr() string { + if x != nil { + return x.AggregatorAddr + } + return "" +} + +// * +// @dev CancelRequest +// @param {id} - identifier of the proof request to cancel +type CancelRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` +} + +func (x *CancelRequest) Reset() { + *x = CancelRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_aggregator_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CancelRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CancelRequest) ProtoMessage() {} + +func (x *CancelRequest) ProtoReflect() protoreflect.Message { + mi := &file_aggregator_proto_msgTypes[7] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CancelRequest.ProtoReflect.Descriptor instead. +func (*CancelRequest) Descriptor() ([]byte, []int) { + return file_aggregator_proto_rawDescGZIP(), []int{7} +} + +func (x *CancelRequest) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +// * +// @dev Request GetProof +// @param {id} - proof identifier of the proof request +// @param {timeout} - time to wait until the service responds +type GetProofRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Timeout uint64 `protobuf:"varint,2,opt,name=timeout,proto3" json:"timeout,omitempty"` +} + +func (x *GetProofRequest) Reset() { + *x = GetProofRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_aggregator_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetProofRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetProofRequest) ProtoMessage() {} + +func (x *GetProofRequest) ProtoReflect() protoreflect.Message { + mi := &file_aggregator_proto_msgTypes[8] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetProofRequest.ProtoReflect.Descriptor instead. +func (*GetProofRequest) Descriptor() ([]byte, []int) { + return file_aggregator_proto_rawDescGZIP(), []int{8} +} + +func (x *GetProofRequest) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *GetProofRequest) GetTimeout() uint64 { + if x != nil { + return x.Timeout + } + return 0 +} + +// * +// @dev Response GetStatus +// @param {status} - server status +// - BOOTING: being ready to compute proofs +// - COMPUTING: busy computing a proof +// - IDLE: waiting for a proof to compute +// - HALT: stop +// @param {last_computed_request_id} - last proof identifier that has been computed +// @param {last_computed_end_time} - last proof timestamp when it was finished +// @param {current_computing_request_id} - id of the proof that is being computed +// @param {current_computing_start_time} - timestamp when the proof that is being computed started +// @param {version_proto} - .proto verion +// @param {version_server} - server version +// @param {pending_request_queue_ids} - list of identifierss of proof requests that are in the pending queue +// @param {prover_name} - id of this prover server, normally specified via config.json, or UNSPECIFIED otherwise; it does not change if prover reboots +// @param {prover_id} - id of this prover instance or reboot; it changes if prover reboots; it is a UUID, automatically generated during the initialization +// @param {number_of_cores} - number of cores in the system where the prover is running +// @param {total_memory} - total memory in the system where the prover is running +// @param {free_memory} - free memory in the system where the prover is running +type GetStatusResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Status GetStatusResponse_Status `protobuf:"varint,1,opt,name=status,proto3,enum=aggregator.v1.GetStatusResponse_Status" json:"status,omitempty"` + LastComputedRequestId string `protobuf:"bytes,2,opt,name=last_computed_request_id,json=lastComputedRequestId,proto3" json:"last_computed_request_id,omitempty"` + LastComputedEndTime uint64 `protobuf:"varint,3,opt,name=last_computed_end_time,json=lastComputedEndTime,proto3" json:"last_computed_end_time,omitempty"` + CurrentComputingRequestId string `protobuf:"bytes,4,opt,name=current_computing_request_id,json=currentComputingRequestId,proto3" json:"current_computing_request_id,omitempty"` + CurrentComputingStartTime uint64 `protobuf:"varint,5,opt,name=current_computing_start_time,json=currentComputingStartTime,proto3" json:"current_computing_start_time,omitempty"` + VersionProto string `protobuf:"bytes,6,opt,name=version_proto,json=versionProto,proto3" json:"version_proto,omitempty"` + VersionServer string `protobuf:"bytes,7,opt,name=version_server,json=versionServer,proto3" json:"version_server,omitempty"` + PendingRequestQueueIds []string `protobuf:"bytes,8,rep,name=pending_request_queue_ids,json=pendingRequestQueueIds,proto3" json:"pending_request_queue_ids,omitempty"` + ProverName string `protobuf:"bytes,9,opt,name=prover_name,json=proverName,proto3" json:"prover_name,omitempty"` + ProverId string `protobuf:"bytes,10,opt,name=prover_id,json=proverId,proto3" json:"prover_id,omitempty"` + NumberOfCores uint64 `protobuf:"varint,11,opt,name=number_of_cores,json=numberOfCores,proto3" json:"number_of_cores,omitempty"` + TotalMemory uint64 `protobuf:"varint,12,opt,name=total_memory,json=totalMemory,proto3" json:"total_memory,omitempty"` + FreeMemory uint64 `protobuf:"varint,13,opt,name=free_memory,json=freeMemory,proto3" json:"free_memory,omitempty"` + ForkId uint64 `protobuf:"varint,14,opt,name=fork_id,json=forkId,proto3" json:"fork_id,omitempty"` +} + +func (x *GetStatusResponse) Reset() { + *x = GetStatusResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_aggregator_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetStatusResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetStatusResponse) ProtoMessage() {} + +func (x *GetStatusResponse) ProtoReflect() protoreflect.Message { + mi := &file_aggregator_proto_msgTypes[9] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetStatusResponse.ProtoReflect.Descriptor instead. +func (*GetStatusResponse) Descriptor() ([]byte, []int) { + return file_aggregator_proto_rawDescGZIP(), []int{9} +} + +func (x *GetStatusResponse) GetStatus() GetStatusResponse_Status { + if x != nil { + return x.Status + } + return GetStatusResponse_STATUS_UNSPECIFIED +} + +func (x *GetStatusResponse) GetLastComputedRequestId() string { + if x != nil { + return x.LastComputedRequestId + } + return "" +} + +func (x *GetStatusResponse) GetLastComputedEndTime() uint64 { + if x != nil { + return x.LastComputedEndTime + } + return 0 +} + +func (x *GetStatusResponse) GetCurrentComputingRequestId() string { + if x != nil { + return x.CurrentComputingRequestId + } + return "" +} + +func (x *GetStatusResponse) GetCurrentComputingStartTime() uint64 { + if x != nil { + return x.CurrentComputingStartTime + } + return 0 +} + +func (x *GetStatusResponse) GetVersionProto() string { + if x != nil { + return x.VersionProto + } + return "" +} + +func (x *GetStatusResponse) GetVersionServer() string { + if x != nil { + return x.VersionServer + } + return "" +} + +func (x *GetStatusResponse) GetPendingRequestQueueIds() []string { + if x != nil { + return x.PendingRequestQueueIds + } + return nil +} + +func (x *GetStatusResponse) GetProverName() string { + if x != nil { + return x.ProverName + } + return "" +} + +func (x *GetStatusResponse) GetProverId() string { + if x != nil { + return x.ProverId + } + return "" +} + +func (x *GetStatusResponse) GetNumberOfCores() uint64 { + if x != nil { + return x.NumberOfCores + } + return 0 +} + +func (x *GetStatusResponse) GetTotalMemory() uint64 { + if x != nil { + return x.TotalMemory + } + return 0 +} + +func (x *GetStatusResponse) GetFreeMemory() uint64 { + if x != nil { + return x.FreeMemory + } + return 0 +} + +func (x *GetStatusResponse) GetForkId() uint64 { + if x != nil { + return x.ForkId + } + return 0 +} + +// * +// @dev GenBatchProofResponse +// @param {id} - proof identifier, to be used in GetProofRequest() +// @param {result} - request result +type GenBatchProofResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Result Result `protobuf:"varint,2,opt,name=result,proto3,enum=aggregator.v1.Result" json:"result,omitempty"` +} + +func (x *GenBatchProofResponse) Reset() { + *x = GenBatchProofResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_aggregator_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GenBatchProofResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GenBatchProofResponse) ProtoMessage() {} + +func (x *GenBatchProofResponse) ProtoReflect() protoreflect.Message { + mi := &file_aggregator_proto_msgTypes[10] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GenBatchProofResponse.ProtoReflect.Descriptor instead. +func (*GenBatchProofResponse) Descriptor() ([]byte, []int) { + return file_aggregator_proto_rawDescGZIP(), []int{10} +} + +func (x *GenBatchProofResponse) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *GenBatchProofResponse) GetResult() Result { + if x != nil { + return x.Result + } + return Result_RESULT_UNSPECIFIED +} + +// * +// @dev GenAggregatedProofResponse +// @param {id} - proof identifier, to be used in GetProofRequest() +// @param {result} - request result +type GenAggregatedProofResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Result Result `protobuf:"varint,2,opt,name=result,proto3,enum=aggregator.v1.Result" json:"result,omitempty"` +} + +func (x *GenAggregatedProofResponse) Reset() { + *x = GenAggregatedProofResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_aggregator_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GenAggregatedProofResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GenAggregatedProofResponse) ProtoMessage() {} + +func (x *GenAggregatedProofResponse) ProtoReflect() protoreflect.Message { + mi := &file_aggregator_proto_msgTypes[11] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GenAggregatedProofResponse.ProtoReflect.Descriptor instead. +func (*GenAggregatedProofResponse) Descriptor() ([]byte, []int) { + return file_aggregator_proto_rawDescGZIP(), []int{11} +} + +func (x *GenAggregatedProofResponse) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *GenAggregatedProofResponse) GetResult() Result { + if x != nil { + return x.Result + } + return Result_RESULT_UNSPECIFIED +} + +// * +// @dev Response GenFinalProof +// @param {id} - proof identifier, to be used in GetProofRequest() +// @param {result} - request result +type GenFinalProofResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + Result Result `protobuf:"varint,2,opt,name=result,proto3,enum=aggregator.v1.Result" json:"result,omitempty"` +} + +func (x *GenFinalProofResponse) Reset() { + *x = GenFinalProofResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_aggregator_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GenFinalProofResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GenFinalProofResponse) ProtoMessage() {} + +func (x *GenFinalProofResponse) ProtoReflect() protoreflect.Message { + mi := &file_aggregator_proto_msgTypes[12] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GenFinalProofResponse.ProtoReflect.Descriptor instead. +func (*GenFinalProofResponse) Descriptor() ([]byte, []int) { + return file_aggregator_proto_rawDescGZIP(), []int{12} +} + +func (x *GenFinalProofResponse) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *GenFinalProofResponse) GetResult() Result { + if x != nil { + return x.Result + } + return Result_RESULT_UNSPECIFIED +} + +// * +// @dev CancelResponse +// @param {result} - request result +type CancelResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Result Result `protobuf:"varint,1,opt,name=result,proto3,enum=aggregator.v1.Result" json:"result,omitempty"` +} + +func (x *CancelResponse) Reset() { + *x = CancelResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_aggregator_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CancelResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CancelResponse) ProtoMessage() {} + +func (x *CancelResponse) ProtoReflect() protoreflect.Message { + mi := &file_aggregator_proto_msgTypes[13] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CancelResponse.ProtoReflect.Descriptor instead. +func (*CancelResponse) Descriptor() ([]byte, []int) { + return file_aggregator_proto_rawDescGZIP(), []int{13} +} + +func (x *CancelResponse) GetResult() Result { + if x != nil { + return x.Result + } + return Result_RESULT_UNSPECIFIED +} + +// * +// @dev GetProofResponse +// @param {id} - proof identifier +// @param {final_proof} - groth16 proof + public circuit inputs +// @param {recursive_proof} - recursive proof json +// @param {result} - proof result +// - COMPLETED_OK: proof has been computed successfully and it is valid +// - ERROR: request error +// - COMPLETED_ERROR: proof has been computed successfully and it is not valid +// - PENDING: proof is being computed +// - INTERNAL_ERROR: server error during proof computation +// - CANCEL: proof has been cancelled +// +// @param {result_string} - extends result information +type GetProofResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + // Types that are assignable to Proof: + // + // *GetProofResponse_FinalProof + // *GetProofResponse_RecursiveProof + Proof isGetProofResponse_Proof `protobuf_oneof:"proof"` + Result GetProofResponse_Result `protobuf:"varint,4,opt,name=result,proto3,enum=aggregator.v1.GetProofResponse_Result" json:"result,omitempty"` + ResultString string `protobuf:"bytes,5,opt,name=result_string,json=resultString,proto3" json:"result_string,omitempty"` +} + +func (x *GetProofResponse) Reset() { + *x = GetProofResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_aggregator_proto_msgTypes[14] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GetProofResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetProofResponse) ProtoMessage() {} + +func (x *GetProofResponse) ProtoReflect() protoreflect.Message { + mi := &file_aggregator_proto_msgTypes[14] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetProofResponse.ProtoReflect.Descriptor instead. +func (*GetProofResponse) Descriptor() ([]byte, []int) { + return file_aggregator_proto_rawDescGZIP(), []int{14} +} + +func (x *GetProofResponse) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (m *GetProofResponse) GetProof() isGetProofResponse_Proof { + if m != nil { + return m.Proof + } + return nil +} + +func (x *GetProofResponse) GetFinalProof() *FinalProof { + if x, ok := x.GetProof().(*GetProofResponse_FinalProof); ok { + return x.FinalProof + } + return nil +} + +func (x *GetProofResponse) GetRecursiveProof() string { + if x, ok := x.GetProof().(*GetProofResponse_RecursiveProof); ok { + return x.RecursiveProof + } + return "" +} + +func (x *GetProofResponse) GetResult() GetProofResponse_Result { + if x != nil { + return x.Result + } + return GetProofResponse_RESULT_UNSPECIFIED +} + +func (x *GetProofResponse) GetResultString() string { + if x != nil { + return x.ResultString + } + return "" +} + +type isGetProofResponse_Proof interface { + isGetProofResponse_Proof() +} + +type GetProofResponse_FinalProof struct { + FinalProof *FinalProof `protobuf:"bytes,2,opt,name=final_proof,json=finalProof,proto3,oneof"` +} + +type GetProofResponse_RecursiveProof struct { + RecursiveProof string `protobuf:"bytes,3,opt,name=recursive_proof,json=recursiveProof,proto3,oneof"` +} + +func (*GetProofResponse_FinalProof) isGetProofResponse_Proof() {} + +func (*GetProofResponse_RecursiveProof) isGetProofResponse_Proof() {} + +// @dev FinalProof +// @param {proof} - groth16 proof +// @param {public} - public circuit inputs +type FinalProof struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Proof string `protobuf:"bytes,1,opt,name=proof,proto3" json:"proof,omitempty"` + Public *PublicInputsExtended `protobuf:"bytes,2,opt,name=public,proto3" json:"public,omitempty"` +} + +func (x *FinalProof) Reset() { + *x = FinalProof{} + if protoimpl.UnsafeEnabled { + mi := &file_aggregator_proto_msgTypes[15] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *FinalProof) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FinalProof) ProtoMessage() {} + +func (x *FinalProof) ProtoReflect() protoreflect.Message { + mi := &file_aggregator_proto_msgTypes[15] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use FinalProof.ProtoReflect.Descriptor instead. +func (*FinalProof) Descriptor() ([]byte, []int) { + return file_aggregator_proto_rawDescGZIP(), []int{15} +} + +func (x *FinalProof) GetProof() string { + if x != nil { + return x.Proof + } + return "" +} + +func (x *FinalProof) GetPublic() *PublicInputsExtended { + if x != nil { + return x.Public + } + return nil +} + +// @dev PublicInputs +// @param {old_state_root} +// @param {old_acc_input_hash} +// @param {old_batch_num} +// @param {chain_id} +// @param {batch_l2_data} +// @param {global_exit_root} +// @param {sequencer_addr} +// @param {aggregator_addr} +type PublicInputs struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + OldStateRoot []byte `protobuf:"bytes,1,opt,name=old_state_root,json=oldStateRoot,proto3" json:"old_state_root,omitempty"` + OldAccInputHash []byte `protobuf:"bytes,2,opt,name=old_acc_input_hash,json=oldAccInputHash,proto3" json:"old_acc_input_hash,omitempty"` + OldBatchNum uint64 `protobuf:"varint,3,opt,name=old_batch_num,json=oldBatchNum,proto3" json:"old_batch_num,omitempty"` + ChainId uint64 `protobuf:"varint,4,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` + ForkId uint64 `protobuf:"varint,5,opt,name=fork_id,json=forkId,proto3" json:"fork_id,omitempty"` + BatchL2Data []byte `protobuf:"bytes,6,opt,name=batch_l2_data,json=batchL2Data,proto3" json:"batch_l2_data,omitempty"` + L1InfoRoot []byte `protobuf:"bytes,7,opt,name=l1_info_root,json=l1InfoRoot,proto3" json:"l1_info_root,omitempty"` + TimestampLimit uint64 `protobuf:"varint,8,opt,name=timestamp_limit,json=timestampLimit,proto3" json:"timestamp_limit,omitempty"` + SequencerAddr string `protobuf:"bytes,9,opt,name=sequencer_addr,json=sequencerAddr,proto3" json:"sequencer_addr,omitempty"` + ForcedBlockhashL1 []byte `protobuf:"bytes,10,opt,name=forced_blockhash_l1,json=forcedBlockhashL1,proto3" json:"forced_blockhash_l1,omitempty"` + AggregatorAddr string `protobuf:"bytes,12,opt,name=aggregator_addr,json=aggregatorAddr,proto3" json:"aggregator_addr,omitempty"` + L1InfoTreeData map[uint32]*L1Data `protobuf:"bytes,16,rep,name=l1_info_tree_data,json=l1InfoTreeData,proto3" json:"l1_info_tree_data,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} + +func (x *PublicInputs) Reset() { + *x = PublicInputs{} + if protoimpl.UnsafeEnabled { + mi := &file_aggregator_proto_msgTypes[16] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *PublicInputs) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PublicInputs) ProtoMessage() {} + +func (x *PublicInputs) ProtoReflect() protoreflect.Message { + mi := &file_aggregator_proto_msgTypes[16] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use PublicInputs.ProtoReflect.Descriptor instead. +func (*PublicInputs) Descriptor() ([]byte, []int) { + return file_aggregator_proto_rawDescGZIP(), []int{16} +} + +func (x *PublicInputs) GetOldStateRoot() []byte { + if x != nil { + return x.OldStateRoot + } + return nil +} + +func (x *PublicInputs) GetOldAccInputHash() []byte { + if x != nil { + return x.OldAccInputHash + } + return nil +} + +func (x *PublicInputs) GetOldBatchNum() uint64 { + if x != nil { + return x.OldBatchNum + } + return 0 +} + +func (x *PublicInputs) GetChainId() uint64 { + if x != nil { + return x.ChainId + } + return 0 +} + +func (x *PublicInputs) GetForkId() uint64 { + if x != nil { + return x.ForkId + } + return 0 +} + +func (x *PublicInputs) GetBatchL2Data() []byte { + if x != nil { + return x.BatchL2Data + } + return nil +} + +func (x *PublicInputs) GetL1InfoRoot() []byte { + if x != nil { + return x.L1InfoRoot + } + return nil +} + +func (x *PublicInputs) GetTimestampLimit() uint64 { + if x != nil { + return x.TimestampLimit + } + return 0 +} + +func (x *PublicInputs) GetSequencerAddr() string { + if x != nil { + return x.SequencerAddr + } + return "" +} + +func (x *PublicInputs) GetForcedBlockhashL1() []byte { + if x != nil { + return x.ForcedBlockhashL1 + } + return nil +} + +func (x *PublicInputs) GetAggregatorAddr() string { + if x != nil { + return x.AggregatorAddr + } + return "" +} + +func (x *PublicInputs) GetL1InfoTreeData() map[uint32]*L1Data { + if x != nil { + return x.L1InfoTreeData + } + return nil +} + +// l1InfoTree leaf values +type L1Data struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + GlobalExitRoot []byte `protobuf:"bytes,1,opt,name=global_exit_root,json=globalExitRoot,proto3" json:"global_exit_root,omitempty"` + BlockhashL1 []byte `protobuf:"bytes,2,opt,name=blockhash_l1,json=blockhashL1,proto3" json:"blockhash_l1,omitempty"` + MinTimestamp uint32 `protobuf:"varint,3,opt,name=min_timestamp,json=minTimestamp,proto3" json:"min_timestamp,omitempty"` + SmtProof [][]byte `protobuf:"bytes,4,rep,name=smt_proof,json=smtProof,proto3" json:"smt_proof,omitempty"` +} + +func (x *L1Data) Reset() { + *x = L1Data{} + if protoimpl.UnsafeEnabled { + mi := &file_aggregator_proto_msgTypes[17] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *L1Data) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*L1Data) ProtoMessage() {} + +func (x *L1Data) ProtoReflect() protoreflect.Message { + mi := &file_aggregator_proto_msgTypes[17] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use L1Data.ProtoReflect.Descriptor instead. +func (*L1Data) Descriptor() ([]byte, []int) { + return file_aggregator_proto_rawDescGZIP(), []int{17} +} + +func (x *L1Data) GetGlobalExitRoot() []byte { + if x != nil { + return x.GlobalExitRoot + } + return nil +} + +func (x *L1Data) GetBlockhashL1() []byte { + if x != nil { + return x.BlockhashL1 + } + return nil +} + +func (x *L1Data) GetMinTimestamp() uint32 { + if x != nil { + return x.MinTimestamp + } + return 0 +} + +func (x *L1Data) GetSmtProof() [][]byte { + if x != nil { + return x.SmtProof + } + return nil +} + +// * +// @dev InputProver +// @param {public_inputs} - public inputs +// @param {db} - database containing all key-values in smt matching the old state root +// @param {contracts_bytecode} - key is the hash(contractBytecode), value is the bytecode itself +type InputProver struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + PublicInputs *PublicInputs `protobuf:"bytes,1,opt,name=public_inputs,json=publicInputs,proto3" json:"public_inputs,omitempty"` + Db map[string]string `protobuf:"bytes,4,rep,name=db,proto3" json:"db,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` // For debug/testing purpposes only. Don't fill this on production + ContractsBytecode map[string]string `protobuf:"bytes,5,rep,name=contracts_bytecode,json=contractsBytecode,proto3" json:"contracts_bytecode,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` // For debug/testing purpposes only. Don't fill this on production +} + +func (x *InputProver) Reset() { + *x = InputProver{} + if protoimpl.UnsafeEnabled { + mi := &file_aggregator_proto_msgTypes[18] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *InputProver) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*InputProver) ProtoMessage() {} + +func (x *InputProver) ProtoReflect() protoreflect.Message { + mi := &file_aggregator_proto_msgTypes[18] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use InputProver.ProtoReflect.Descriptor instead. +func (*InputProver) Descriptor() ([]byte, []int) { + return file_aggregator_proto_rawDescGZIP(), []int{18} +} + +func (x *InputProver) GetPublicInputs() *PublicInputs { + if x != nil { + return x.PublicInputs + } + return nil +} + +func (x *InputProver) GetDb() map[string]string { + if x != nil { + return x.Db + } + return nil +} + +func (x *InputProver) GetContractsBytecode() map[string]string { + if x != nil { + return x.ContractsBytecode + } + return nil +} + +// * +// @dev PublicInputsExtended +// @param {public_inputs} - public inputs +// @param {new_state_root} - final state root. Used as a sanity check. +// @param {new_acc_input_hash} - final accumulate input hash. Used as a sanity check. +// @param {new_local_exit_root} - new local exit root. Used as a sanity check. +// @param {new_batch_num} - final num batch. Used as a sanity check. +type PublicInputsExtended struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + PublicInputs *PublicInputs `protobuf:"bytes,1,opt,name=public_inputs,json=publicInputs,proto3" json:"public_inputs,omitempty"` + NewStateRoot []byte `protobuf:"bytes,2,opt,name=new_state_root,json=newStateRoot,proto3" json:"new_state_root,omitempty"` + NewAccInputHash []byte `protobuf:"bytes,3,opt,name=new_acc_input_hash,json=newAccInputHash,proto3" json:"new_acc_input_hash,omitempty"` + NewLocalExitRoot []byte `protobuf:"bytes,4,opt,name=new_local_exit_root,json=newLocalExitRoot,proto3" json:"new_local_exit_root,omitempty"` + NewBatchNum uint64 `protobuf:"varint,5,opt,name=new_batch_num,json=newBatchNum,proto3" json:"new_batch_num,omitempty"` +} + +func (x *PublicInputsExtended) Reset() { + *x = PublicInputsExtended{} + if protoimpl.UnsafeEnabled { + mi := &file_aggregator_proto_msgTypes[19] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *PublicInputsExtended) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PublicInputsExtended) ProtoMessage() {} + +func (x *PublicInputsExtended) ProtoReflect() protoreflect.Message { + mi := &file_aggregator_proto_msgTypes[19] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use PublicInputsExtended.ProtoReflect.Descriptor instead. +func (*PublicInputsExtended) Descriptor() ([]byte, []int) { + return file_aggregator_proto_rawDescGZIP(), []int{19} +} + +func (x *PublicInputsExtended) GetPublicInputs() *PublicInputs { + if x != nil { + return x.PublicInputs + } + return nil +} + +func (x *PublicInputsExtended) GetNewStateRoot() []byte { + if x != nil { + return x.NewStateRoot + } + return nil +} + +func (x *PublicInputsExtended) GetNewAccInputHash() []byte { + if x != nil { + return x.NewAccInputHash + } + return nil +} + +func (x *PublicInputsExtended) GetNewLocalExitRoot() []byte { + if x != nil { + return x.NewLocalExitRoot + } + return nil +} + +func (x *PublicInputsExtended) GetNewBatchNum() uint64 { + if x != nil { + return x.NewBatchNum + } + return 0 +} + +var File_aggregator_proto protoreflect.FileDescriptor + +var file_aggregator_proto_rawDesc = []byte{ + 0x0a, 0x10, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x12, 0x0d, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x76, + 0x31, 0x22, 0x1f, 0x0a, 0x07, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x14, 0x0a, 0x06, + 0x76, 0x30, 0x5f, 0x30, 0x5f, 0x31, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x76, 0x30, + 0x30, 0x31, 0x22, 0xbd, 0x04, 0x0a, 0x11, 0x41, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x6f, + 0x72, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x4f, 0x0a, 0x12, 0x67, 0x65, 0x74, 0x5f, + 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x6f, + 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x48, 0x00, 0x52, 0x10, 0x67, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, + 0x75, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x5c, 0x0a, 0x17, 0x67, 0x65, 0x6e, + 0x5f, 0x62, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x5f, 0x72, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x61, 0x67, 0x67, + 0x72, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x6e, 0x42, 0x61, + 0x74, 0x63, 0x68, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x48, + 0x00, 0x52, 0x14, 0x67, 0x65, 0x6e, 0x42, 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, 0x6f, 0x6f, 0x66, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x6b, 0x0a, 0x1c, 0x67, 0x65, 0x6e, 0x5f, 0x61, + 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x5f, + 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, + 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, + 0x6e, 0x41, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x65, 0x64, 0x50, 0x72, 0x6f, 0x6f, 0x66, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x48, 0x00, 0x52, 0x19, 0x67, 0x65, 0x6e, 0x41, 0x67, + 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x65, 0x64, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x12, 0x5c, 0x0a, 0x17, 0x67, 0x65, 0x6e, 0x5f, 0x66, 0x69, 0x6e, 0x61, + 0x6c, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, + 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, + 0x6f, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x6e, 0x46, 0x69, 0x6e, 0x61, 0x6c, 0x50, 0x72, + 0x6f, 0x6f, 0x66, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x48, 0x00, 0x52, 0x14, 0x67, 0x65, + 0x6e, 0x46, 0x69, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x45, 0x0a, 0x0e, 0x63, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x5f, 0x72, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x61, 0x67, 0x67, + 0x72, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x61, 0x6e, 0x63, 0x65, + 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x48, 0x00, 0x52, 0x0d, 0x63, 0x61, 0x6e, 0x63, + 0x65, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x4c, 0x0a, 0x11, 0x67, 0x65, 0x74, + 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, 0x07, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x6f, + 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x48, 0x00, 0x52, 0x0f, 0x67, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x6f, 0x66, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x42, 0x09, 0x0a, 0x07, 0x72, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x22, 0xcc, 0x04, 0x0a, 0x0d, 0x50, 0x72, 0x6f, 0x76, 0x65, 0x72, 0x4d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x02, 0x69, 0x64, 0x12, 0x52, 0x0a, 0x13, 0x67, 0x65, 0x74, 0x5f, 0x73, 0x74, 0x61, 0x74, + 0x75, 0x73, 0x5f, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x20, 0x2e, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x76, + 0x31, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x48, 0x00, 0x52, 0x11, 0x67, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x5f, 0x0a, 0x18, 0x67, 0x65, 0x6e, 0x5f, + 0x62, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x5f, 0x72, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x61, 0x67, 0x67, + 0x72, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x6e, 0x42, 0x61, + 0x74, 0x63, 0x68, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x48, 0x00, 0x52, 0x15, 0x67, 0x65, 0x6e, 0x42, 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, 0x6f, 0x6f, + 0x66, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x6e, 0x0a, 0x1d, 0x67, 0x65, 0x6e, + 0x5f, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x70, 0x72, 0x6f, 0x6f, + 0x66, 0x5f, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x29, 0x2e, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x76, 0x31, + 0x2e, 0x47, 0x65, 0x6e, 0x41, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x65, 0x64, 0x50, 0x72, + 0x6f, 0x6f, 0x66, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x48, 0x00, 0x52, 0x1a, 0x67, + 0x65, 0x6e, 0x41, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x65, 0x64, 0x50, 0x72, 0x6f, 0x6f, + 0x66, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x5f, 0x0a, 0x18, 0x67, 0x65, 0x6e, + 0x5f, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x5f, 0x72, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x61, 0x67, + 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x6e, 0x46, + 0x69, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x48, 0x00, 0x52, 0x15, 0x67, 0x65, 0x6e, 0x46, 0x69, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, + 0x6f, 0x66, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x48, 0x0a, 0x0f, 0x63, 0x61, + 0x6e, 0x63, 0x65, 0x6c, 0x5f, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x18, 0x06, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, + 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x48, 0x00, 0x52, 0x0e, 0x63, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4f, 0x0a, 0x12, 0x67, 0x65, 0x74, 0x5f, 0x70, 0x72, 0x6f, 0x6f, + 0x66, 0x5f, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1f, 0x2e, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x76, 0x31, + 0x2e, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x48, 0x00, 0x52, 0x10, 0x67, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x42, 0x0a, 0x0a, 0x08, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x22, 0x12, 0x0a, 0x10, 0x47, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x48, 0x0a, 0x14, 0x47, 0x65, 0x6e, 0x42, 0x61, 0x74, 0x63, + 0x68, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x30, 0x0a, + 0x05, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x61, + 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x70, + 0x75, 0x74, 0x50, 0x72, 0x6f, 0x76, 0x65, 0x72, 0x52, 0x05, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x22, + 0x73, 0x0a, 0x19, 0x47, 0x65, 0x6e, 0x41, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x65, 0x64, + 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x2a, 0x0a, 0x11, + 0x72, 0x65, 0x63, 0x75, 0x72, 0x73, 0x69, 0x76, 0x65, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x5f, + 0x31, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x72, 0x65, 0x63, 0x75, 0x72, 0x73, 0x69, + 0x76, 0x65, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x31, 0x12, 0x2a, 0x0a, 0x11, 0x72, 0x65, 0x63, 0x75, + 0x72, 0x73, 0x69, 0x76, 0x65, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x5f, 0x32, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x0f, 0x72, 0x65, 0x63, 0x75, 0x72, 0x73, 0x69, 0x76, 0x65, 0x50, 0x72, + 0x6f, 0x6f, 0x66, 0x32, 0x22, 0x68, 0x0a, 0x14, 0x47, 0x65, 0x6e, 0x46, 0x69, 0x6e, 0x61, 0x6c, + 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x27, 0x0a, 0x0f, + 0x72, 0x65, 0x63, 0x75, 0x72, 0x73, 0x69, 0x76, 0x65, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x72, 0x65, 0x63, 0x75, 0x72, 0x73, 0x69, 0x76, 0x65, + 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x12, 0x27, 0x0a, 0x0f, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, + 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, + 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x22, 0x1f, + 0x0a, 0x0d, 0x43, 0x61, 0x6e, 0x63, 0x65, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, + 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x22, + 0x3b, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, + 0x69, 0x64, 0x12, 0x18, 0x0a, 0x07, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x04, 0x52, 0x07, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x22, 0xfc, 0x05, 0x0a, + 0x11, 0x47, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x12, 0x3f, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0e, 0x32, 0x27, 0x2e, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x2e, + 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x12, 0x37, 0x0a, 0x18, 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x63, 0x6f, 0x6d, 0x70, + 0x75, 0x74, 0x65, 0x64, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x5f, 0x69, 0x64, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x15, 0x6c, 0x61, 0x73, 0x74, 0x43, 0x6f, 0x6d, 0x70, 0x75, + 0x74, 0x65, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x49, 0x64, 0x12, 0x33, 0x0a, 0x16, + 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x63, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x65, 0x64, 0x5f, 0x65, 0x6e, + 0x64, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x13, 0x6c, 0x61, + 0x73, 0x74, 0x43, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x64, 0x54, 0x69, 0x6d, + 0x65, 0x12, 0x3f, 0x0a, 0x1c, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x63, 0x6f, 0x6d, + 0x70, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x5f, 0x69, + 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x19, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, + 0x43, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x49, 0x64, 0x12, 0x3f, 0x0a, 0x1c, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x63, 0x6f, + 0x6d, 0x70, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x5f, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, + 0x6d, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x52, 0x19, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, + 0x74, 0x43, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x61, 0x72, 0x74, 0x54, + 0x69, 0x6d, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x76, 0x65, 0x72, 0x73, + 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x25, 0x0a, 0x0e, 0x76, 0x65, 0x72, 0x73, + 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x0d, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x12, + 0x39, 0x0a, 0x19, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x5f, 0x71, 0x75, 0x65, 0x75, 0x65, 0x5f, 0x69, 0x64, 0x73, 0x18, 0x08, 0x20, 0x03, + 0x28, 0x09, 0x52, 0x16, 0x70, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x51, 0x75, 0x65, 0x75, 0x65, 0x49, 0x64, 0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x72, + 0x6f, 0x76, 0x65, 0x72, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0a, 0x70, 0x72, 0x6f, 0x76, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x70, + 0x72, 0x6f, 0x76, 0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, + 0x70, 0x72, 0x6f, 0x76, 0x65, 0x72, 0x49, 0x64, 0x12, 0x26, 0x0a, 0x0f, 0x6e, 0x75, 0x6d, 0x62, + 0x65, 0x72, 0x5f, 0x6f, 0x66, 0x5f, 0x63, 0x6f, 0x72, 0x65, 0x73, 0x18, 0x0b, 0x20, 0x01, 0x28, + 0x04, 0x52, 0x0d, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x4f, 0x66, 0x43, 0x6f, 0x72, 0x65, 0x73, + 0x12, 0x21, 0x0a, 0x0c, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, + 0x18, 0x0c, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x4d, 0x65, 0x6d, + 0x6f, 0x72, 0x79, 0x12, 0x1f, 0x0a, 0x0b, 0x66, 0x72, 0x65, 0x65, 0x5f, 0x6d, 0x65, 0x6d, 0x6f, + 0x72, 0x79, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x66, 0x72, 0x65, 0x65, 0x4d, 0x65, + 0x6d, 0x6f, 0x72, 0x79, 0x12, 0x17, 0x0a, 0x07, 0x66, 0x6f, 0x72, 0x6b, 0x5f, 0x69, 0x64, 0x18, + 0x0e, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x66, 0x6f, 0x72, 0x6b, 0x49, 0x64, 0x22, 0x6c, 0x0a, + 0x06, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x16, 0x0a, 0x12, 0x53, 0x54, 0x41, 0x54, 0x55, + 0x53, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, + 0x12, 0x0a, 0x0e, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x42, 0x4f, 0x4f, 0x54, 0x49, 0x4e, + 0x47, 0x10, 0x01, 0x12, 0x14, 0x0a, 0x10, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x43, 0x4f, + 0x4d, 0x50, 0x55, 0x54, 0x49, 0x4e, 0x47, 0x10, 0x02, 0x12, 0x0f, 0x0a, 0x0b, 0x53, 0x54, 0x41, + 0x54, 0x55, 0x53, 0x5f, 0x49, 0x44, 0x4c, 0x45, 0x10, 0x03, 0x12, 0x0f, 0x0a, 0x0b, 0x53, 0x54, + 0x41, 0x54, 0x55, 0x53, 0x5f, 0x48, 0x41, 0x4c, 0x54, 0x10, 0x04, 0x22, 0x56, 0x0a, 0x15, 0x47, + 0x65, 0x6e, 0x42, 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x02, 0x69, 0x64, 0x12, 0x2d, 0x0a, 0x06, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0e, 0x32, 0x15, 0x2e, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x6f, + 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, 0x06, 0x72, 0x65, 0x73, + 0x75, 0x6c, 0x74, 0x22, 0x5b, 0x0a, 0x1a, 0x47, 0x65, 0x6e, 0x41, 0x67, 0x67, 0x72, 0x65, 0x67, + 0x61, 0x74, 0x65, 0x64, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, + 0x64, 0x12, 0x2d, 0x0a, 0x06, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0e, 0x32, 0x15, 0x2e, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x76, + 0x31, 0x2e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, 0x06, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, + 0x22, 0x56, 0x0a, 0x15, 0x47, 0x65, 0x6e, 0x46, 0x69, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x6f, + 0x66, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x2d, 0x0a, 0x06, 0x72, 0x65, 0x73, + 0x75, 0x6c, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x15, 0x2e, 0x61, 0x67, 0x67, 0x72, + 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, + 0x52, 0x06, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x3f, 0x0a, 0x0e, 0x43, 0x61, 0x6e, 0x63, + 0x65, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x2d, 0x0a, 0x06, 0x72, 0x65, + 0x73, 0x75, 0x6c, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x15, 0x2e, 0x61, 0x67, 0x67, + 0x72, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x73, 0x75, 0x6c, + 0x74, 0x52, 0x06, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0xa5, 0x03, 0x0a, 0x10, 0x47, 0x65, + 0x74, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x0e, + 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x3c, + 0x0a, 0x0b, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, + 0x2e, 0x76, 0x31, 0x2e, 0x46, 0x69, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x48, 0x00, + 0x52, 0x0a, 0x66, 0x69, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x12, 0x29, 0x0a, 0x0f, + 0x72, 0x65, 0x63, 0x75, 0x72, 0x73, 0x69, 0x76, 0x65, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0e, 0x72, 0x65, 0x63, 0x75, 0x72, 0x73, 0x69, + 0x76, 0x65, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x12, 0x3e, 0x0a, 0x06, 0x72, 0x65, 0x73, 0x75, 0x6c, + 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x26, 0x2e, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, + 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x47, 0x65, 0x74, 0x50, 0x72, 0x6f, 0x6f, 0x66, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, + 0x06, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x73, 0x75, 0x6c, + 0x74, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, + 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0xa9, 0x01, 0x0a, + 0x06, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x12, 0x16, 0x0a, 0x12, 0x52, 0x45, 0x53, 0x55, 0x4c, + 0x54, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, + 0x17, 0x0a, 0x13, 0x52, 0x45, 0x53, 0x55, 0x4c, 0x54, 0x5f, 0x43, 0x4f, 0x4d, 0x50, 0x4c, 0x45, + 0x54, 0x45, 0x44, 0x5f, 0x4f, 0x4b, 0x10, 0x01, 0x12, 0x10, 0x0a, 0x0c, 0x52, 0x45, 0x53, 0x55, + 0x4c, 0x54, 0x5f, 0x45, 0x52, 0x52, 0x4f, 0x52, 0x10, 0x02, 0x12, 0x1a, 0x0a, 0x16, 0x52, 0x45, + 0x53, 0x55, 0x4c, 0x54, 0x5f, 0x43, 0x4f, 0x4d, 0x50, 0x4c, 0x45, 0x54, 0x45, 0x44, 0x5f, 0x45, + 0x52, 0x52, 0x4f, 0x52, 0x10, 0x03, 0x12, 0x12, 0x0a, 0x0e, 0x52, 0x45, 0x53, 0x55, 0x4c, 0x54, + 0x5f, 0x50, 0x45, 0x4e, 0x44, 0x49, 0x4e, 0x47, 0x10, 0x04, 0x12, 0x19, 0x0a, 0x15, 0x52, 0x45, + 0x53, 0x55, 0x4c, 0x54, 0x5f, 0x49, 0x4e, 0x54, 0x45, 0x52, 0x4e, 0x41, 0x4c, 0x5f, 0x45, 0x52, + 0x52, 0x4f, 0x52, 0x10, 0x05, 0x12, 0x11, 0x0a, 0x0d, 0x52, 0x45, 0x53, 0x55, 0x4c, 0x54, 0x5f, + 0x43, 0x41, 0x4e, 0x43, 0x45, 0x4c, 0x10, 0x06, 0x42, 0x07, 0x0a, 0x05, 0x70, 0x72, 0x6f, 0x6f, + 0x66, 0x22, 0x5f, 0x0a, 0x0a, 0x46, 0x69, 0x6e, 0x61, 0x6c, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x12, + 0x14, 0x0a, 0x05, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, + 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x12, 0x3b, 0x0a, 0x06, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, + 0x6f, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x49, 0x6e, 0x70, 0x75, + 0x74, 0x73, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x65, 0x64, 0x52, 0x06, 0x70, 0x75, 0x62, 0x6c, + 0x69, 0x63, 0x22, 0xde, 0x04, 0x0a, 0x0c, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x49, 0x6e, 0x70, + 0x75, 0x74, 0x73, 0x12, 0x24, 0x0a, 0x0e, 0x6f, 0x6c, 0x64, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x65, + 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0c, 0x6f, 0x6c, 0x64, + 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x2b, 0x0a, 0x12, 0x6f, 0x6c, 0x64, + 0x5f, 0x61, 0x63, 0x63, 0x5f, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0f, 0x6f, 0x6c, 0x64, 0x41, 0x63, 0x63, 0x49, 0x6e, 0x70, + 0x75, 0x74, 0x48, 0x61, 0x73, 0x68, 0x12, 0x22, 0x0a, 0x0d, 0x6f, 0x6c, 0x64, 0x5f, 0x62, 0x61, + 0x74, 0x63, 0x68, 0x5f, 0x6e, 0x75, 0x6d, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x6f, + 0x6c, 0x64, 0x42, 0x61, 0x74, 0x63, 0x68, 0x4e, 0x75, 0x6d, 0x12, 0x19, 0x0a, 0x08, 0x63, 0x68, + 0x61, 0x69, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x07, 0x63, 0x68, + 0x61, 0x69, 0x6e, 0x49, 0x64, 0x12, 0x17, 0x0a, 0x07, 0x66, 0x6f, 0x72, 0x6b, 0x5f, 0x69, 0x64, + 0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x66, 0x6f, 0x72, 0x6b, 0x49, 0x64, 0x12, 0x22, + 0x0a, 0x0d, 0x62, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x6c, 0x32, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, + 0x06, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x62, 0x61, 0x74, 0x63, 0x68, 0x4c, 0x32, 0x44, 0x61, + 0x74, 0x61, 0x12, 0x20, 0x0a, 0x0c, 0x6c, 0x31, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x5f, 0x72, 0x6f, + 0x6f, 0x74, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x6c, 0x31, 0x49, 0x6e, 0x66, 0x6f, + 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x27, 0x0a, 0x0f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, + 0x70, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x08, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0e, 0x74, + 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x12, 0x25, 0x0a, + 0x0e, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x18, + 0x09, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x72, + 0x41, 0x64, 0x64, 0x72, 0x12, 0x2e, 0x0a, 0x13, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x64, 0x5f, 0x62, + 0x6c, 0x6f, 0x63, 0x6b, 0x68, 0x61, 0x73, 0x68, 0x5f, 0x6c, 0x31, 0x18, 0x0a, 0x20, 0x01, 0x28, + 0x0c, 0x52, 0x11, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x64, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x68, 0x61, + 0x73, 0x68, 0x4c, 0x31, 0x12, 0x27, 0x0a, 0x0f, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, + 0x6f, 0x72, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x61, + 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, 0x72, 0x12, 0x5a, 0x0a, + 0x11, 0x6c, 0x31, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x5f, 0x74, 0x72, 0x65, 0x65, 0x5f, 0x64, 0x61, + 0x74, 0x61, 0x18, 0x10, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x61, 0x67, 0x67, 0x72, 0x65, + 0x67, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x49, + 0x6e, 0x70, 0x75, 0x74, 0x73, 0x2e, 0x4c, 0x31, 0x49, 0x6e, 0x66, 0x6f, 0x54, 0x72, 0x65, 0x65, + 0x44, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0e, 0x6c, 0x31, 0x49, 0x6e, 0x66, + 0x6f, 0x54, 0x72, 0x65, 0x65, 0x44, 0x61, 0x74, 0x61, 0x1a, 0x58, 0x0a, 0x13, 0x4c, 0x31, 0x49, + 0x6e, 0x66, 0x6f, 0x54, 0x72, 0x65, 0x65, 0x44, 0x61, 0x74, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, + 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x03, 0x6b, + 0x65, 0x79, 0x12, 0x2b, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x15, 0x2e, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x76, + 0x31, 0x2e, 0x4c, 0x31, 0x44, 0x61, 0x74, 0x61, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, + 0x02, 0x38, 0x01, 0x22, 0x97, 0x01, 0x0a, 0x06, 0x4c, 0x31, 0x44, 0x61, 0x74, 0x61, 0x12, 0x28, + 0x0a, 0x10, 0x67, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x5f, 0x65, 0x78, 0x69, 0x74, 0x5f, 0x72, 0x6f, + 0x6f, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0e, 0x67, 0x6c, 0x6f, 0x62, 0x61, 0x6c, + 0x45, 0x78, 0x69, 0x74, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x62, 0x6c, 0x6f, 0x63, + 0x6b, 0x68, 0x61, 0x73, 0x68, 0x5f, 0x6c, 0x31, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, + 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x68, 0x61, 0x73, 0x68, 0x4c, 0x31, 0x12, 0x23, 0x0a, 0x0d, 0x6d, + 0x69, 0x6e, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x0d, 0x52, 0x0c, 0x6d, 0x69, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, + 0x12, 0x1b, 0x0a, 0x09, 0x73, 0x6d, 0x74, 0x5f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x18, 0x04, 0x20, + 0x03, 0x28, 0x0c, 0x52, 0x08, 0x73, 0x6d, 0x74, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x22, 0xe2, 0x02, + 0x0a, 0x0b, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x50, 0x72, 0x6f, 0x76, 0x65, 0x72, 0x12, 0x40, 0x0a, + 0x0d, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x6f, + 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x49, 0x6e, 0x70, 0x75, 0x74, + 0x73, 0x52, 0x0c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x12, + 0x32, 0x0a, 0x02, 0x64, 0x62, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x61, 0x67, + 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x70, 0x75, + 0x74, 0x50, 0x72, 0x6f, 0x76, 0x65, 0x72, 0x2e, 0x44, 0x62, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, + 0x02, 0x64, 0x62, 0x12, 0x60, 0x0a, 0x12, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x73, + 0x5f, 0x62, 0x79, 0x74, 0x65, 0x63, 0x6f, 0x64, 0x65, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x31, 0x2e, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x76, 0x31, 0x2e, + 0x49, 0x6e, 0x70, 0x75, 0x74, 0x50, 0x72, 0x6f, 0x76, 0x65, 0x72, 0x2e, 0x43, 0x6f, 0x6e, 0x74, + 0x72, 0x61, 0x63, 0x74, 0x73, 0x42, 0x79, 0x74, 0x65, 0x63, 0x6f, 0x64, 0x65, 0x45, 0x6e, 0x74, + 0x72, 0x79, 0x52, 0x11, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x73, 0x42, 0x79, 0x74, + 0x65, 0x63, 0x6f, 0x64, 0x65, 0x1a, 0x35, 0x0a, 0x07, 0x44, 0x62, 0x45, 0x6e, 0x74, 0x72, 0x79, + 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, + 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x44, 0x0a, 0x16, + 0x43, 0x6f, 0x6e, 0x74, 0x72, 0x61, 0x63, 0x74, 0x73, 0x42, 0x79, 0x74, 0x65, 0x63, 0x6f, 0x64, + 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, + 0x38, 0x01, 0x22, 0xfe, 0x01, 0x0a, 0x14, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x49, 0x6e, 0x70, + 0x75, 0x74, 0x73, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x65, 0x64, 0x12, 0x40, 0x0a, 0x0d, 0x70, + 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x2e, + 0x76, 0x31, 0x2e, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x52, + 0x0c, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x12, 0x24, 0x0a, + 0x0e, 0x6e, 0x65, 0x77, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0c, 0x6e, 0x65, 0x77, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, + 0x6f, 0x6f, 0x74, 0x12, 0x2b, 0x0a, 0x12, 0x6e, 0x65, 0x77, 0x5f, 0x61, 0x63, 0x63, 0x5f, 0x69, + 0x6e, 0x70, 0x75, 0x74, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, + 0x0f, 0x6e, 0x65, 0x77, 0x41, 0x63, 0x63, 0x49, 0x6e, 0x70, 0x75, 0x74, 0x48, 0x61, 0x73, 0x68, + 0x12, 0x2d, 0x0a, 0x13, 0x6e, 0x65, 0x77, 0x5f, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x5f, 0x65, 0x78, + 0x69, 0x74, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x10, 0x6e, + 0x65, 0x77, 0x4c, 0x6f, 0x63, 0x61, 0x6c, 0x45, 0x78, 0x69, 0x74, 0x52, 0x6f, 0x6f, 0x74, 0x12, + 0x22, 0x0a, 0x0d, 0x6e, 0x65, 0x77, 0x5f, 0x62, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x6e, 0x75, 0x6d, + 0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x6e, 0x65, 0x77, 0x42, 0x61, 0x74, 0x63, 0x68, + 0x4e, 0x75, 0x6d, 0x2a, 0x5c, 0x0a, 0x06, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x12, 0x16, 0x0a, + 0x12, 0x52, 0x45, 0x53, 0x55, 0x4c, 0x54, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, + 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x0d, 0x0a, 0x09, 0x52, 0x45, 0x53, 0x55, 0x4c, 0x54, 0x5f, + 0x4f, 0x4b, 0x10, 0x01, 0x12, 0x10, 0x0a, 0x0c, 0x52, 0x45, 0x53, 0x55, 0x4c, 0x54, 0x5f, 0x45, + 0x52, 0x52, 0x4f, 0x52, 0x10, 0x02, 0x12, 0x19, 0x0a, 0x15, 0x52, 0x45, 0x53, 0x55, 0x4c, 0x54, + 0x5f, 0x49, 0x4e, 0x54, 0x45, 0x52, 0x4e, 0x41, 0x4c, 0x5f, 0x45, 0x52, 0x52, 0x4f, 0x52, 0x10, + 0x03, 0x32, 0x64, 0x0a, 0x11, 0x41, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x53, + 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x4f, 0x0a, 0x07, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, + 0x6c, 0x12, 0x1c, 0x2e, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x76, + 0x31, 0x2e, 0x50, 0x72, 0x6f, 0x76, 0x65, 0x72, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x1a, + 0x20, 0x2e, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x76, 0x31, 0x2e, + 0x41, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, + 0x65, 0x22, 0x00, 0x28, 0x01, 0x30, 0x01, 0x42, 0x3b, 0x5a, 0x39, 0x67, 0x69, 0x74, 0x68, 0x75, + 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x30, 0x78, 0x50, 0x6f, 0x6c, 0x79, 0x67, 0x6f, 0x6e, 0x48, + 0x65, 0x72, 0x6d, 0x65, 0x7a, 0x2f, 0x7a, 0x6b, 0x65, 0x76, 0x6d, 0x2d, 0x6e, 0x6f, 0x64, 0x65, + 0x2f, 0x70, 0x72, 0x6f, 0x76, 0x65, 0x72, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x2f, 0x70, 0x72, + 0x6f, 0x76, 0x65, 0x72, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_aggregator_proto_rawDescOnce sync.Once + file_aggregator_proto_rawDescData = file_aggregator_proto_rawDesc +) + +func file_aggregator_proto_rawDescGZIP() []byte { + file_aggregator_proto_rawDescOnce.Do(func() { + file_aggregator_proto_rawDescData = protoimpl.X.CompressGZIP(file_aggregator_proto_rawDescData) + }) + return file_aggregator_proto_rawDescData +} + +var file_aggregator_proto_enumTypes = make([]protoimpl.EnumInfo, 3) +var file_aggregator_proto_msgTypes = make([]protoimpl.MessageInfo, 23) +var file_aggregator_proto_goTypes = []interface{}{ + (Result)(0), // 0: aggregator.v1.Result + (GetStatusResponse_Status)(0), // 1: aggregator.v1.GetStatusResponse.Status + (GetProofResponse_Result)(0), // 2: aggregator.v1.GetProofResponse.Result + (*Version)(nil), // 3: aggregator.v1.Version + (*AggregatorMessage)(nil), // 4: aggregator.v1.AggregatorMessage + (*ProverMessage)(nil), // 5: aggregator.v1.ProverMessage + (*GetStatusRequest)(nil), // 6: aggregator.v1.GetStatusRequest + (*GenBatchProofRequest)(nil), // 7: aggregator.v1.GenBatchProofRequest + (*GenAggregatedProofRequest)(nil), // 8: aggregator.v1.GenAggregatedProofRequest + (*GenFinalProofRequest)(nil), // 9: aggregator.v1.GenFinalProofRequest + (*CancelRequest)(nil), // 10: aggregator.v1.CancelRequest + (*GetProofRequest)(nil), // 11: aggregator.v1.GetProofRequest + (*GetStatusResponse)(nil), // 12: aggregator.v1.GetStatusResponse + (*GenBatchProofResponse)(nil), // 13: aggregator.v1.GenBatchProofResponse + (*GenAggregatedProofResponse)(nil), // 14: aggregator.v1.GenAggregatedProofResponse + (*GenFinalProofResponse)(nil), // 15: aggregator.v1.GenFinalProofResponse + (*CancelResponse)(nil), // 16: aggregator.v1.CancelResponse + (*GetProofResponse)(nil), // 17: aggregator.v1.GetProofResponse + (*FinalProof)(nil), // 18: aggregator.v1.FinalProof + (*PublicInputs)(nil), // 19: aggregator.v1.PublicInputs + (*L1Data)(nil), // 20: aggregator.v1.L1Data + (*InputProver)(nil), // 21: aggregator.v1.InputProver + (*PublicInputsExtended)(nil), // 22: aggregator.v1.PublicInputsExtended + nil, // 23: aggregator.v1.PublicInputs.L1InfoTreeDataEntry + nil, // 24: aggregator.v1.InputProver.DbEntry + nil, // 25: aggregator.v1.InputProver.ContractsBytecodeEntry +} +var file_aggregator_proto_depIdxs = []int32{ + 6, // 0: aggregator.v1.AggregatorMessage.get_status_request:type_name -> aggregator.v1.GetStatusRequest + 7, // 1: aggregator.v1.AggregatorMessage.gen_batch_proof_request:type_name -> aggregator.v1.GenBatchProofRequest + 8, // 2: aggregator.v1.AggregatorMessage.gen_aggregated_proof_request:type_name -> aggregator.v1.GenAggregatedProofRequest + 9, // 3: aggregator.v1.AggregatorMessage.gen_final_proof_request:type_name -> aggregator.v1.GenFinalProofRequest + 10, // 4: aggregator.v1.AggregatorMessage.cancel_request:type_name -> aggregator.v1.CancelRequest + 11, // 5: aggregator.v1.AggregatorMessage.get_proof_request:type_name -> aggregator.v1.GetProofRequest + 12, // 6: aggregator.v1.ProverMessage.get_status_response:type_name -> aggregator.v1.GetStatusResponse + 13, // 7: aggregator.v1.ProverMessage.gen_batch_proof_response:type_name -> aggregator.v1.GenBatchProofResponse + 14, // 8: aggregator.v1.ProverMessage.gen_aggregated_proof_response:type_name -> aggregator.v1.GenAggregatedProofResponse + 15, // 9: aggregator.v1.ProverMessage.gen_final_proof_response:type_name -> aggregator.v1.GenFinalProofResponse + 16, // 10: aggregator.v1.ProverMessage.cancel_response:type_name -> aggregator.v1.CancelResponse + 17, // 11: aggregator.v1.ProverMessage.get_proof_response:type_name -> aggregator.v1.GetProofResponse + 21, // 12: aggregator.v1.GenBatchProofRequest.input:type_name -> aggregator.v1.InputProver + 1, // 13: aggregator.v1.GetStatusResponse.status:type_name -> aggregator.v1.GetStatusResponse.Status + 0, // 14: aggregator.v1.GenBatchProofResponse.result:type_name -> aggregator.v1.Result + 0, // 15: aggregator.v1.GenAggregatedProofResponse.result:type_name -> aggregator.v1.Result + 0, // 16: aggregator.v1.GenFinalProofResponse.result:type_name -> aggregator.v1.Result + 0, // 17: aggregator.v1.CancelResponse.result:type_name -> aggregator.v1.Result + 18, // 18: aggregator.v1.GetProofResponse.final_proof:type_name -> aggregator.v1.FinalProof + 2, // 19: aggregator.v1.GetProofResponse.result:type_name -> aggregator.v1.GetProofResponse.Result + 22, // 20: aggregator.v1.FinalProof.public:type_name -> aggregator.v1.PublicInputsExtended + 23, // 21: aggregator.v1.PublicInputs.l1_info_tree_data:type_name -> aggregator.v1.PublicInputs.L1InfoTreeDataEntry + 19, // 22: aggregator.v1.InputProver.public_inputs:type_name -> aggregator.v1.PublicInputs + 24, // 23: aggregator.v1.InputProver.db:type_name -> aggregator.v1.InputProver.DbEntry + 25, // 24: aggregator.v1.InputProver.contracts_bytecode:type_name -> aggregator.v1.InputProver.ContractsBytecodeEntry + 19, // 25: aggregator.v1.PublicInputsExtended.public_inputs:type_name -> aggregator.v1.PublicInputs + 20, // 26: aggregator.v1.PublicInputs.L1InfoTreeDataEntry.value:type_name -> aggregator.v1.L1Data + 5, // 27: aggregator.v1.AggregatorService.Channel:input_type -> aggregator.v1.ProverMessage + 4, // 28: aggregator.v1.AggregatorService.Channel:output_type -> aggregator.v1.AggregatorMessage + 28, // [28:29] is the sub-list for method output_type + 27, // [27:28] is the sub-list for method input_type + 27, // [27:27] is the sub-list for extension type_name + 27, // [27:27] is the sub-list for extension extendee + 0, // [0:27] is the sub-list for field type_name +} + +func init() { file_aggregator_proto_init() } +func file_aggregator_proto_init() { + if File_aggregator_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_aggregator_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Version); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_aggregator_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*AggregatorMessage); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_aggregator_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ProverMessage); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_aggregator_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetStatusRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_aggregator_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GenBatchProofRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_aggregator_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GenAggregatedProofRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_aggregator_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GenFinalProofRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_aggregator_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CancelRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_aggregator_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetProofRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_aggregator_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetStatusResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_aggregator_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GenBatchProofResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_aggregator_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GenAggregatedProofResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_aggregator_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GenFinalProofResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_aggregator_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CancelResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_aggregator_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GetProofResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_aggregator_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*FinalProof); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_aggregator_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*PublicInputs); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_aggregator_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*L1Data); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_aggregator_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*InputProver); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_aggregator_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*PublicInputsExtended); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + file_aggregator_proto_msgTypes[1].OneofWrappers = []interface{}{ + (*AggregatorMessage_GetStatusRequest)(nil), + (*AggregatorMessage_GenBatchProofRequest)(nil), + (*AggregatorMessage_GenAggregatedProofRequest)(nil), + (*AggregatorMessage_GenFinalProofRequest)(nil), + (*AggregatorMessage_CancelRequest)(nil), + (*AggregatorMessage_GetProofRequest)(nil), + } + file_aggregator_proto_msgTypes[2].OneofWrappers = []interface{}{ + (*ProverMessage_GetStatusResponse)(nil), + (*ProverMessage_GenBatchProofResponse)(nil), + (*ProverMessage_GenAggregatedProofResponse)(nil), + (*ProverMessage_GenFinalProofResponse)(nil), + (*ProverMessage_CancelResponse)(nil), + (*ProverMessage_GetProofResponse)(nil), + } + file_aggregator_proto_msgTypes[14].OneofWrappers = []interface{}{ + (*GetProofResponse_FinalProof)(nil), + (*GetProofResponse_RecursiveProof)(nil), + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_aggregator_proto_rawDesc, + NumEnums: 3, + NumMessages: 23, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_aggregator_proto_goTypes, + DependencyIndexes: file_aggregator_proto_depIdxs, + EnumInfos: file_aggregator_proto_enumTypes, + MessageInfos: file_aggregator_proto_msgTypes, + }.Build() + File_aggregator_proto = out.File + file_aggregator_proto_rawDesc = nil + file_aggregator_proto_goTypes = nil + file_aggregator_proto_depIdxs = nil +} diff --git a/aggregator/prover/aggregator_grpc.pb.go b/aggregator/prover/aggregator_grpc.pb.go new file mode 100644 index 0000000..6930132 --- /dev/null +++ b/aggregator/prover/aggregator_grpc.pb.go @@ -0,0 +1,141 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.3.0 +// - protoc v4.25.1 +// source: aggregator.proto + +package prover + +import ( + context "context" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.32.0 or later. +const _ = grpc.SupportPackageIsVersion7 + +const ( + AggregatorService_Channel_FullMethodName = "/aggregator.v1.AggregatorService/Channel" +) + +// AggregatorServiceClient is the client API for AggregatorService service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type AggregatorServiceClient interface { + Channel(ctx context.Context, opts ...grpc.CallOption) (AggregatorService_ChannelClient, error) +} + +type aggregatorServiceClient struct { + cc grpc.ClientConnInterface +} + +func NewAggregatorServiceClient(cc grpc.ClientConnInterface) AggregatorServiceClient { + return &aggregatorServiceClient{cc} +} + +func (c *aggregatorServiceClient) Channel(ctx context.Context, opts ...grpc.CallOption) (AggregatorService_ChannelClient, error) { + stream, err := c.cc.NewStream(ctx, &AggregatorService_ServiceDesc.Streams[0], AggregatorService_Channel_FullMethodName, opts...) + if err != nil { + return nil, err + } + x := &aggregatorServiceChannelClient{stream} + return x, nil +} + +type AggregatorService_ChannelClient interface { + Send(*ProverMessage) error + Recv() (*AggregatorMessage, error) + grpc.ClientStream +} + +type aggregatorServiceChannelClient struct { + grpc.ClientStream +} + +func (x *aggregatorServiceChannelClient) Send(m *ProverMessage) error { + return x.ClientStream.SendMsg(m) +} + +func (x *aggregatorServiceChannelClient) Recv() (*AggregatorMessage, error) { + m := new(AggregatorMessage) + if err := x.ClientStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +// AggregatorServiceServer is the server API for AggregatorService service. +// All implementations must embed UnimplementedAggregatorServiceServer +// for forward compatibility +type AggregatorServiceServer interface { + Channel(AggregatorService_ChannelServer) error + mustEmbedUnimplementedAggregatorServiceServer() +} + +// UnimplementedAggregatorServiceServer must be embedded to have forward compatible implementations. +type UnimplementedAggregatorServiceServer struct { +} + +func (UnimplementedAggregatorServiceServer) Channel(AggregatorService_ChannelServer) error { + return status.Errorf(codes.Unimplemented, "method Channel not implemented") +} +func (UnimplementedAggregatorServiceServer) mustEmbedUnimplementedAggregatorServiceServer() {} + +// UnsafeAggregatorServiceServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to AggregatorServiceServer will +// result in compilation errors. +type UnsafeAggregatorServiceServer interface { + mustEmbedUnimplementedAggregatorServiceServer() +} + +func RegisterAggregatorServiceServer(s grpc.ServiceRegistrar, srv AggregatorServiceServer) { + s.RegisterService(&AggregatorService_ServiceDesc, srv) +} + +func _AggregatorService_Channel_Handler(srv interface{}, stream grpc.ServerStream) error { + return srv.(AggregatorServiceServer).Channel(&aggregatorServiceChannelServer{stream}) +} + +type AggregatorService_ChannelServer interface { + Send(*AggregatorMessage) error + Recv() (*ProverMessage, error) + grpc.ServerStream +} + +type aggregatorServiceChannelServer struct { + grpc.ServerStream +} + +func (x *aggregatorServiceChannelServer) Send(m *AggregatorMessage) error { + return x.ServerStream.SendMsg(m) +} + +func (x *aggregatorServiceChannelServer) Recv() (*ProverMessage, error) { + m := new(ProverMessage) + if err := x.ServerStream.RecvMsg(m); err != nil { + return nil, err + } + return m, nil +} + +// AggregatorService_ServiceDesc is the grpc.ServiceDesc for AggregatorService service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var AggregatorService_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "aggregator.v1.AggregatorService", + HandlerType: (*AggregatorServiceServer)(nil), + Methods: []grpc.MethodDesc{}, + Streams: []grpc.StreamDesc{ + { + StreamName: "Channel", + Handler: _AggregatorService_Channel_Handler, + ServerStreams: true, + ClientStreams: true, + }, + }, + Metadata: "aggregator.proto", +} diff --git a/cmd/main.go b/cmd/main.go new file mode 100644 index 0000000..3be4317 --- /dev/null +++ b/cmd/main.go @@ -0,0 +1,96 @@ +package main + +import ( + "os" + + "github.com/0xPolygonHermez/zkevm-ethtx-manager" + "github.com/0xPolygonHermez/zkevm-ethtx-manager/config" + "github.com/0xPolygonHermez/zkevm-ethtx-manager/log" + "github.com/urfave/cli/v2" +) + +const appName = "zkevm-ethtx-manager" + +const ( + // ETHTXMANAGER is the service that manages the tx sent to L1 + ETHTXMANAGER = "ethtx-manager" +) + +const ( + // NODE_CONFIGFILE name to identify the node config-file + NODE_CONFIGFILE = "node" + // NETWORK_CONFIGFILE name to identify the netowk_custom (genesis) config-file + NETWORK_CONFIGFILE = "custom_network" +) + +var ( + configFileFlag = cli.StringFlag{ + Name: config.FlagCfg, + Aliases: []string{"c"}, + Usage: "Configuration `FILE`", + Required: true, + } + networkFlag = cli.StringFlag{ + Name: config.FlagNetwork, + Aliases: []string{"net"}, + Usage: "Load default network configuration. Supported values: [`mainnet`, `testnet`, `custom`]", + Required: true, + } + customNetworkFlag = cli.StringFlag{ + Name: config.FlagCustomNetwork, + Aliases: []string{"net-file"}, + Usage: "Load the network configuration file if --network=custom", + Required: false, + } + yesFlag = cli.BoolFlag{ + Name: config.FlagYes, + Aliases: []string{"y"}, + Usage: "Automatically accepts any confirmation to execute the command", + Required: false, + } + componentsFlag = cli.StringSliceFlag{ + Name: config.FlagComponents, + Aliases: []string{"co"}, + Usage: "List of components to run", + Required: false, + Value: cli.NewStringSlice(ETHTXMANAGER), + } + migrationsFlag = cli.BoolFlag{ + Name: config.FlagMigrations, + Aliases: []string{"mig"}, + Usage: "Blocks the migrations in stateDB to not run them", + Required: false, + } +) + +func main() { + app := cli.NewApp() + app.Name = appName + app.Version = zkevm.Version + flags := []cli.Flag{ + &configFileFlag, + &yesFlag, + &componentsFlag, + } + app.Commands = []*cli.Command{ + { + Name: "version", + Aliases: []string{}, + Usage: "Application version and build", + Action: versionCmd, + }, + { + Name: "run", + Aliases: []string{}, + Usage: "Run the zkevm-ethtx-manager", + Action: start, + Flags: append(flags, &networkFlag, &customNetworkFlag, &migrationsFlag), + }, + } + + err := app.Run(os.Args) + if err != nil { + log.Fatal(err) + os.Exit(1) + } +} diff --git a/cmd/run.go b/cmd/run.go new file mode 100644 index 0000000..988bf05 --- /dev/null +++ b/cmd/run.go @@ -0,0 +1,207 @@ +package main + +import ( + "context" + "fmt" + "net" + "net/http" + "net/http/pprof" + "os" + "os/signal" + "runtime" + "time" + + "github.com/0xPolygonHermez/zkevm-ethtx-manager" + "github.com/0xPolygonHermez/zkevm-ethtx-manager/config" + "github.com/0xPolygonHermez/zkevm-ethtx-manager/db" + "github.com/0xPolygonHermez/zkevm-ethtx-manager/etherman" + "github.com/0xPolygonHermez/zkevm-ethtx-manager/ethtxmanager" + "github.com/0xPolygonHermez/zkevm-ethtx-manager/log" + "github.com/0xPolygonHermez/zkevm-ethtx-manager/metrics" + "github.com/prometheus/client_golang/prometheus/promhttp" + "github.com/urfave/cli/v2" +) + +func start(cliCtx *cli.Context) error { + c, err := config.Load(cliCtx, true) + if err != nil { + return err + } + setupLog(c.Log) + + if c.Log.Environment == log.EnvironmentDevelopment { + zkevm.PrintVersion(os.Stdout) + log.Info("Starting application") + } else if c.Log.Environment == log.EnvironmentProduction { + logVersion() + } + + if c.Metrics.Enabled { + metrics.Init() + } + components := cliCtx.StringSlice(config.FlagComponents) + + // Only runs migration if the component is the synchronizer and if the flag is deactivated + if !cliCtx.Bool(config.FlagMigrations) { + runStateMigrations(c.EthTxManager.DB) + } + checkStateMigrations(c.EthTxManager.DB) + + var ( + cancelFuncs []context.CancelFunc + // needsExecutor, needsStateTree bool + ) + + ethTxManagerStorage, err := ethtxmanager.NewPostgresStorage(c.EthTxManager.DB) + if err != nil { + log.Fatal(err) + } + + if c.Metrics.ProfilingEnabled { + go startProfilingHttpServer(c.Metrics) + } + for _, component := range components { + switch component { + case ETHTXMANAGER: + etm := createEthTxManager(*c, ethTxManagerStorage) + go etm.Start() + } + } + + if c.Metrics.Enabled { + go startMetricsHttpServer(c.Metrics) + } + + waitSignal(cancelFuncs) + + return nil +} + +func setupLog(c log.Config) { + log.Init(c) +} + +func runStateMigrations(c db.Config) { + runMigrations(c, db.EthTxManagerMigrationName) +} + +func checkStateMigrations(c db.Config) { + err := db.CheckMigrations(c, db.EthTxManagerMigrationName) + if err != nil { + log.Fatal(err) + } +} + +func runMigrations(c db.Config, name string) { + log.Infof("running migrations for %v", name) + err := db.RunMigrationsUp(c, name) + if err != nil { + log.Fatal(err) + } +} + +func newEtherman(c config.Config) (*etherman.Client, error) { + return etherman.NewClient(c.Etherman, c.NetworkConfig.L1Config) +} + +func waitSignal(cancelFuncs []context.CancelFunc) { + signals := make(chan os.Signal, 1) + signal.Notify(signals, os.Interrupt) + + for sig := range signals { + switch sig { + case os.Interrupt, os.Kill: + log.Info("terminating application gracefully...") + + exitStatus := 0 + for _, cancel := range cancelFuncs { + cancel() + } + os.Exit(exitStatus) + } + } +} + +func createEthTxManager(cfg config.Config, etmStorage *ethtxmanager.PostgresStorage) *ethtxmanager.Client { + etherman, err := newEtherman(cfg) + if err != nil { + log.Fatal(err) + } + + for _, privateKey := range cfg.EthTxManager.PrivateKeys { + _, err := etherman.LoadAuthFromKeyStore(privateKey.Path, privateKey.Password) + if err != nil { + log.Fatal(err) + } + } + etm := ethtxmanager.New(cfg.EthTxManager, etherman, etmStorage) + return etm +} + +func startProfilingHttpServer(c metrics.Config) { + const two = 2 + mux := http.NewServeMux() + address := fmt.Sprintf("%s:%d", c.ProfilingHost, c.ProfilingPort) + lis, err := net.Listen("tcp", address) + if err != nil { + log.Errorf("failed to create tcp listener for profiling: %v", err) + return + } + mux.HandleFunc(metrics.ProfilingIndexEndpoint, pprof.Index) + mux.HandleFunc(metrics.ProfileEndpoint, pprof.Profile) + mux.HandleFunc(metrics.ProfilingCmdEndpoint, pprof.Cmdline) + mux.HandleFunc(metrics.ProfilingSymbolEndpoint, pprof.Symbol) + mux.HandleFunc(metrics.ProfilingTraceEndpoint, pprof.Trace) + profilingServer := &http.Server{ + Handler: mux, + ReadHeaderTimeout: two * time.Minute, + ReadTimeout: two * time.Minute, + } + log.Infof("profiling server listening on port %d", c.ProfilingPort) + if err := profilingServer.Serve(lis); err != nil { + if err == http.ErrServerClosed { + log.Warnf("http server for profiling stopped") + return + } + log.Errorf("closed http connection for profiling server: %v", err) + return + } +} + +func startMetricsHttpServer(c metrics.Config) { + const ten = 10 + mux := http.NewServeMux() + address := fmt.Sprintf("%s:%d", c.Host, c.Port) + lis, err := net.Listen("tcp", address) + if err != nil { + log.Errorf("failed to create tcp listener for metrics: %v", err) + return + } + mux.Handle(metrics.Endpoint, promhttp.Handler()) + + metricsServer := &http.Server{ + Handler: mux, + ReadHeaderTimeout: ten * time.Second, + ReadTimeout: ten * time.Second, + } + log.Infof("metrics server listening on port %d", c.Port) + if err := metricsServer.Serve(lis); err != nil { + if err == http.ErrServerClosed { + log.Warnf("http server for metrics stopped") + return + } + log.Errorf("closed http connection for metrics server: %v", err) + return + } +} + +func logVersion() { + log.Infow("Starting application", + // node version is already logged by default + "gitRevision", zkevm.GitRev, + "gitBranch", zkevm.GitBranch, + "goVersion", runtime.Version(), + "built", zkevm.BuildDate, + "os/arch", fmt.Sprintf("%s/%s", runtime.GOOS, runtime.GOARCH), + ) +} diff --git a/cmd/version.go b/cmd/version.go new file mode 100644 index 0000000..4ffafe1 --- /dev/null +++ b/cmd/version.go @@ -0,0 +1,13 @@ +package main + +import ( + "os" + + "github.com/0xPolygonHermez/zkevm-ethtx-manager" + "github.com/urfave/cli/v2" +) + +func versionCmd(*cli.Context) error { + zkevm.PrintVersion(os.Stdout) + return nil +} diff --git a/config/config.go b/config/config.go new file mode 100644 index 0000000..7af50d2 --- /dev/null +++ b/config/config.go @@ -0,0 +1,126 @@ +package config + +import ( + "bytes" + "path/filepath" + "strings" + + "github.com/0xPolygonHermez/zkevm-ethtx-manager/etherman" + "github.com/0xPolygonHermez/zkevm-ethtx-manager/ethtxmanager" + "github.com/0xPolygonHermez/zkevm-ethtx-manager/log" + "github.com/0xPolygonHermez/zkevm-ethtx-manager/metrics" + "github.com/mitchellh/mapstructure" + "github.com/spf13/viper" + "github.com/urfave/cli/v2" +) + +const ( + // FlagYes is the flag for yes. + FlagYes = "yes" + // FlagCfg is the flag for cfg. + FlagCfg = "cfg" + // FlagNetwork is the flag for the network name. Valid values: ["testnet", "mainnet", "custom"]. + FlagNetwork = "network" + // FlagCustomNetwork is the flag for the custom network file. This is required if --network=custom + FlagCustomNetwork = "custom-network-file" + // FlagAmount is the flag for amount. + FlagAmount = "amount" + // FlagRemoteMT is the flag for remote-merkletree. + FlagRemoteMT = "remote-merkletree" + // FlagComponents is the flag for components. + FlagComponents = "components" + // FlagHTTPAPI is the flag for http.api. + FlagHTTPAPI = "http.api" + // FlagKeyStorePath is the path of the key store file containing the private key of the account going to sing and approve the tokens + FlagKeyStorePath = "key-store-path" + // FlagPassword is the password needed to decrypt the key store + FlagPassword = "password" + // FlagMigrations is the flag for migrations. + FlagMigrations = "migrations" + // FlagOutputFile is the flag for the output file + FlagOutputFile = "output" + // FlagMaxAmount is the flag to avoid to use the flag FlagAmount + FlagMaxAmount = "max-amount" + // FlagDocumentationFileType is the flag for the choose which file generate json-schema + FlagDocumentationFileType = "config-file" +) + +// Config represents the configuration of the eth tx manager +type Config struct { + // Configure Log level for all the services, allow also to store the logs in a file + Log log.Config + // Configuration of the etherman (client for access L1) + Etherman etherman.Config + // Configuration for ethereum transaction manager + EthTxManager ethtxmanager.Config + // Configuration of the genesis of the network. This is used to known the initial state of the network + NetworkConfig NetworkConfig + // Configuration of the metrics service, basically is where is going to publish the metrics + Metrics metrics.Config +} + +// Default parses the default configuration values. +func Default() (*Config, error) { + var cfg Config + viper.SetConfigType("toml") + + err := viper.ReadConfig(bytes.NewBuffer([]byte(DefaultValues))) + if err != nil { + return nil, err + } + err = viper.Unmarshal(&cfg, viper.DecodeHook(mapstructure.TextUnmarshallerHookFunc())) + if err != nil { + return nil, err + } + return &cfg, nil +} + +// Load loads the configuration +func Load(ctx *cli.Context, loadNetworkConfig bool) (*Config, error) { + cfg, err := Default() + if err != nil { + return nil, err + } + configFilePath := ctx.String(FlagCfg) + if configFilePath != "" { + dirName, fileName := filepath.Split(configFilePath) + + fileExtension := strings.TrimPrefix(filepath.Ext(fileName), ".") + fileNameWithoutExtension := strings.TrimSuffix(fileName, "."+fileExtension) + + viper.AddConfigPath(dirName) + viper.SetConfigName(fileNameWithoutExtension) + viper.SetConfigType(fileExtension) + } + viper.AutomaticEnv() + replacer := strings.NewReplacer(".", "_") + viper.SetEnvKeyReplacer(replacer) + viper.SetEnvPrefix("ZKEVM_NODE") + err = viper.ReadInConfig() + if err != nil { + _, ok := err.(viper.ConfigFileNotFoundError) + if ok { + log.Infof("config file not found") + } else { + log.Infof("error reading config file: ", err) + return nil, err + } + } + + decodeHooks := []viper.DecoderConfigOption{ + // this allows arrays to be decoded from env var separated by ",", example: MY_VAR="value1,value2,value3" + viper.DecodeHook(mapstructure.ComposeDecodeHookFunc(mapstructure.TextUnmarshallerHookFunc(), mapstructure.StringToSliceHookFunc(","))), + } + + err = viper.Unmarshal(&cfg, decodeHooks...) + if err != nil { + return nil, err + } + + if loadNetworkConfig { + // Load genesis parameters + cfg.loadNetworkConfig(ctx) + } + + return cfg, nil +} diff --git a/config/default.go b/config/default.go new file mode 100644 index 0000000..6f53021 --- /dev/null +++ b/config/default.go @@ -0,0 +1,36 @@ +package config + +// DefaultValues is the default configuration +const DefaultValues = ` +[Log] +Environment = "development" # "production" or "development" +Level = "info" +Outputs = ["stderr"] + +[Etherman] +URL = "http://localhost:8545" +ForkIDChunkSize = 20000 +MultiGasProvider = false + [Etherman.Etherscan] + ApiKey = "" + +[EthTxManager] +FrequencyToMonitorTxs = "1s" +WaitTxToBeMined = "2m" +ForcedGas = 0 +GasPriceMarginFactor = 1 +MaxGasPriceLimit = 0 + [EthTxManager.DB] + User = "ethtxmanager_user" + Password = "ethtxmanager_password" + Name = "ethtxmanager_db" + Host = "zkevm-ethtxmanager-db" + Port = "5432" + EnableLog = false + MaxConns = 200 + +[Metrics] +Host = "0.0.0.0" +Port = 9091 +Enabled = false +` diff --git a/config/environments/local/local.ethtxmanager.config.toml b/config/environments/local/local.ethtxmanager.config.toml new file mode 100644 index 0000000..5161082 --- /dev/null +++ b/config/environments/local/local.ethtxmanager.config.toml @@ -0,0 +1,34 @@ +[Log] +Environment = "development" # "production" or "development" +Level = "debug" +Outputs = ["stderr"] + +[Etherman] +URL = "http://your.L1node.url" +ForkIDChunkSize = 20000 +MultiGasProvider = false + [Etherman.Etherscan] + ApiKey = "" + +[EthTxManager] +ForcedGas = 0 +PrivateKeys = [ + {Path = "/pk/sequencer.keystore", Password = "testonly"}, + {Path = "/pk/aggregator.keystore", Password = "testonly"} + ] + [EthTxManager.DB] + User = "ethtxmanager_user" + Password = "ethtxmanager_password" + Name = "ethtxmanager_db" + Host = "zkevm-ethtxmanager-db" + Port = "5432" + EnableLog = false + MaxConns = 200 + +[Metrics] +Host = "0.0.0.0" +Port = 9091 +Enabled = false +ProfilingHost = "0.0.0.0" +ProfilingPort = 6060 +ProfilingEnabled = false diff --git a/config/environments/local/local.genesis.config.json b/config/environments/local/local.genesis.config.json new file mode 100644 index 0000000..042bd75 --- /dev/null +++ b/config/environments/local/local.genesis.config.json @@ -0,0 +1,100 @@ +{ + "l1Config": { + "chainId": 1337, + "polygonZkEVMAddress": "0x8dAF17A20c9DBA35f005b6324F493785D239719d", + "polygonRollupManagerAddress": "0xB7f8BC63BbcaD18155201308C8f3540b07f84F5e", + "polTokenAddress": "0x5FbDB2315678afecb367f032d93F642f64180aa3", + "polygonZkEVMGlobalExitRootAddress": "0x8A791620dd6260079BF849Dc5567aDC3F2FdC318" + }, + "genesisBlockNumber": 138, + "root": "0xa64456534f3bbe93f991c0139342a0ef52df95c6999eaa5ec8a69741da407f9a", + "genesis": [ + { + "contractName": "PolygonZkEVMDeployer", + "balance": "0", + "nonce": "4", + "address": "0x51dbd54FCCb6b3A07738fd3E156D588e71f79973", + "bytecode": "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", + "storage": { + "0x0000000000000000000000000000000000000000000000000000000000000000": "0x000000000000000000000000f39fd6e51aad88f6f4ce6ab8827279cfffb92266" + } + }, + { + "contractName": "ProxyAdmin", + "balance": "0", + "nonce": "1", + "address": "0xe34Fe58DDa5b8c6D547E4857E987633aa86a5e90", + "bytecode": "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", + "storage": { + "0x0000000000000000000000000000000000000000000000000000000000000000": "0x0000000000000000000000000165878a594ca255338adfa4d48449f69242eb8f" + } + }, + { + "contractName": "PolygonZkEVMBridge implementation", + "balance": "0", + "nonce": "1", + "address": "0x12864938EADb26501034339667CabFB3d7045CD2", + "bytecode": "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" + }, + { + "contractName": "PolygonZkEVMBridge proxy", + "balance": "340282366920938463463374607431768211455", + "nonce": "1", + "address": "0xCca6ECD73932e49633B9307e1aa0fC174525F424", + "bytecode": "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", + "storage": { + "0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103": "0x000000000000000000000000e34fe58dda5b8c6d547e4857e987633aa86a5e90", + "0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc": "0x00000000000000000000000012864938eadb26501034339667cabfb3d7045cd2" + } + }, + { + "contractName": "PolygonZkEVMGlobalExitRootL2 implementation", + "balance": "0", + "nonce": "1", + "address": "0xDc64a140Aa3E981100a9becA4E685f962f0cF6C9", + "bytecode": "0x608060405234801561001057600080fd5b506004361061004c5760003560e01c806301fd904414610051578063257b36321461006d57806333d6247d1461008d578063a3c573eb146100a2575b600080fd5b61005a60015481565b6040519081526020015b60405180910390f35b61005a61007b366004610162565b60006020819052908152604090205481565b6100a061009b366004610162565b6100ee565b005b6100c97f000000000000000000000000cca6ecd73932e49633b9307e1aa0fc174525f42481565b60405173ffffffffffffffffffffffffffffffffffffffff9091168152602001610064565b3373ffffffffffffffffffffffffffffffffffffffff7f000000000000000000000000cca6ecd73932e49633b9307e1aa0fc174525f424161461015d576040517fb49365dd00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600155565b60006020828403121561017457600080fd5b503591905056fea2646970667358221220ea2171e2c85c8bff947affc409ef6fc6a8fe82fb8c174ddeda988651e595d66564736f6c63430008140033" + }, + { + "contractName": "PolygonZkEVMGlobalExitRootL2 proxy", + "balance": "0", + "nonce": "1", + "address": "0xa40d5f56745a118d0906a34e69aec8c0db1cb8fa", + "bytecode": "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", + "storage": { + "0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103": "0x000000000000000000000000e34fe58dda5b8c6d547e4857e987633aa86a5e90", + "0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc": "0x000000000000000000000000dc64a140aa3e981100a9beca4e685f962f0cf6c9" + } + }, + { + "contractName": "PolygonZkEVMTimelock", + "balance": "0", + "nonce": "1", + "address": "0x0165878A594ca255338adfa4d48449f69242Eb8F", + "bytecode": "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", + "storage": { + "0x0000000000000000000000000000000000000000000000000000000000000002": "0x0000000000000000000000000000000000000000000000000000000000000e10", + "0xaedcc9e7897c0d335bdc5d92fe3a8b4f23727fe558cd1c19f332b28716a30559": "0x0000000000000000000000000000000000000000000000000000000000000001", + "0xf5e61edb9c9cc6bfbae4463e9a2b1dd6ac3b44ddef38f18016e56ba0363910d9": "0x0000000000000000000000000000000000000000000000000000000000000001", + "0x64494413541ff93b31aa309254e3fed72a7456e9845988b915b4c7a7ceba8814": "0x5f58e3a2316349923ce3780f8d587db2d72378aed66a8261c916544fa6846ca5", + "0x60b9d94c75b7b3f721925089391e4644cd890cb5e6466f9596dfbd2c54e0b280": "0x0000000000000000000000000000000000000000000000000000000000000001", + "0x3412d5605ac6cd444957cedb533e5dacad6378b4bc819ebe3652188a665066d6": "0x5f58e3a2316349923ce3780f8d587db2d72378aed66a8261c916544fa6846ca5", + "0x4b63b79f1e338a49559dcd3193ac9eecc50d0f275d24e97cc8c319e5a31a8bd0": "0x0000000000000000000000000000000000000000000000000000000000000001", + "0xdae2aa361dfd1ca020a396615627d436107c35eff9fe7738a3512819782d706a": "0x5f58e3a2316349923ce3780f8d587db2d72378aed66a8261c916544fa6846ca5", + "0x800d5dfe4bba53eedee06cd4546a27da8de00f12db83f56062976d4493fda899": "0x0000000000000000000000000000000000000000000000000000000000000001", + "0xc3ad33e20b0c56a223ad5104fff154aa010f8715b9c981fd38fdc60a4d1a52fc": "0x5f58e3a2316349923ce3780f8d587db2d72378aed66a8261c916544fa6846ca5" + } + }, + { + "accountName": "keyless Deployer", + "balance": "0", + "nonce": "1", + "address": "0x28BB4e66addE1f042B77E04cf7D3784C1dcDBbA3" + }, + { + "accountName": "deployer", + "balance": "100000000000000000000000", + "nonce": "8", + "address": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266" + } + ] +} \ No newline at end of file diff --git a/config/environments/mainnet/ethtxmanager.config.toml b/config/environments/mainnet/ethtxmanager.config.toml new file mode 100644 index 0000000..b89d5da --- /dev/null +++ b/config/environments/mainnet/ethtxmanager.config.toml @@ -0,0 +1,34 @@ +[Log] +Environment = "development" # "production" or "development" +Level = "info" +Outputs = ["stderr"] + +[Etherman] +URL = "http://your.L1node.url" +ForkIDChunkSize = 20000 +MultiGasProvider = false + [Etherman.Etherscan] + ApiKey = "" + +[EthTxManager] +ForcedGas = 0 +PrivateKeys = [ + {Path = "/pk/sequencer.keystore", Password = "testonly"}, + {Path = "/pk/aggregator.keystore", Password = "testonly"} + ] + [EthTxManager.DB] + User = "ethtxmanager_user" + Password = "ethtxmanager_password" + Name = "ethtxmanager_db" + Host = "zkevm-ethtxmanager-db" + Port = "5432" + EnableLog = false + MaxConns = 200 + +[Metrics] +Host = "0.0.0.0" +Port = 9091 +Enabled = false +ProfilingHost = "0.0.0.0" +ProfilingPort = 6060 +ProfilingEnabled = false diff --git a/config/environments/mainnet/example.env b/config/environments/mainnet/example.env new file mode 100644 index 0000000..abeed7b --- /dev/null +++ b/config/environments/mainnet/example.env @@ -0,0 +1,7 @@ +ZKEVM_NETWORK = "mainnet" +# URL of a JSON RPC for Ethereum mainnet +ZKEVM_ETHTXMANAGER_ETHERMAN_URL = "http://your.L1node.url" +# PATH WHERE THE ETHTXMANAGER POSTGRES CONTAINER WILL STORE PERSISTENT DATA +ZKEVM_ETHTXMANAGER_DATA_DIR = "/path/to/persistent/data/ethtxmanager" +# OPTIONAL, UNCOMENT IF YOU WANT TO DO ADVANCED CONFIG +# ZKEVM_ADVANCED_CONFIG_DIR = "/should/be/same/path/as/ZKEVM_CONFIG_DIR" \ No newline at end of file diff --git a/config/environments/mainnet/postgresql.conf b/config/environments/mainnet/postgresql.conf new file mode 100644 index 0000000..51dff68 --- /dev/null +++ b/config/environments/mainnet/postgresql.conf @@ -0,0 +1,815 @@ +# ----------------------------- +# PostgreSQL configuration file +# ----------------------------- +# +# This file consists of lines of the form: +# +# name = value +# +# (The "=" is optional.) Whitespace may be used. Comments are introduced with +# "#" anywhere on a line. The complete list of parameter names and allowed +# values can be found in the PostgreSQL documentation. +# +# The commented-out settings shown in this file represent the default values. +# Re-commenting a setting is NOT sufficient to revert it to the default value; +# you need to reload the server. +# +# This file is read on server startup and when the server receives a SIGHUP +# signal. If you edit the file on a running system, you have to SIGHUP the +# server for the changes to take effect, run "pg_ctl reload", or execute +# "SELECT pg_reload_conf()". Some parameters, which are marked below, +# require a server shutdown and restart to take effect. +# +# Any parameter can also be given as a command-line option to the server, e.g., +# "postgres -c log_connections=on". Some parameters can be changed at run time +# with the "SET" SQL command. +# +# Memory units: B = bytes Time units: us = microseconds +# kB = kilobytes ms = milliseconds +# MB = megabytes s = seconds +# GB = gigabytes min = minutes +# TB = terabytes h = hours +# d = days + + +#------------------------------------------------------------------------------ +# FILE LOCATIONS +#------------------------------------------------------------------------------ + +# The default values of these variables are driven from the -D command-line +# option or PGDATA environment variable, represented here as ConfigDir. + +#data_directory = 'ConfigDir' # use data in another directory + # (change requires restart) +#hba_file = 'ConfigDir/pg_hba.conf' # host-based authentication file + # (change requires restart) +#ident_file = 'ConfigDir/pg_ident.conf' # ident configuration file + # (change requires restart) + +# If external_pid_file is not explicitly set, no extra PID file is written. +#external_pid_file = '' # write an extra PID file + # (change requires restart) + + +#------------------------------------------------------------------------------ +# CONNECTIONS AND AUTHENTICATION +#------------------------------------------------------------------------------ + +# - Connection Settings - + +listen_addresses = '*' + # comma-separated list of addresses; + # defaults to 'localhost'; use '*' for all + # (change requires restart) +#port = 5432 # (change requires restart) +max_connections = 100 # (change requires restart) +#superuser_reserved_connections = 3 # (change requires restart) +#unix_socket_directories = '/var/run/postgresql' # comma-separated list of directories + # (change requires restart) +#unix_socket_group = '' # (change requires restart) +#unix_socket_permissions = 0777 # begin with 0 to use octal notation + # (change requires restart) +#bonjour = off # advertise server via Bonjour + # (change requires restart) +#bonjour_name = '' # defaults to the computer name + # (change requires restart) + +# - TCP settings - +# see "man tcp" for details + +#tcp_keepalives_idle = 0 # TCP_KEEPIDLE, in seconds; + # 0 selects the system default +#tcp_keepalives_interval = 0 # TCP_KEEPINTVL, in seconds; + # 0 selects the system default +#tcp_keepalives_count = 0 # TCP_KEEPCNT; + # 0 selects the system default +#tcp_user_timeout = 0 # TCP_USER_TIMEOUT, in milliseconds; + # 0 selects the system default + +#client_connection_check_interval = 0 # time between checks for client + # disconnection while running queries; + # 0 for never + +# - Authentication - + +#authentication_timeout = 1min # 1s-600s +#password_encryption = scram-sha-256 # scram-sha-256 or md5 +#db_user_namespace = off + +# GSSAPI using Kerberos +#krb_server_keyfile = 'FILE:${sysconfdir}/krb5.keytab' +#krb_caseins_users = off + +# - SSL - + +#ssl = off +#ssl_ca_file = '' +#ssl_cert_file = 'server.crt' +#ssl_crl_file = '' +#ssl_crl_dir = '' +#ssl_key_file = 'server.key' +#ssl_ciphers = 'HIGH:MEDIUM:+3DES:!aNULL' # allowed SSL ciphers +#ssl_prefer_server_ciphers = on +#ssl_ecdh_curve = 'prime256v1' +#ssl_min_protocol_version = 'TLSv1.2' +#ssl_max_protocol_version = '' +#ssl_dh_params_file = '' +#ssl_passphrase_command = '' +#ssl_passphrase_command_supports_reload = off + + +#------------------------------------------------------------------------------ +# RESOURCE USAGE (except WAL) +#------------------------------------------------------------------------------ + +# - Memory - + +shared_buffers = 8GB # min 128kB + # (change requires restart) +#huge_pages = try # on, off, or try + # (change requires restart) +#huge_page_size = 0 # zero for system default + # (change requires restart) +temp_buffers = 64MB # min 800kB +#max_prepared_transactions = 0 # zero disables the feature + # (change requires restart) +# Caution: it is not advisable to set max_prepared_transactions nonzero unless +# you actively intend to use prepared transactions. +work_mem = 104857kB # min 64kB +#hash_mem_multiplier = 2.0 # 1-1000.0 multiplier on hash table work_mem +maintenance_work_mem = 2GB # min 1MB +#autovacuum_work_mem = -1 # min 1MB, or -1 to use maintenance_work_mem +#logical_decoding_work_mem = 64MB # min 64kB +#max_stack_depth = 2MB # min 100kB +#shared_memory_type = mmap # the default is the first option + # supported by the operating system: + # mmap + # sysv + # windows + # (change requires restart) +dynamic_shared_memory_type = posix # the default is usually the first option + # supported by the operating system: + # posix + # sysv + # windows + # mmap + # (change requires restart) +#min_dynamic_shared_memory = 0MB # (change requires restart) + +# - Disk - + +#temp_file_limit = -1 # limits per-process temp file space + # in kilobytes, or -1 for no limit + +# - Kernel Resources - + +#max_files_per_process = 1000 # min 64 + # (change requires restart) + +# - Cost-Based Vacuum Delay - + +#vacuum_cost_delay = 0 # 0-100 milliseconds (0 disables) +#vacuum_cost_page_hit = 1 # 0-10000 credits +#vacuum_cost_page_miss = 2 # 0-10000 credits +#vacuum_cost_page_dirty = 20 # 0-10000 credits +#vacuum_cost_limit = 200 # 1-10000 credits + +# - Background Writer - + +#bgwriter_delay = 200ms # 10-10000ms between rounds +#bgwriter_lru_maxpages = 100 # max buffers written/round, 0 disables +#bgwriter_lru_multiplier = 2.0 # 0-10.0 multiplier on buffers scanned/round +#bgwriter_flush_after = 512kB # measured in pages, 0 disables + +# - Asynchronous Behavior - + +#backend_flush_after = 0 # measured in pages, 0 disables +effective_io_concurrency = 300 # 1-1000; 0 disables prefetching +#maintenance_io_concurrency = 10 # 1-1000; 0 disables prefetching +max_worker_processes = 16 # (change requires restart) +max_parallel_workers_per_gather = 4 # taken from max_parallel_workers +max_parallel_maintenance_workers = 4 # taken from max_parallel_workers +max_parallel_workers = 16 # maximum number of max_worker_processes that + # can be used in parallel operations +#parallel_leader_participation = on +#old_snapshot_threshold = -1 # 1min-60d; -1 disables; 0 is immediate + # (change requires restart) + + +#------------------------------------------------------------------------------ +# WRITE-AHEAD LOG +#------------------------------------------------------------------------------ + +# - Settings - + +#wal_level = replica # minimal, replica, or logical + # (change requires restart) +#fsync = on # flush data to disk for crash safety + # (turning this off can cause + # unrecoverable data corruption) +#synchronous_commit = on # synchronization level; + # off, local, remote_write, remote_apply, or on +#wal_sync_method = fsync # the default is the first option + # supported by the operating system: + # open_datasync + # fdatasync (default on Linux and FreeBSD) + # fsync + # fsync_writethrough + # open_sync +#full_page_writes = on # recover from partial page writes +#wal_log_hints = off # also do full page writes of non-critical updates + # (change requires restart) +#wal_compression = off # enables compression of full-page writes; + # off, pglz, lz4, zstd, or on +#wal_init_zero = on # zero-fill new WAL files +#wal_recycle = on # recycle WAL files +wal_buffers = 16MB # min 32kB, -1 sets based on shared_buffers + # (change requires restart) +#wal_writer_delay = 200ms # 1-10000 milliseconds +#wal_writer_flush_after = 1MB # measured in pages, 0 disables +#wal_skip_threshold = 2MB + +#commit_delay = 0 # range 0-100000, in microseconds +#commit_siblings = 5 # range 1-1000 + +# - Checkpoints - + +#checkpoint_timeout = 5min # range 30s-1d +checkpoint_completion_target = 0.9 # checkpoint target duration, 0.0 - 1.0 +#checkpoint_flush_after = 256kB # measured in pages, 0 disables +#checkpoint_warning = 30s # 0 disables +max_wal_size = 8GB +min_wal_size = 2GB + +# - Prefetching during recovery - + +#recovery_prefetch = try # prefetch pages referenced in the WAL? +#wal_decode_buffer_size = 512kB # lookahead window used for prefetching + # (change requires restart) + +# - Archiving - + +#archive_mode = off # enables archiving; off, on, or always + # (change requires restart) +#archive_library = '' # library to use to archive a logfile segment + # (empty string indicates archive_command should + # be used) +#archive_command = '' # command to use to archive a logfile segment + # placeholders: %p = path of file to archive + # %f = file name only + # e.g. 'test ! -f /mnt/server/archivedir/%f && cp %p /mnt/server/archivedir/%f' +#archive_timeout = 0 # force a logfile segment switch after this + # number of seconds; 0 disables + +# - Archive Recovery - + +# These are only used in recovery mode. + +#restore_command = '' # command to use to restore an archived logfile segment + # placeholders: %p = path of file to restore + # %f = file name only + # e.g. 'cp /mnt/server/archivedir/%f %p' +#archive_cleanup_command = '' # command to execute at every restartpoint +#recovery_end_command = '' # command to execute at completion of recovery + +# - Recovery Target - + +# Set these only when performing a targeted recovery. + +#recovery_target = '' # 'immediate' to end recovery as soon as a + # consistent state is reached + # (change requires restart) +#recovery_target_name = '' # the named restore point to which recovery will proceed + # (change requires restart) +#recovery_target_time = '' # the time stamp up to which recovery will proceed + # (change requires restart) +#recovery_target_xid = '' # the transaction ID up to which recovery will proceed + # (change requires restart) +#recovery_target_lsn = '' # the WAL LSN up to which recovery will proceed + # (change requires restart) +#recovery_target_inclusive = on # Specifies whether to stop: + # just after the specified recovery target (on) + # just before the recovery target (off) + # (change requires restart) +#recovery_target_timeline = 'latest' # 'current', 'latest', or timeline ID + # (change requires restart) +#recovery_target_action = 'pause' # 'pause', 'promote', 'shutdown' + # (change requires restart) + + +#------------------------------------------------------------------------------ +# REPLICATION +#------------------------------------------------------------------------------ + +# - Sending Servers - + +# Set these on the primary and on any standby that will send replication data. + +#max_wal_senders = 10 # max number of walsender processes + # (change requires restart) +#max_replication_slots = 10 # max number of replication slots + # (change requires restart) +#wal_keep_size = 0 # in megabytes; 0 disables +#max_slot_wal_keep_size = -1 # in megabytes; -1 disables +#wal_sender_timeout = 60s # in milliseconds; 0 disables +#track_commit_timestamp = off # collect timestamp of transaction commit + # (change requires restart) + +# - Primary Server - + +# These settings are ignored on a standby server. + +#synchronous_standby_names = '' # standby servers that provide sync rep + # method to choose sync standbys, number of sync standbys, + # and comma-separated list of application_name + # from standby(s); '*' = all +#vacuum_defer_cleanup_age = 0 # number of xacts by which cleanup is delayed + +# - Standby Servers - + +# These settings are ignored on a primary server. + +#primary_conninfo = '' # connection string to sending server +#primary_slot_name = '' # replication slot on sending server +#promote_trigger_file = '' # file name whose presence ends recovery +#hot_standby = on # "off" disallows queries during recovery + # (change requires restart) +#max_standby_archive_delay = 30s # max delay before canceling queries + # when reading WAL from archive; + # -1 allows indefinite delay +#max_standby_streaming_delay = 30s # max delay before canceling queries + # when reading streaming WAL; + # -1 allows indefinite delay +#wal_receiver_create_temp_slot = off # create temp slot if primary_slot_name + # is not set +#wal_receiver_status_interval = 10s # send replies at least this often + # 0 disables +#hot_standby_feedback = off # send info from standby to prevent + # query conflicts +#wal_receiver_timeout = 60s # time that receiver waits for + # communication from primary + # in milliseconds; 0 disables +#wal_retrieve_retry_interval = 5s # time to wait before retrying to + # retrieve WAL after a failed attempt +#recovery_min_apply_delay = 0 # minimum delay for applying changes during recovery + +# - Subscribers - + +# These settings are ignored on a publisher. + +#max_logical_replication_workers = 4 # taken from max_worker_processes + # (change requires restart) +#max_sync_workers_per_subscription = 2 # taken from max_logical_replication_workers + + +#------------------------------------------------------------------------------ +# QUERY TUNING +#------------------------------------------------------------------------------ + +# - Planner Method Configuration - + +#enable_async_append = on +#enable_bitmapscan = on +#enable_gathermerge = on +#enable_hashagg = on +#enable_hashjoin = on +#enable_incremental_sort = on +#enable_indexscan = on +#enable_indexonlyscan = on +#enable_material = on +#enable_memoize = on +#enable_mergejoin = on +#enable_nestloop = on +#enable_parallel_append = on +#enable_parallel_hash = on +#enable_partition_pruning = on +#enable_partitionwise_join = off +#enable_partitionwise_aggregate = off +#enable_seqscan = on +#enable_sort = on +#enable_tidscan = on + +# - Planner Cost Constants - + +#seq_page_cost = 1.0 # measured on an arbitrary scale +random_page_cost = 1.1 # same scale as above +#cpu_tuple_cost = 0.01 # same scale as above +#cpu_index_tuple_cost = 0.005 # same scale as above +#cpu_operator_cost = 0.0025 # same scale as above +#parallel_setup_cost = 1000.0 # same scale as above +#parallel_tuple_cost = 0.1 # same scale as above +#min_parallel_table_scan_size = 8MB +#min_parallel_index_scan_size = 512kB +effective_cache_size = 24GB + +#jit_above_cost = 100000 # perform JIT compilation if available + # and query more expensive than this; + # -1 disables +#jit_inline_above_cost = 500000 # inline small functions if query is + # more expensive than this; -1 disables +#jit_optimize_above_cost = 500000 # use expensive JIT optimizations if + # query is more expensive than this; + # -1 disables + +# - Genetic Query Optimizer - + +#geqo = on +#geqo_threshold = 12 +#geqo_effort = 5 # range 1-10 +#geqo_pool_size = 0 # selects default based on effort +#geqo_generations = 0 # selects default based on effort +#geqo_selection_bias = 2.0 # range 1.5-2.0 +#geqo_seed = 0.0 # range 0.0-1.0 + +# - Other Planner Options - + +default_statistics_target = 100 # range 1-10000 +#constraint_exclusion = partition # on, off, or partition +#cursor_tuple_fraction = 0.1 # range 0.0-1.0 +#from_collapse_limit = 8 +#jit = on # allow JIT compilation +#join_collapse_limit = 8 # 1 disables collapsing of explicit + # JOIN clauses +#plan_cache_mode = auto # auto, force_generic_plan or + # force_custom_plan +#recursive_worktable_factor = 10.0 # range 0.001-1000000 + + +#------------------------------------------------------------------------------ +# REPORTING AND LOGGING +#------------------------------------------------------------------------------ + +# - Where to Log - + +#log_destination = 'stderr' # Valid values are combinations of + # stderr, csvlog, jsonlog, syslog, and + # eventlog, depending on platform. + # csvlog and jsonlog require + # logging_collector to be on. + +# This is used when logging to stderr: +#logging_collector = off # Enable capturing of stderr, jsonlog, + # and csvlog into log files. Required + # to be on for csvlogs and jsonlogs. + # (change requires restart) + +# These are only used if logging_collector is on: +#log_directory = 'log' # directory where log files are written, + # can be absolute or relative to PGDATA +#log_filename = 'postgresql-%Y-%m-%d_%H%M%S.log' # log file name pattern, + # can include strftime() escapes +#log_file_mode = 0600 # creation mode for log files, + # begin with 0 to use octal notation +#log_rotation_age = 1d # Automatic rotation of logfiles will + # happen after that time. 0 disables. +#log_rotation_size = 10MB # Automatic rotation of logfiles will + # happen after that much log output. + # 0 disables. +#log_truncate_on_rotation = off # If on, an existing log file with the + # same name as the new log file will be + # truncated rather than appended to. + # But such truncation only occurs on + # time-driven rotation, not on restarts + # or size-driven rotation. Default is + # off, meaning append to existing files + # in all cases. + +# These are relevant when logging to syslog: +#syslog_facility = 'LOCAL0' +#syslog_ident = 'postgres' +#syslog_sequence_numbers = on +#syslog_split_messages = on + +# This is only relevant when logging to eventlog (Windows): +# (change requires restart) +#event_source = 'PostgreSQL' + +# - When to Log - + +#log_min_messages = warning # values in order of decreasing detail: + # debug5 + # debug4 + # debug3 + # debug2 + # debug1 + # info + # notice + # warning + # error + # log + # fatal + # panic + +#log_min_error_statement = error # values in order of decreasing detail: + # debug5 + # debug4 + # debug3 + # debug2 + # debug1 + # info + # notice + # warning + # error + # log + # fatal + # panic (effectively off) + +#log_min_duration_statement = -1 # -1 is disabled, 0 logs all statements + # and their durations, > 0 logs only + # statements running at least this number + # of milliseconds + +#log_min_duration_sample = -1 # -1 is disabled, 0 logs a sample of statements + # and their durations, > 0 logs only a sample of + # statements running at least this number + # of milliseconds; + # sample fraction is determined by log_statement_sample_rate + +#log_statement_sample_rate = 1.0 # fraction of logged statements exceeding + # log_min_duration_sample to be logged; + # 1.0 logs all such statements, 0.0 never logs + + +#log_transaction_sample_rate = 0.0 # fraction of transactions whose statements + # are logged regardless of their duration; 1.0 logs all + # statements from all transactions, 0.0 never logs + +#log_startup_progress_interval = 10s # Time between progress updates for + # long-running startup operations. + # 0 disables the feature, > 0 indicates + # the interval in milliseconds. + +# - What to Log - + +#debug_print_parse = off +#debug_print_rewritten = off +#debug_print_plan = off +#debug_pretty_print = on +#log_autovacuum_min_duration = 10min # log autovacuum activity; + # -1 disables, 0 logs all actions and + # their durations, > 0 logs only + # actions running at least this number + # of milliseconds. +#log_checkpoints = on +#log_connections = off +#log_disconnections = off +#log_duration = off +#log_error_verbosity = default # terse, default, or verbose messages +#log_hostname = off +#log_line_prefix = '%m [%p] ' # special values: + # %a = application name + # %u = user name + # %d = database name + # %r = remote host and port + # %h = remote host + # %b = backend type + # %p = process ID + # %P = process ID of parallel group leader + # %t = timestamp without milliseconds + # %m = timestamp with milliseconds + # %n = timestamp with milliseconds (as a Unix epoch) + # %Q = query ID (0 if none or not computed) + # %i = command tag + # %e = SQL state + # %c = session ID + # %l = session line number + # %s = session start timestamp + # %v = virtual transaction ID + # %x = transaction ID (0 if none) + # %q = stop here in non-session + # processes + # %% = '%' + # e.g. '<%u%%%d> ' +#log_lock_waits = off # log lock waits >= deadlock_timeout +#log_recovery_conflict_waits = off # log standby recovery conflict waits + # >= deadlock_timeout +#log_parameter_max_length = -1 # when logging statements, limit logged + # bind-parameter values to N bytes; + # -1 means print in full, 0 disables +#log_parameter_max_length_on_error = 0 # when logging an error, limit logged + # bind-parameter values to N bytes; + # -1 means print in full, 0 disables +#log_statement = 'none' # none, ddl, mod, all +#log_replication_commands = off +#log_temp_files = -1 # log temporary files equal or larger + # than the specified size in kilobytes; + # -1 disables, 0 logs all temp files +log_timezone = 'Etc/UTC' + + +#------------------------------------------------------------------------------ +# PROCESS TITLE +#------------------------------------------------------------------------------ + +#cluster_name = '' # added to process titles if nonempty + # (change requires restart) +#update_process_title = on + + +#------------------------------------------------------------------------------ +# STATISTICS +#------------------------------------------------------------------------------ + +# - Cumulative Query and Index Statistics - + +#track_activities = on +#track_activity_query_size = 1024 # (change requires restart) +#track_counts = on +#track_io_timing = off +#track_wal_io_timing = off +#track_functions = none # none, pl, all +#stats_fetch_consistency = cache + + +# - Monitoring - + +#compute_query_id = auto +#log_statement_stats = off +#log_parser_stats = off +#log_planner_stats = off +#log_executor_stats = off + + +#------------------------------------------------------------------------------ +# AUTOVACUUM +#------------------------------------------------------------------------------ + +#autovacuum = on # Enable autovacuum subprocess? 'on' + # requires track_counts to also be on. +#autovacuum_max_workers = 3 # max number of autovacuum subprocesses + # (change requires restart) +#autovacuum_naptime = 1min # time between autovacuum runs +#autovacuum_vacuum_threshold = 50 # min number of row updates before + # vacuum +#autovacuum_vacuum_insert_threshold = 1000 # min number of row inserts + # before vacuum; -1 disables insert + # vacuums +#autovacuum_analyze_threshold = 50 # min number of row updates before + # analyze +#autovacuum_vacuum_scale_factor = 0.2 # fraction of table size before vacuum +#autovacuum_vacuum_insert_scale_factor = 0.2 # fraction of inserts over table + # size before insert vacuum +#autovacuum_analyze_scale_factor = 0.1 # fraction of table size before analyze +#autovacuum_freeze_max_age = 200000000 # maximum XID age before forced vacuum + # (change requires restart) +#autovacuum_multixact_freeze_max_age = 400000000 # maximum multixact age + # before forced vacuum + # (change requires restart) +#autovacuum_vacuum_cost_delay = 2ms # default vacuum cost delay for + # autovacuum, in milliseconds; + # -1 means use vacuum_cost_delay +#autovacuum_vacuum_cost_limit = -1 # default vacuum cost limit for + # autovacuum, -1 means use + # vacuum_cost_limit + + +#------------------------------------------------------------------------------ +# CLIENT CONNECTION DEFAULTS +#------------------------------------------------------------------------------ + +# - Statement Behavior - + +#client_min_messages = notice # values in order of decreasing detail: + # debug5 + # debug4 + # debug3 + # debug2 + # debug1 + # log + # notice + # warning + # error +#search_path = '"$user", public' # schema names +#row_security = on +#default_table_access_method = 'heap' +#default_tablespace = '' # a tablespace name, '' uses the default +#default_toast_compression = 'pglz' # 'pglz' or 'lz4' +#temp_tablespaces = '' # a list of tablespace names, '' uses + # only default tablespace +#check_function_bodies = on +#default_transaction_isolation = 'read committed' +#default_transaction_read_only = off +#default_transaction_deferrable = off +#session_replication_role = 'origin' +#statement_timeout = 0 # in milliseconds, 0 is disabled +#lock_timeout = 0 # in milliseconds, 0 is disabled +#idle_in_transaction_session_timeout = 0 # in milliseconds, 0 is disabled +#idle_session_timeout = 0 # in milliseconds, 0 is disabled +#vacuum_freeze_table_age = 150000000 +#vacuum_freeze_min_age = 50000000 +#vacuum_failsafe_age = 1600000000 +#vacuum_multixact_freeze_table_age = 150000000 +#vacuum_multixact_freeze_min_age = 5000000 +#vacuum_multixact_failsafe_age = 1600000000 +#bytea_output = 'hex' # hex, escape +#xmlbinary = 'base64' +#xmloption = 'content' +#gin_pending_list_limit = 4MB + +# - Locale and Formatting - + +datestyle = 'iso, mdy' +#intervalstyle = 'postgres' +timezone = 'Etc/UTC' +#timezone_abbreviations = 'Default' # Select the set of available time zone + # abbreviations. Currently, there are + # Default + # Australia (historical usage) + # India + # You can create your own file in + # share/timezonesets/. +#extra_float_digits = 1 # min -15, max 3; any value >0 actually + # selects precise output mode +#client_encoding = sql_ascii # actually, defaults to database + # encoding + +# These settings are initialized by initdb, but they can be changed. +lc_messages = 'en_US.utf8' # locale for system error message + # strings +lc_monetary = 'en_US.utf8' # locale for monetary formatting +lc_numeric = 'en_US.utf8' # locale for number formatting +lc_time = 'en_US.utf8' # locale for time formatting + +# default configuration for text search +default_text_search_config = 'pg_catalog.english' + +# - Shared Library Preloading - + +#local_preload_libraries = '' +#session_preload_libraries = '' +#shared_preload_libraries = '' # (change requires restart) +#jit_provider = 'llvmjit' # JIT library to use + +# - Other Defaults - + +#dynamic_library_path = '$libdir' +#extension_destdir = '' # prepend path when loading extensions + # and shared objects (added by Debian) +#gin_fuzzy_search_limit = 0 + + +#------------------------------------------------------------------------------ +# LOCK MANAGEMENT +#------------------------------------------------------------------------------ + +#deadlock_timeout = 1s +#max_locks_per_transaction = 64 # min 10 + # (change requires restart) +#max_pred_locks_per_transaction = 64 # min 10 + # (change requires restart) +#max_pred_locks_per_relation = -2 # negative values mean + # (max_pred_locks_per_transaction + # / -max_pred_locks_per_relation) - 1 +#max_pred_locks_per_page = 2 # min 0 + + +#------------------------------------------------------------------------------ +# VERSION AND PLATFORM COMPATIBILITY +#------------------------------------------------------------------------------ + +# - Previous PostgreSQL Versions - + +#array_nulls = on +#backslash_quote = safe_encoding # on, off, or safe_encoding +#escape_string_warning = on +#lo_compat_privileges = off +#quote_all_identifiers = off +#standard_conforming_strings = on +#synchronize_seqscans = on + +# - Other Platforms and Clients - + +#transform_null_equals = off + + +#------------------------------------------------------------------------------ +# ERROR HANDLING +#------------------------------------------------------------------------------ + +#exit_on_error = off # terminate session on any error? +#restart_after_crash = on # reinitialize after backend crash? +#data_sync_retry = off # retry or panic on failure to fsync + # data? + # (change requires restart) +#recovery_init_sync_method = fsync # fsync, syncfs (Linux 5.8+) + + +#------------------------------------------------------------------------------ +# CONFIG FILE INCLUDES +#------------------------------------------------------------------------------ + +# These options allow settings to be loaded from files other than the +# default postgresql.conf. Note that these are directives, not variable +# assignments, so they can usefully be given more than once. + +#include_dir = '...' # include files ending in '.conf' from + # a directory, e.g., 'conf.d' +#include_if_exists = '...' # include file only if it exists +#include = '...' # include file + + +#------------------------------------------------------------------------------ +# CUSTOMIZED OPTIONS +#------------------------------------------------------------------------------ + +# Add settings for extensions here diff --git a/config/environments/mainnet/prover.config.json b/config/environments/mainnet/prover.config.json new file mode 100644 index 0000000..15c999b --- /dev/null +++ b/config/environments/mainnet/prover.config.json @@ -0,0 +1,117 @@ +{ + "runProverServer": false, + "runProverServerMock": false, + "runProverClient": false, + + "runExecutorServer": true, + "runExecutorClient": false, + "runExecutorClientMultithread": false, + + "runHashDBServer": true, + "runHashDBTest": false, + + "runAggregatorServer": false, + "runAggregatorClient": false, + + "runFileGenProof": false, + "runFileGenBatchProof": false, + "runFileGenAggregatedProof": false, + "runFileGenFinalProof": false, + "runFileProcessBatch": false, + "runFileProcessBatchMultithread": false, + + "runKeccakScriptGenerator": false, + "runKeccakTest": false, + "runStorageSMTest": false, + "runBinarySMTest": false, + "runMemAlignSMTest": false, + "runSHA256Test": false, + "runBlakeTest": false, + + "executeInParallel": true, + "useMainExecGenerated": true, + "saveRequestToFile": false, + "saveInputToFile": false, + "saveDbReadsToFile": false, + "saveDbReadsToFileOnChange": false, + "saveOutputToFile": false, + "saveResponseToFile": false, + "loadDBToMemCache": true, + "opcodeTracer": false, + "logRemoteDbReads": false, + "logExecutorServerResponses": false, + + "proverServerPort": 50051, + "proverServerMockPort": 50052, + "proverServerMockTimeout": 10000000, + "proverClientPort": 50051, + "proverClientHost": "127.0.0.1", + + "executorServerPort": 50071, + "executorROMLineTraces": false, + "executorClientPort": 50071, + "executorClientHost": "127.0.0.1", + + "hashDBServerPort": 50061, + "hashDBURL": "local", + + "aggregatorServerPort": 50081, + "aggregatorClientPort": 50081, + "aggregatorClientHost": "127.0.0.1", + + "inputFile": "input_executor.json", + "outputPath": "output", + "cmPolsFile_disabled": "zkevm.commit", + "cmPolsFileC12a_disabled": "zkevm.c12a.commit", + "cmPolsFileRecursive1_disabled": "zkevm.recursive1.commit", + "constPolsFile": "zkevm.const", + "constPolsC12aFile": "zkevm.c12a.const", + "constPolsRecursive1File": "zkevm.recursive1.const", + "mapConstPolsFile": false, + "constantsTreeFile": "zkevm.consttree", + "constantsTreeC12aFile": "zkevm.c12a.consttree", + "constantsTreeRecursive1File": "zkevm.recursive1.consttree", + "mapConstantsTreeFile": false, + "starkFile": "zkevm.prove.json", + "starkZkIn": "zkevm.proof.zkin.json", + "starkZkInC12a":"zkevm.c12a.zkin.proof.json", + "starkFileRecursive1": "zkevm.recursive1.proof.json", + "verifierFile": "zkevm.verifier.dat", + "verifierFileRecursive1": "zkevm.recursive1.verifier.dat", + "witnessFile_disabled": "zkevm.witness.wtns", + "witnessFileRecursive1": "zkevm.recursive1.witness.wtns", + "execC12aFile": "zkevm.c12a.exec", + "execRecursive1File": "zkevm.recursive1.exec", + "starkVerifierFile": "zkevm.g16.0001.zkey", + "publicStarkFile": "zkevm.public.json", + "publicFile": "public.json", + "proofFile": "proof.json", + "keccakScriptFile": "keccak_script.json", + "keccakPolsFile_DISABLED": "keccak_pols.json", + "keccakConnectionsFile": "keccak_connections.json", + "starkInfoFile": "zkevm.starkinfo.json", + "starkInfoC12aFile": "zkevm.c12a.starkinfo.json", + "starkInfoRecursive1File": "zkevm.recursive1.starkinfo.json", + "databaseURL": "postgresql://prover_user:prover_pass@zkevm-state-db:5432/prover_db", + "dbNodesTableName": "state.nodes", + "dbProgramTableName": "state.program", + "dbAsyncWrite": false, + "dbMultiWrite": true, + "dbConnectionsPool": true, + "dbNumberOfPoolConnections": 30, + "dbMetrics": true, + "dbClearCache": false, + "dbGetTree": true, + "dbReadOnly": false, + "dbMTCacheSize": 8192, + "dbProgramCacheSize": 1024, + "cleanerPollingPeriod": 600, + "requestsPersistence": 3600, + "maxExecutorThreads": 20, + "maxProverThreads": 8, + "maxHashDBThreads": 8, + "ECRecoverPrecalc": false, + "ECRecoverPrecalcNThreads": 4, + "stateManager": true, + "useAssociativeCache" : false +} diff --git a/config/environments/testnet/ethtxmanager.config.toml b/config/environments/testnet/ethtxmanager.config.toml new file mode 100644 index 0000000..b89d5da --- /dev/null +++ b/config/environments/testnet/ethtxmanager.config.toml @@ -0,0 +1,34 @@ +[Log] +Environment = "development" # "production" or "development" +Level = "info" +Outputs = ["stderr"] + +[Etherman] +URL = "http://your.L1node.url" +ForkIDChunkSize = 20000 +MultiGasProvider = false + [Etherman.Etherscan] + ApiKey = "" + +[EthTxManager] +ForcedGas = 0 +PrivateKeys = [ + {Path = "/pk/sequencer.keystore", Password = "testonly"}, + {Path = "/pk/aggregator.keystore", Password = "testonly"} + ] + [EthTxManager.DB] + User = "ethtxmanager_user" + Password = "ethtxmanager_password" + Name = "ethtxmanager_db" + Host = "zkevm-ethtxmanager-db" + Port = "5432" + EnableLog = false + MaxConns = 200 + +[Metrics] +Host = "0.0.0.0" +Port = 9091 +Enabled = false +ProfilingHost = "0.0.0.0" +ProfilingPort = 6060 +ProfilingEnabled = false diff --git a/config/environments/testnet/example.env b/config/environments/testnet/example.env new file mode 100644 index 0000000..632cb39 --- /dev/null +++ b/config/environments/testnet/example.env @@ -0,0 +1,7 @@ +ZKEVM_NETWORK = "testnet" +# URL of a JSON RPC for Sepolia +ZKEVM_ETHTXMANAGER_ETHERMAN_URL = "http://your.L1node.url" +# PATH WHERE THE ETHTXMANAGER POSTGRES CONTAINER WILL STORE PERSISTENT DATA +ZKEVM_ETHTXMANAGER_DATA_DIR = "/path/to/persistent/data/ethtxmanager" +# OPTIONAL, UNCOMENT IF YOU WANT TO DO ADVANCED CONFIG +# ZKEVM_ADVANCED_CONFIG_DIR = "/should/be/same/path/as/ZKEVM_CONFIG_DIR" \ No newline at end of file diff --git a/config/environments/testnet/postgresql.conf b/config/environments/testnet/postgresql.conf new file mode 100644 index 0000000..51dff68 --- /dev/null +++ b/config/environments/testnet/postgresql.conf @@ -0,0 +1,815 @@ +# ----------------------------- +# PostgreSQL configuration file +# ----------------------------- +# +# This file consists of lines of the form: +# +# name = value +# +# (The "=" is optional.) Whitespace may be used. Comments are introduced with +# "#" anywhere on a line. The complete list of parameter names and allowed +# values can be found in the PostgreSQL documentation. +# +# The commented-out settings shown in this file represent the default values. +# Re-commenting a setting is NOT sufficient to revert it to the default value; +# you need to reload the server. +# +# This file is read on server startup and when the server receives a SIGHUP +# signal. If you edit the file on a running system, you have to SIGHUP the +# server for the changes to take effect, run "pg_ctl reload", or execute +# "SELECT pg_reload_conf()". Some parameters, which are marked below, +# require a server shutdown and restart to take effect. +# +# Any parameter can also be given as a command-line option to the server, e.g., +# "postgres -c log_connections=on". Some parameters can be changed at run time +# with the "SET" SQL command. +# +# Memory units: B = bytes Time units: us = microseconds +# kB = kilobytes ms = milliseconds +# MB = megabytes s = seconds +# GB = gigabytes min = minutes +# TB = terabytes h = hours +# d = days + + +#------------------------------------------------------------------------------ +# FILE LOCATIONS +#------------------------------------------------------------------------------ + +# The default values of these variables are driven from the -D command-line +# option or PGDATA environment variable, represented here as ConfigDir. + +#data_directory = 'ConfigDir' # use data in another directory + # (change requires restart) +#hba_file = 'ConfigDir/pg_hba.conf' # host-based authentication file + # (change requires restart) +#ident_file = 'ConfigDir/pg_ident.conf' # ident configuration file + # (change requires restart) + +# If external_pid_file is not explicitly set, no extra PID file is written. +#external_pid_file = '' # write an extra PID file + # (change requires restart) + + +#------------------------------------------------------------------------------ +# CONNECTIONS AND AUTHENTICATION +#------------------------------------------------------------------------------ + +# - Connection Settings - + +listen_addresses = '*' + # comma-separated list of addresses; + # defaults to 'localhost'; use '*' for all + # (change requires restart) +#port = 5432 # (change requires restart) +max_connections = 100 # (change requires restart) +#superuser_reserved_connections = 3 # (change requires restart) +#unix_socket_directories = '/var/run/postgresql' # comma-separated list of directories + # (change requires restart) +#unix_socket_group = '' # (change requires restart) +#unix_socket_permissions = 0777 # begin with 0 to use octal notation + # (change requires restart) +#bonjour = off # advertise server via Bonjour + # (change requires restart) +#bonjour_name = '' # defaults to the computer name + # (change requires restart) + +# - TCP settings - +# see "man tcp" for details + +#tcp_keepalives_idle = 0 # TCP_KEEPIDLE, in seconds; + # 0 selects the system default +#tcp_keepalives_interval = 0 # TCP_KEEPINTVL, in seconds; + # 0 selects the system default +#tcp_keepalives_count = 0 # TCP_KEEPCNT; + # 0 selects the system default +#tcp_user_timeout = 0 # TCP_USER_TIMEOUT, in milliseconds; + # 0 selects the system default + +#client_connection_check_interval = 0 # time between checks for client + # disconnection while running queries; + # 0 for never + +# - Authentication - + +#authentication_timeout = 1min # 1s-600s +#password_encryption = scram-sha-256 # scram-sha-256 or md5 +#db_user_namespace = off + +# GSSAPI using Kerberos +#krb_server_keyfile = 'FILE:${sysconfdir}/krb5.keytab' +#krb_caseins_users = off + +# - SSL - + +#ssl = off +#ssl_ca_file = '' +#ssl_cert_file = 'server.crt' +#ssl_crl_file = '' +#ssl_crl_dir = '' +#ssl_key_file = 'server.key' +#ssl_ciphers = 'HIGH:MEDIUM:+3DES:!aNULL' # allowed SSL ciphers +#ssl_prefer_server_ciphers = on +#ssl_ecdh_curve = 'prime256v1' +#ssl_min_protocol_version = 'TLSv1.2' +#ssl_max_protocol_version = '' +#ssl_dh_params_file = '' +#ssl_passphrase_command = '' +#ssl_passphrase_command_supports_reload = off + + +#------------------------------------------------------------------------------ +# RESOURCE USAGE (except WAL) +#------------------------------------------------------------------------------ + +# - Memory - + +shared_buffers = 8GB # min 128kB + # (change requires restart) +#huge_pages = try # on, off, or try + # (change requires restart) +#huge_page_size = 0 # zero for system default + # (change requires restart) +temp_buffers = 64MB # min 800kB +#max_prepared_transactions = 0 # zero disables the feature + # (change requires restart) +# Caution: it is not advisable to set max_prepared_transactions nonzero unless +# you actively intend to use prepared transactions. +work_mem = 104857kB # min 64kB +#hash_mem_multiplier = 2.0 # 1-1000.0 multiplier on hash table work_mem +maintenance_work_mem = 2GB # min 1MB +#autovacuum_work_mem = -1 # min 1MB, or -1 to use maintenance_work_mem +#logical_decoding_work_mem = 64MB # min 64kB +#max_stack_depth = 2MB # min 100kB +#shared_memory_type = mmap # the default is the first option + # supported by the operating system: + # mmap + # sysv + # windows + # (change requires restart) +dynamic_shared_memory_type = posix # the default is usually the first option + # supported by the operating system: + # posix + # sysv + # windows + # mmap + # (change requires restart) +#min_dynamic_shared_memory = 0MB # (change requires restart) + +# - Disk - + +#temp_file_limit = -1 # limits per-process temp file space + # in kilobytes, or -1 for no limit + +# - Kernel Resources - + +#max_files_per_process = 1000 # min 64 + # (change requires restart) + +# - Cost-Based Vacuum Delay - + +#vacuum_cost_delay = 0 # 0-100 milliseconds (0 disables) +#vacuum_cost_page_hit = 1 # 0-10000 credits +#vacuum_cost_page_miss = 2 # 0-10000 credits +#vacuum_cost_page_dirty = 20 # 0-10000 credits +#vacuum_cost_limit = 200 # 1-10000 credits + +# - Background Writer - + +#bgwriter_delay = 200ms # 10-10000ms between rounds +#bgwriter_lru_maxpages = 100 # max buffers written/round, 0 disables +#bgwriter_lru_multiplier = 2.0 # 0-10.0 multiplier on buffers scanned/round +#bgwriter_flush_after = 512kB # measured in pages, 0 disables + +# - Asynchronous Behavior - + +#backend_flush_after = 0 # measured in pages, 0 disables +effective_io_concurrency = 300 # 1-1000; 0 disables prefetching +#maintenance_io_concurrency = 10 # 1-1000; 0 disables prefetching +max_worker_processes = 16 # (change requires restart) +max_parallel_workers_per_gather = 4 # taken from max_parallel_workers +max_parallel_maintenance_workers = 4 # taken from max_parallel_workers +max_parallel_workers = 16 # maximum number of max_worker_processes that + # can be used in parallel operations +#parallel_leader_participation = on +#old_snapshot_threshold = -1 # 1min-60d; -1 disables; 0 is immediate + # (change requires restart) + + +#------------------------------------------------------------------------------ +# WRITE-AHEAD LOG +#------------------------------------------------------------------------------ + +# - Settings - + +#wal_level = replica # minimal, replica, or logical + # (change requires restart) +#fsync = on # flush data to disk for crash safety + # (turning this off can cause + # unrecoverable data corruption) +#synchronous_commit = on # synchronization level; + # off, local, remote_write, remote_apply, or on +#wal_sync_method = fsync # the default is the first option + # supported by the operating system: + # open_datasync + # fdatasync (default on Linux and FreeBSD) + # fsync + # fsync_writethrough + # open_sync +#full_page_writes = on # recover from partial page writes +#wal_log_hints = off # also do full page writes of non-critical updates + # (change requires restart) +#wal_compression = off # enables compression of full-page writes; + # off, pglz, lz4, zstd, or on +#wal_init_zero = on # zero-fill new WAL files +#wal_recycle = on # recycle WAL files +wal_buffers = 16MB # min 32kB, -1 sets based on shared_buffers + # (change requires restart) +#wal_writer_delay = 200ms # 1-10000 milliseconds +#wal_writer_flush_after = 1MB # measured in pages, 0 disables +#wal_skip_threshold = 2MB + +#commit_delay = 0 # range 0-100000, in microseconds +#commit_siblings = 5 # range 1-1000 + +# - Checkpoints - + +#checkpoint_timeout = 5min # range 30s-1d +checkpoint_completion_target = 0.9 # checkpoint target duration, 0.0 - 1.0 +#checkpoint_flush_after = 256kB # measured in pages, 0 disables +#checkpoint_warning = 30s # 0 disables +max_wal_size = 8GB +min_wal_size = 2GB + +# - Prefetching during recovery - + +#recovery_prefetch = try # prefetch pages referenced in the WAL? +#wal_decode_buffer_size = 512kB # lookahead window used for prefetching + # (change requires restart) + +# - Archiving - + +#archive_mode = off # enables archiving; off, on, or always + # (change requires restart) +#archive_library = '' # library to use to archive a logfile segment + # (empty string indicates archive_command should + # be used) +#archive_command = '' # command to use to archive a logfile segment + # placeholders: %p = path of file to archive + # %f = file name only + # e.g. 'test ! -f /mnt/server/archivedir/%f && cp %p /mnt/server/archivedir/%f' +#archive_timeout = 0 # force a logfile segment switch after this + # number of seconds; 0 disables + +# - Archive Recovery - + +# These are only used in recovery mode. + +#restore_command = '' # command to use to restore an archived logfile segment + # placeholders: %p = path of file to restore + # %f = file name only + # e.g. 'cp /mnt/server/archivedir/%f %p' +#archive_cleanup_command = '' # command to execute at every restartpoint +#recovery_end_command = '' # command to execute at completion of recovery + +# - Recovery Target - + +# Set these only when performing a targeted recovery. + +#recovery_target = '' # 'immediate' to end recovery as soon as a + # consistent state is reached + # (change requires restart) +#recovery_target_name = '' # the named restore point to which recovery will proceed + # (change requires restart) +#recovery_target_time = '' # the time stamp up to which recovery will proceed + # (change requires restart) +#recovery_target_xid = '' # the transaction ID up to which recovery will proceed + # (change requires restart) +#recovery_target_lsn = '' # the WAL LSN up to which recovery will proceed + # (change requires restart) +#recovery_target_inclusive = on # Specifies whether to stop: + # just after the specified recovery target (on) + # just before the recovery target (off) + # (change requires restart) +#recovery_target_timeline = 'latest' # 'current', 'latest', or timeline ID + # (change requires restart) +#recovery_target_action = 'pause' # 'pause', 'promote', 'shutdown' + # (change requires restart) + + +#------------------------------------------------------------------------------ +# REPLICATION +#------------------------------------------------------------------------------ + +# - Sending Servers - + +# Set these on the primary and on any standby that will send replication data. + +#max_wal_senders = 10 # max number of walsender processes + # (change requires restart) +#max_replication_slots = 10 # max number of replication slots + # (change requires restart) +#wal_keep_size = 0 # in megabytes; 0 disables +#max_slot_wal_keep_size = -1 # in megabytes; -1 disables +#wal_sender_timeout = 60s # in milliseconds; 0 disables +#track_commit_timestamp = off # collect timestamp of transaction commit + # (change requires restart) + +# - Primary Server - + +# These settings are ignored on a standby server. + +#synchronous_standby_names = '' # standby servers that provide sync rep + # method to choose sync standbys, number of sync standbys, + # and comma-separated list of application_name + # from standby(s); '*' = all +#vacuum_defer_cleanup_age = 0 # number of xacts by which cleanup is delayed + +# - Standby Servers - + +# These settings are ignored on a primary server. + +#primary_conninfo = '' # connection string to sending server +#primary_slot_name = '' # replication slot on sending server +#promote_trigger_file = '' # file name whose presence ends recovery +#hot_standby = on # "off" disallows queries during recovery + # (change requires restart) +#max_standby_archive_delay = 30s # max delay before canceling queries + # when reading WAL from archive; + # -1 allows indefinite delay +#max_standby_streaming_delay = 30s # max delay before canceling queries + # when reading streaming WAL; + # -1 allows indefinite delay +#wal_receiver_create_temp_slot = off # create temp slot if primary_slot_name + # is not set +#wal_receiver_status_interval = 10s # send replies at least this often + # 0 disables +#hot_standby_feedback = off # send info from standby to prevent + # query conflicts +#wal_receiver_timeout = 60s # time that receiver waits for + # communication from primary + # in milliseconds; 0 disables +#wal_retrieve_retry_interval = 5s # time to wait before retrying to + # retrieve WAL after a failed attempt +#recovery_min_apply_delay = 0 # minimum delay for applying changes during recovery + +# - Subscribers - + +# These settings are ignored on a publisher. + +#max_logical_replication_workers = 4 # taken from max_worker_processes + # (change requires restart) +#max_sync_workers_per_subscription = 2 # taken from max_logical_replication_workers + + +#------------------------------------------------------------------------------ +# QUERY TUNING +#------------------------------------------------------------------------------ + +# - Planner Method Configuration - + +#enable_async_append = on +#enable_bitmapscan = on +#enable_gathermerge = on +#enable_hashagg = on +#enable_hashjoin = on +#enable_incremental_sort = on +#enable_indexscan = on +#enable_indexonlyscan = on +#enable_material = on +#enable_memoize = on +#enable_mergejoin = on +#enable_nestloop = on +#enable_parallel_append = on +#enable_parallel_hash = on +#enable_partition_pruning = on +#enable_partitionwise_join = off +#enable_partitionwise_aggregate = off +#enable_seqscan = on +#enable_sort = on +#enable_tidscan = on + +# - Planner Cost Constants - + +#seq_page_cost = 1.0 # measured on an arbitrary scale +random_page_cost = 1.1 # same scale as above +#cpu_tuple_cost = 0.01 # same scale as above +#cpu_index_tuple_cost = 0.005 # same scale as above +#cpu_operator_cost = 0.0025 # same scale as above +#parallel_setup_cost = 1000.0 # same scale as above +#parallel_tuple_cost = 0.1 # same scale as above +#min_parallel_table_scan_size = 8MB +#min_parallel_index_scan_size = 512kB +effective_cache_size = 24GB + +#jit_above_cost = 100000 # perform JIT compilation if available + # and query more expensive than this; + # -1 disables +#jit_inline_above_cost = 500000 # inline small functions if query is + # more expensive than this; -1 disables +#jit_optimize_above_cost = 500000 # use expensive JIT optimizations if + # query is more expensive than this; + # -1 disables + +# - Genetic Query Optimizer - + +#geqo = on +#geqo_threshold = 12 +#geqo_effort = 5 # range 1-10 +#geqo_pool_size = 0 # selects default based on effort +#geqo_generations = 0 # selects default based on effort +#geqo_selection_bias = 2.0 # range 1.5-2.0 +#geqo_seed = 0.0 # range 0.0-1.0 + +# - Other Planner Options - + +default_statistics_target = 100 # range 1-10000 +#constraint_exclusion = partition # on, off, or partition +#cursor_tuple_fraction = 0.1 # range 0.0-1.0 +#from_collapse_limit = 8 +#jit = on # allow JIT compilation +#join_collapse_limit = 8 # 1 disables collapsing of explicit + # JOIN clauses +#plan_cache_mode = auto # auto, force_generic_plan or + # force_custom_plan +#recursive_worktable_factor = 10.0 # range 0.001-1000000 + + +#------------------------------------------------------------------------------ +# REPORTING AND LOGGING +#------------------------------------------------------------------------------ + +# - Where to Log - + +#log_destination = 'stderr' # Valid values are combinations of + # stderr, csvlog, jsonlog, syslog, and + # eventlog, depending on platform. + # csvlog and jsonlog require + # logging_collector to be on. + +# This is used when logging to stderr: +#logging_collector = off # Enable capturing of stderr, jsonlog, + # and csvlog into log files. Required + # to be on for csvlogs and jsonlogs. + # (change requires restart) + +# These are only used if logging_collector is on: +#log_directory = 'log' # directory where log files are written, + # can be absolute or relative to PGDATA +#log_filename = 'postgresql-%Y-%m-%d_%H%M%S.log' # log file name pattern, + # can include strftime() escapes +#log_file_mode = 0600 # creation mode for log files, + # begin with 0 to use octal notation +#log_rotation_age = 1d # Automatic rotation of logfiles will + # happen after that time. 0 disables. +#log_rotation_size = 10MB # Automatic rotation of logfiles will + # happen after that much log output. + # 0 disables. +#log_truncate_on_rotation = off # If on, an existing log file with the + # same name as the new log file will be + # truncated rather than appended to. + # But such truncation only occurs on + # time-driven rotation, not on restarts + # or size-driven rotation. Default is + # off, meaning append to existing files + # in all cases. + +# These are relevant when logging to syslog: +#syslog_facility = 'LOCAL0' +#syslog_ident = 'postgres' +#syslog_sequence_numbers = on +#syslog_split_messages = on + +# This is only relevant when logging to eventlog (Windows): +# (change requires restart) +#event_source = 'PostgreSQL' + +# - When to Log - + +#log_min_messages = warning # values in order of decreasing detail: + # debug5 + # debug4 + # debug3 + # debug2 + # debug1 + # info + # notice + # warning + # error + # log + # fatal + # panic + +#log_min_error_statement = error # values in order of decreasing detail: + # debug5 + # debug4 + # debug3 + # debug2 + # debug1 + # info + # notice + # warning + # error + # log + # fatal + # panic (effectively off) + +#log_min_duration_statement = -1 # -1 is disabled, 0 logs all statements + # and their durations, > 0 logs only + # statements running at least this number + # of milliseconds + +#log_min_duration_sample = -1 # -1 is disabled, 0 logs a sample of statements + # and their durations, > 0 logs only a sample of + # statements running at least this number + # of milliseconds; + # sample fraction is determined by log_statement_sample_rate + +#log_statement_sample_rate = 1.0 # fraction of logged statements exceeding + # log_min_duration_sample to be logged; + # 1.0 logs all such statements, 0.0 never logs + + +#log_transaction_sample_rate = 0.0 # fraction of transactions whose statements + # are logged regardless of their duration; 1.0 logs all + # statements from all transactions, 0.0 never logs + +#log_startup_progress_interval = 10s # Time between progress updates for + # long-running startup operations. + # 0 disables the feature, > 0 indicates + # the interval in milliseconds. + +# - What to Log - + +#debug_print_parse = off +#debug_print_rewritten = off +#debug_print_plan = off +#debug_pretty_print = on +#log_autovacuum_min_duration = 10min # log autovacuum activity; + # -1 disables, 0 logs all actions and + # their durations, > 0 logs only + # actions running at least this number + # of milliseconds. +#log_checkpoints = on +#log_connections = off +#log_disconnections = off +#log_duration = off +#log_error_verbosity = default # terse, default, or verbose messages +#log_hostname = off +#log_line_prefix = '%m [%p] ' # special values: + # %a = application name + # %u = user name + # %d = database name + # %r = remote host and port + # %h = remote host + # %b = backend type + # %p = process ID + # %P = process ID of parallel group leader + # %t = timestamp without milliseconds + # %m = timestamp with milliseconds + # %n = timestamp with milliseconds (as a Unix epoch) + # %Q = query ID (0 if none or not computed) + # %i = command tag + # %e = SQL state + # %c = session ID + # %l = session line number + # %s = session start timestamp + # %v = virtual transaction ID + # %x = transaction ID (0 if none) + # %q = stop here in non-session + # processes + # %% = '%' + # e.g. '<%u%%%d> ' +#log_lock_waits = off # log lock waits >= deadlock_timeout +#log_recovery_conflict_waits = off # log standby recovery conflict waits + # >= deadlock_timeout +#log_parameter_max_length = -1 # when logging statements, limit logged + # bind-parameter values to N bytes; + # -1 means print in full, 0 disables +#log_parameter_max_length_on_error = 0 # when logging an error, limit logged + # bind-parameter values to N bytes; + # -1 means print in full, 0 disables +#log_statement = 'none' # none, ddl, mod, all +#log_replication_commands = off +#log_temp_files = -1 # log temporary files equal or larger + # than the specified size in kilobytes; + # -1 disables, 0 logs all temp files +log_timezone = 'Etc/UTC' + + +#------------------------------------------------------------------------------ +# PROCESS TITLE +#------------------------------------------------------------------------------ + +#cluster_name = '' # added to process titles if nonempty + # (change requires restart) +#update_process_title = on + + +#------------------------------------------------------------------------------ +# STATISTICS +#------------------------------------------------------------------------------ + +# - Cumulative Query and Index Statistics - + +#track_activities = on +#track_activity_query_size = 1024 # (change requires restart) +#track_counts = on +#track_io_timing = off +#track_wal_io_timing = off +#track_functions = none # none, pl, all +#stats_fetch_consistency = cache + + +# - Monitoring - + +#compute_query_id = auto +#log_statement_stats = off +#log_parser_stats = off +#log_planner_stats = off +#log_executor_stats = off + + +#------------------------------------------------------------------------------ +# AUTOVACUUM +#------------------------------------------------------------------------------ + +#autovacuum = on # Enable autovacuum subprocess? 'on' + # requires track_counts to also be on. +#autovacuum_max_workers = 3 # max number of autovacuum subprocesses + # (change requires restart) +#autovacuum_naptime = 1min # time between autovacuum runs +#autovacuum_vacuum_threshold = 50 # min number of row updates before + # vacuum +#autovacuum_vacuum_insert_threshold = 1000 # min number of row inserts + # before vacuum; -1 disables insert + # vacuums +#autovacuum_analyze_threshold = 50 # min number of row updates before + # analyze +#autovacuum_vacuum_scale_factor = 0.2 # fraction of table size before vacuum +#autovacuum_vacuum_insert_scale_factor = 0.2 # fraction of inserts over table + # size before insert vacuum +#autovacuum_analyze_scale_factor = 0.1 # fraction of table size before analyze +#autovacuum_freeze_max_age = 200000000 # maximum XID age before forced vacuum + # (change requires restart) +#autovacuum_multixact_freeze_max_age = 400000000 # maximum multixact age + # before forced vacuum + # (change requires restart) +#autovacuum_vacuum_cost_delay = 2ms # default vacuum cost delay for + # autovacuum, in milliseconds; + # -1 means use vacuum_cost_delay +#autovacuum_vacuum_cost_limit = -1 # default vacuum cost limit for + # autovacuum, -1 means use + # vacuum_cost_limit + + +#------------------------------------------------------------------------------ +# CLIENT CONNECTION DEFAULTS +#------------------------------------------------------------------------------ + +# - Statement Behavior - + +#client_min_messages = notice # values in order of decreasing detail: + # debug5 + # debug4 + # debug3 + # debug2 + # debug1 + # log + # notice + # warning + # error +#search_path = '"$user", public' # schema names +#row_security = on +#default_table_access_method = 'heap' +#default_tablespace = '' # a tablespace name, '' uses the default +#default_toast_compression = 'pglz' # 'pglz' or 'lz4' +#temp_tablespaces = '' # a list of tablespace names, '' uses + # only default tablespace +#check_function_bodies = on +#default_transaction_isolation = 'read committed' +#default_transaction_read_only = off +#default_transaction_deferrable = off +#session_replication_role = 'origin' +#statement_timeout = 0 # in milliseconds, 0 is disabled +#lock_timeout = 0 # in milliseconds, 0 is disabled +#idle_in_transaction_session_timeout = 0 # in milliseconds, 0 is disabled +#idle_session_timeout = 0 # in milliseconds, 0 is disabled +#vacuum_freeze_table_age = 150000000 +#vacuum_freeze_min_age = 50000000 +#vacuum_failsafe_age = 1600000000 +#vacuum_multixact_freeze_table_age = 150000000 +#vacuum_multixact_freeze_min_age = 5000000 +#vacuum_multixact_failsafe_age = 1600000000 +#bytea_output = 'hex' # hex, escape +#xmlbinary = 'base64' +#xmloption = 'content' +#gin_pending_list_limit = 4MB + +# - Locale and Formatting - + +datestyle = 'iso, mdy' +#intervalstyle = 'postgres' +timezone = 'Etc/UTC' +#timezone_abbreviations = 'Default' # Select the set of available time zone + # abbreviations. Currently, there are + # Default + # Australia (historical usage) + # India + # You can create your own file in + # share/timezonesets/. +#extra_float_digits = 1 # min -15, max 3; any value >0 actually + # selects precise output mode +#client_encoding = sql_ascii # actually, defaults to database + # encoding + +# These settings are initialized by initdb, but they can be changed. +lc_messages = 'en_US.utf8' # locale for system error message + # strings +lc_monetary = 'en_US.utf8' # locale for monetary formatting +lc_numeric = 'en_US.utf8' # locale for number formatting +lc_time = 'en_US.utf8' # locale for time formatting + +# default configuration for text search +default_text_search_config = 'pg_catalog.english' + +# - Shared Library Preloading - + +#local_preload_libraries = '' +#session_preload_libraries = '' +#shared_preload_libraries = '' # (change requires restart) +#jit_provider = 'llvmjit' # JIT library to use + +# - Other Defaults - + +#dynamic_library_path = '$libdir' +#extension_destdir = '' # prepend path when loading extensions + # and shared objects (added by Debian) +#gin_fuzzy_search_limit = 0 + + +#------------------------------------------------------------------------------ +# LOCK MANAGEMENT +#------------------------------------------------------------------------------ + +#deadlock_timeout = 1s +#max_locks_per_transaction = 64 # min 10 + # (change requires restart) +#max_pred_locks_per_transaction = 64 # min 10 + # (change requires restart) +#max_pred_locks_per_relation = -2 # negative values mean + # (max_pred_locks_per_transaction + # / -max_pred_locks_per_relation) - 1 +#max_pred_locks_per_page = 2 # min 0 + + +#------------------------------------------------------------------------------ +# VERSION AND PLATFORM COMPATIBILITY +#------------------------------------------------------------------------------ + +# - Previous PostgreSQL Versions - + +#array_nulls = on +#backslash_quote = safe_encoding # on, off, or safe_encoding +#escape_string_warning = on +#lo_compat_privileges = off +#quote_all_identifiers = off +#standard_conforming_strings = on +#synchronize_seqscans = on + +# - Other Platforms and Clients - + +#transform_null_equals = off + + +#------------------------------------------------------------------------------ +# ERROR HANDLING +#------------------------------------------------------------------------------ + +#exit_on_error = off # terminate session on any error? +#restart_after_crash = on # reinitialize after backend crash? +#data_sync_retry = off # retry or panic on failure to fsync + # data? + # (change requires restart) +#recovery_init_sync_method = fsync # fsync, syncfs (Linux 5.8+) + + +#------------------------------------------------------------------------------ +# CONFIG FILE INCLUDES +#------------------------------------------------------------------------------ + +# These options allow settings to be loaded from files other than the +# default postgresql.conf. Note that these are directives, not variable +# assignments, so they can usefully be given more than once. + +#include_dir = '...' # include files ending in '.conf' from + # a directory, e.g., 'conf.d' +#include_if_exists = '...' # include file only if it exists +#include = '...' # include file + + +#------------------------------------------------------------------------------ +# CUSTOMIZED OPTIONS +#------------------------------------------------------------------------------ + +# Add settings for extensions here diff --git a/config/environments/testnet/prover.config.json b/config/environments/testnet/prover.config.json new file mode 100644 index 0000000..15c999b --- /dev/null +++ b/config/environments/testnet/prover.config.json @@ -0,0 +1,117 @@ +{ + "runProverServer": false, + "runProverServerMock": false, + "runProverClient": false, + + "runExecutorServer": true, + "runExecutorClient": false, + "runExecutorClientMultithread": false, + + "runHashDBServer": true, + "runHashDBTest": false, + + "runAggregatorServer": false, + "runAggregatorClient": false, + + "runFileGenProof": false, + "runFileGenBatchProof": false, + "runFileGenAggregatedProof": false, + "runFileGenFinalProof": false, + "runFileProcessBatch": false, + "runFileProcessBatchMultithread": false, + + "runKeccakScriptGenerator": false, + "runKeccakTest": false, + "runStorageSMTest": false, + "runBinarySMTest": false, + "runMemAlignSMTest": false, + "runSHA256Test": false, + "runBlakeTest": false, + + "executeInParallel": true, + "useMainExecGenerated": true, + "saveRequestToFile": false, + "saveInputToFile": false, + "saveDbReadsToFile": false, + "saveDbReadsToFileOnChange": false, + "saveOutputToFile": false, + "saveResponseToFile": false, + "loadDBToMemCache": true, + "opcodeTracer": false, + "logRemoteDbReads": false, + "logExecutorServerResponses": false, + + "proverServerPort": 50051, + "proverServerMockPort": 50052, + "proverServerMockTimeout": 10000000, + "proverClientPort": 50051, + "proverClientHost": "127.0.0.1", + + "executorServerPort": 50071, + "executorROMLineTraces": false, + "executorClientPort": 50071, + "executorClientHost": "127.0.0.1", + + "hashDBServerPort": 50061, + "hashDBURL": "local", + + "aggregatorServerPort": 50081, + "aggregatorClientPort": 50081, + "aggregatorClientHost": "127.0.0.1", + + "inputFile": "input_executor.json", + "outputPath": "output", + "cmPolsFile_disabled": "zkevm.commit", + "cmPolsFileC12a_disabled": "zkevm.c12a.commit", + "cmPolsFileRecursive1_disabled": "zkevm.recursive1.commit", + "constPolsFile": "zkevm.const", + "constPolsC12aFile": "zkevm.c12a.const", + "constPolsRecursive1File": "zkevm.recursive1.const", + "mapConstPolsFile": false, + "constantsTreeFile": "zkevm.consttree", + "constantsTreeC12aFile": "zkevm.c12a.consttree", + "constantsTreeRecursive1File": "zkevm.recursive1.consttree", + "mapConstantsTreeFile": false, + "starkFile": "zkevm.prove.json", + "starkZkIn": "zkevm.proof.zkin.json", + "starkZkInC12a":"zkevm.c12a.zkin.proof.json", + "starkFileRecursive1": "zkevm.recursive1.proof.json", + "verifierFile": "zkevm.verifier.dat", + "verifierFileRecursive1": "zkevm.recursive1.verifier.dat", + "witnessFile_disabled": "zkevm.witness.wtns", + "witnessFileRecursive1": "zkevm.recursive1.witness.wtns", + "execC12aFile": "zkevm.c12a.exec", + "execRecursive1File": "zkevm.recursive1.exec", + "starkVerifierFile": "zkevm.g16.0001.zkey", + "publicStarkFile": "zkevm.public.json", + "publicFile": "public.json", + "proofFile": "proof.json", + "keccakScriptFile": "keccak_script.json", + "keccakPolsFile_DISABLED": "keccak_pols.json", + "keccakConnectionsFile": "keccak_connections.json", + "starkInfoFile": "zkevm.starkinfo.json", + "starkInfoC12aFile": "zkevm.c12a.starkinfo.json", + "starkInfoRecursive1File": "zkevm.recursive1.starkinfo.json", + "databaseURL": "postgresql://prover_user:prover_pass@zkevm-state-db:5432/prover_db", + "dbNodesTableName": "state.nodes", + "dbProgramTableName": "state.program", + "dbAsyncWrite": false, + "dbMultiWrite": true, + "dbConnectionsPool": true, + "dbNumberOfPoolConnections": 30, + "dbMetrics": true, + "dbClearCache": false, + "dbGetTree": true, + "dbReadOnly": false, + "dbMTCacheSize": 8192, + "dbProgramCacheSize": 1024, + "cleanerPollingPeriod": 600, + "requestsPersistence": 3600, + "maxExecutorThreads": 20, + "maxProverThreads": 8, + "maxHashDBThreads": 8, + "ECRecoverPrecalc": false, + "ECRecoverPrecalcNThreads": 4, + "stateManager": true, + "useAssociativeCache" : false +} diff --git a/config/example.keystore b/config/example.keystore new file mode 100644 index 0000000..96b662b --- /dev/null +++ b/config/example.keystore @@ -0,0 +1 @@ +{"address":"f39fd6e51aad88f6f4ce6ab8827279cfffb92266","crypto":{"cipher":"aes-128-ctr","ciphertext":"d005030a7684f3adad2447cbb27f63039eec2224c451eaa445de0d90502b9f3d","cipherparams":{"iv":"dc07a54bc7e388efa89c34d42f2ebdb4"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":262144,"p":1,"r":8,"salt":"cf2ec55ecae11171de575112cfb16963570533a9c46fb774473ceb11519eb24a"},"mac":"3eb180d405a5da6e462b2adc00091c14856c91d574bf27348714506357d6e177"},"id":"035454db-6b6d-477f-8a79-ce24c10b185f","version":3} \ No newline at end of file diff --git a/config/genesis.go b/config/genesis.go new file mode 100644 index 0000000..55a9133 --- /dev/null +++ b/config/genesis.go @@ -0,0 +1,26 @@ +package config + +import ( + "github.com/ethereum/go-ethereum/common" +) + +// Genesis contains the information to populate state on creation +type Genesis struct { + // BlockNumber is the block number where the polygonZKEVM smc was deployed on L1 + BlockNumber uint64 + // Root hash of the genesis block + Root common.Hash + // Actions is the data to populate into the state trie + Actions []*GenesisAction +} + +// GenesisAction represents one of the values set on the SMT during genesis. +type GenesisAction struct { + Address string `json:"address"` + Type int `json:"type"` + StoragePosition string `json:"storagePosition"` + Bytecode string `json:"bytecode"` + Key string `json:"key"` + Value string `json:"value"` + Root string `json:"root"` +} diff --git a/config/mainnetgenesis.go b/config/mainnetgenesis.go new file mode 100644 index 0000000..d981590 --- /dev/null +++ b/config/mainnetgenesis.go @@ -0,0 +1,107 @@ +package config + +// MainnetNetworkConfigJSON is the hardcoded network configuration to be used for the official mainnet setup +const MainnetNetworkConfigJSON = ` +{ + "l1Config" : { + "chainId": 1, + "polygonZkEVMAddress": "0x5132A183E9F3CB7C848b0AAC5Ae0c4f0491B7aB2", + "polTokenAddress": "0x7D1AfA7B718fb893dB30A3aBc0Cfc608AaCfeBB0", + "polygonZkEVMGlobalExitRootAddress": "0x580bda1e7A0CFAe92Fa7F6c20A3794F169CE3CFb" + }, + "root": "0x3f86b09b43e3e49a41fc20a07579b79eba044253367817d5c241d23c0e2bc5c9", + "genesisBlockNumber": 16896721, + "genesis": [ + { + "contractName": "PolygonZkEVMDeployer", + "balance": "0", + "nonce": "4", + "address": "0xCB19eDdE626906eB1EE52357a27F62dd519608C2", + "bytecode": "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", + "storage": { + "0x0000000000000000000000000000000000000000000000000000000000000000": "0x0000000000000000000000004c1665d6651ecefa59b9b3041951608468b18891" + } + }, + { + "contractName": "ProxyAdmin", + "balance": "0", + "nonce": "1", + "address": "0x0F99738B2Fc14D77308337f3e2596b63aE7BCC4A", + "bytecode": "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", + "storage": { + "0x0000000000000000000000000000000000000000000000000000000000000000": "0x000000000000000000000000bba0935fa93eb23de7990b47f0d96a8f75766d13" + } + }, + { + "contractName": "PolygonZkEVMBridge implementation", + "balance": "0", + "nonce": "1", + "address": "0x5ac4182A1dd41AeEf465E40B82fd326BF66AB82C", + "bytecode": "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" + }, + { + "contractName": "PolygonZkEVMBridge proxy", + "balance": "200000000000000000000000000", + "nonce": "1", + "address": "0x2a3DD3EB832aF982ec71669E178424b10Dca2EDe", + "bytecode": "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", + "storage": { + "0x0000000000000000000000000000000000000000000000000000000000000000": "0x0000000000000000000000000000000000000000000000000000000000000001", + "0x0000000000000000000000000000000000000000000000000000000000000001": "0x0000000000000000000000000000000000000000000000000000000000000001", + "0x0000000000000000000000000000000000000000000000000000000000000068": "0x00000000000000a40d5f56745a118d0906a34e69aec8c0db1cb8fa0000000100", + "0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103": "0x0000000000000000000000000f99738b2fc14d77308337f3e2596b63ae7bcc4a", + "0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc": "0x0000000000000000000000005ac4182a1dd41aeef465e40b82fd326bf66ab82c" + } + }, + { + "contractName": "PolygonZkEVMGlobalExitRootL2 implementation", + "balance": "0", + "nonce": "1", + "address": "0x0200143Fa295EE4dffEF22eE2616c2E008D81688", + "bytecode": "0x608060405234801561001057600080fd5b506004361061004c5760003560e01c806301fd904414610051578063257b36321461006d57806333d6247d1461008d578063a3c573eb146100a2575b600080fd5b61005a60015481565b6040519081526020015b60405180910390f35b61005a61007b366004610162565b60006020819052908152604090205481565b6100a061009b366004610162565b6100ee565b005b6100c97f0000000000000000000000002a3dd3eb832af982ec71669e178424b10dca2ede81565b60405173ffffffffffffffffffffffffffffffffffffffff9091168152602001610064565b3373ffffffffffffffffffffffffffffffffffffffff7f0000000000000000000000002a3dd3eb832af982ec71669e178424b10dca2ede161461015d576040517fb49365dd00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600155565b60006020828403121561017457600080fd5b503591905056fea2646970667358221220a187fc278346c1b61c449ea3641002b6eac2bda3351a122a12c35099f933696864736f6c63430008110033" + }, + { + "contractName": "PolygonZkEVMGlobalExitRootL2 proxy", + "balance": "0", + "nonce": "1", + "address": "0xa40d5f56745a118d0906a34e69aec8c0db1cb8fa", + "bytecode": "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", + "storage": { + "0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103": "0x0000000000000000000000000f99738b2fc14d77308337f3e2596b63ae7bcc4a", + "0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc": "0x0000000000000000000000000200143fa295ee4dffef22ee2616c2e008d81688" + } + }, + { + "contractName": "PolygonZkEVMTimelock", + "balance": "0", + "nonce": "1", + "address": "0xBBa0935Fa93Eb23de7990b47F0D96a8f75766d13", + "bytecode": "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", + "storage": { + "0x0000000000000000000000000000000000000000000000000000000000000002": "0x00000000000000000000000000000000000000000000000000000000000d2f00", + "0x33d4aa03df3f12c4f615b40676f67fdafecd3edb5a9c0ca2a47a923dae33a023": "0x0000000000000000000000000000000000000000000000000000000000000001", + "0x9fa2d8034dbcb437bee38d61fbd100910e1342ffc07f128aa1b8e6790b7f3f68": "0x0000000000000000000000000000000000000000000000000000000000000001", + "0x64494413541ff93b31aa309254e3fed72a7456e9845988b915b4c7a7ceba8814": "0x5f58e3a2316349923ce3780f8d587db2d72378aed66a8261c916544fa6846ca5", + "0x531a7c25761aa4b0f2310edca9bb25e1e3ceb49ad4b0422aec866b3ce7567c87": "0x0000000000000000000000000000000000000000000000000000000000000001", + "0x3412d5605ac6cd444957cedb533e5dacad6378b4bc819ebe3652188a665066d6": "0x5f58e3a2316349923ce3780f8d587db2d72378aed66a8261c916544fa6846ca5", + "0xedbedc78c4240c7613622a35de050b48bd6c6d9a31b3d485b68fbbed54a4802d": "0x0000000000000000000000000000000000000000000000000000000000000001", + "0xdae2aa361dfd1ca020a396615627d436107c35eff9fe7738a3512819782d706a": "0x5f58e3a2316349923ce3780f8d587db2d72378aed66a8261c916544fa6846ca5", + "0x76616448da8d124a07383c26a6b2433b3259de946aa40f51524ec96ee05e871a": "0x0000000000000000000000000000000000000000000000000000000000000001", + "0xc3ad33e20b0c56a223ad5104fff154aa010f8715b9c981fd38fdc60a4d1a52fc": "0x5f58e3a2316349923ce3780f8d587db2d72378aed66a8261c916544fa6846ca5" + } + }, + { + "accountName": "keyless Deployer", + "balance": "0", + "nonce": "1", + "address": "0x9d90066e7478496e2284E54c3548106bb4F90E50" + }, + { + "accountName": "deployer", + "balance": "0", + "nonce": "8", + "address": "0x4c1665d6651ecEfa59B9B3041951608468b18891" + } + ] + } +` diff --git a/config/network.go b/config/network.go new file mode 100644 index 0000000..a1f31c3 --- /dev/null +++ b/config/network.go @@ -0,0 +1,177 @@ +package config + +import ( + "encoding/json" + "errors" + "fmt" + "io" + "os" + + "github.com/0xPolygonHermez/zkevm-ethtx-manager/etherman" + "github.com/0xPolygonHermez/zkevm-ethtx-manager/log" + "github.com/ethereum/go-ethereum/common" + "github.com/urfave/cli/v2" +) + +type leafType uint8 +type network string + +const ( + mainnet network = "mainnet" + testnet network = "testnet" + custom network = "custom" + // LeafTypeBalance specifies that leaf stores Balance + LeafTypeBalance leafType = 0 + // LeafTypeNonce specifies that leaf stores Nonce + LeafTypeNonce leafType = 1 + // LeafTypeCode specifies that leaf stores Code + LeafTypeCode leafType = 2 + // LeafTypeStorage specifies that leaf stores Storage Value + LeafTypeStorage leafType = 3 + // LeafTypeSCLength specifies that leaf stores Storage Value + LeafTypeSCLength leafType = 4 +) + +// NetworkConfig is the configuration struct for the different environments +type NetworkConfig struct { + // L1: Configuration related to L1 + L1Config etherman.L1Config `json:"l1Config"` + // L1: Genesis of the rollup, first block number and root + Genesis Genesis +} + +// GenesisFromJSON is the config file for network_custom +type GenesisFromJSON struct { + // L1: root hash of the genesis block + Root string `json:"root"` + // L1: block number of the genesis block + GenesisBlockNum uint64 `json:"genesisBlockNumber"` + // L2: List of states contracts used to populate merkle tree at initial state + Genesis []genesisAccountFromJSON `json:"genesis"` + // L1: configuration of the network + L1Config etherman.L1Config +} + +type genesisAccountFromJSON struct { + // Address of the account + Balance string `json:"balance"` + // Nonce of the account + Nonce string `json:"nonce"` + // Address of the contract + Address string `json:"address"` + // Byte code of the contract + Bytecode string `json:"bytecode"` + // Initial storage of the contract + Storage map[string]string `json:"storage"` + // Name of the contract in L1 (e.g. "PolygonZkEVMDeployer", "PolygonZkEVMBridge",...) + ContractName string `json:"contractName"` +} + +func (cfg *Config) loadNetworkConfig(ctx *cli.Context) { + var networkJSON string + switch ctx.String(FlagNetwork) { + case string(mainnet): + networkJSON = MainnetNetworkConfigJSON + case string(testnet): + networkJSON = TestnetNetworkConfigJSON + case string(custom): + var err error + cfgPath := ctx.String(FlagCustomNetwork) + networkJSON, err = LoadGenesisFileAsString(cfgPath) + if err != nil { + panic(err.Error()) + } + default: + log.Fatalf("unsupported --network value. Must be one of: [%s, %s, %s]", mainnet, testnet, custom) + } + config, err := LoadGenesisFromJSONString(networkJSON) + if err != nil { + panic(fmt.Errorf("failed to load genesis configuration from file. Error: %v", err)) + } + cfg.NetworkConfig = config +} + +// LoadGenesisFileAsString loads the genesis file as a string +func LoadGenesisFileAsString(cfgPath string) (string, error) { + if cfgPath != "" { + f, err := os.Open(cfgPath) //nolint:gosec + if err != nil { + return "", err + } + defer func() { + err := f.Close() + if err != nil { + log.Error(err) + } + }() + + b, err := io.ReadAll(f) + if err != nil { + return "", err + } + return string(b), nil + } else { + return "", errors.New("custom network file not provided. Please use the custom-network-file flag") + } +} + +// LoadGenesisFromJSONString loads the genesis file from JSON string +func LoadGenesisFromJSONString(jsonStr string) (NetworkConfig, error) { + var cfg NetworkConfig + + var cfgJSON GenesisFromJSON + if err := json.Unmarshal([]byte(jsonStr), &cfgJSON); err != nil { + return NetworkConfig{}, err + } + + if len(cfgJSON.Genesis) == 0 { + return cfg, nil + } + + cfg.L1Config = cfgJSON.L1Config + cfg.Genesis = Genesis{ + BlockNumber: cfgJSON.GenesisBlockNum, + Root: common.HexToHash(cfgJSON.Root), + Actions: []*GenesisAction{}, + } + + for _, account := range cfgJSON.Genesis { + if account.Balance != "" && account.Balance != "0" { + action := &GenesisAction{ + Address: account.Address, + Type: int(LeafTypeBalance), + Value: account.Balance, + } + cfg.Genesis.Actions = append(cfg.Genesis.Actions, action) + } + if account.Nonce != "" && account.Nonce != "0" { + action := &GenesisAction{ + Address: account.Address, + Type: int(LeafTypeNonce), + Value: account.Nonce, + } + cfg.Genesis.Actions = append(cfg.Genesis.Actions, action) + } + if account.Bytecode != "" { + action := &GenesisAction{ + Address: account.Address, + Type: int(LeafTypeCode), + Bytecode: account.Bytecode, + } + cfg.Genesis.Actions = append(cfg.Genesis.Actions, action) + } + if len(account.Storage) > 0 { + for storageKey, storageValue := range account.Storage { + action := &GenesisAction{ + Address: account.Address, + Type: int(LeafTypeStorage), + StoragePosition: storageKey, + Value: storageValue, + } + cfg.Genesis.Actions = append(cfg.Genesis.Actions, action) + } + } + } + + return cfg, nil +} diff --git a/config/testnetgenesis.go b/config/testnetgenesis.go new file mode 100644 index 0000000..75041ad --- /dev/null +++ b/config/testnetgenesis.go @@ -0,0 +1,108 @@ +package config + +// TestnetNetworkConfigJSON is the hardcoded network configuration to be used for the official mainnet setup +const TestnetNetworkConfigJSON = ` +{ + "l1Config" : { + "chainId": 5, + "polygonZkEVMAddress": "0xa997cfD539E703921fD1e3Cf25b4c241a27a4c7A", + "polTokenAddress": "0x1319D23c2F7034F52Eb07399702B040bA278Ca49", + "polygonZkEVMGlobalExitRootAddress": "0x4d9427DCA0406358445bC0a8F88C26b704004f74" + }, + "root": "0x13a14c4a8288e782863d7ce916d224546c69dc428fbfa7115a0cc33a27a05b26", + "genesisBlockNumber": 8572998, + "genesis": [ + { + "contractName": "PolygonZkEVMDeployer", + "balance": "0", + "nonce": "4", + "address": "0x39877a0c3cd148476DaA2475c77c478C62eC7509", + "bytecode": "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", + "storage": { + "0x0000000000000000000000000000000000000000000000000000000000000000": "0x000000000000000000000000a0b02b28920812324f1cc3255bd8840867d3f227" + } + }, + { + "contractName": "ProxyAdmin", + "balance": "0", + "nonce": "1", + "address": "0x40797c2f93298a44a893F43EdF1B33B63d7BA333", + "bytecode": "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", + "storage": { + "0x0000000000000000000000000000000000000000000000000000000000000000": "0x00000000000000000000000002245d7b6cb0b6870d1e28ac877ee355b9588869" + } + }, + { + "contractName": "PolygonZkEVMBridge implementation", + "balance": "0", + "nonce": "1", + "address": "0x39e780D8800f7396e8B7530A8925B14025AedC77", + "bytecode": "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" + }, + { + "contractName": "PolygonZkEVMBridge proxy", + "balance": "200000000000000000000000000", + "nonce": "1", + "address": "0xF6BEEeBB578e214CA9E23B0e9683454Ff88Ed2A7", + "bytecode": "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", + "storage": { + "0x0000000000000000000000000000000000000000000000000000000000000000": "0x0000000000000000000000000000000000000000000000000000000000000001", + "0x0000000000000000000000000000000000000000000000000000000000000001": "0x0000000000000000000000000000000000000000000000000000000000000001", + "0x0000000000000000000000000000000000000000000000000000000000000068": "0x00000000000000a40d5f56745a118d0906a34e69aec8c0db1cb8fa0000000100", + "0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103": "0x00000000000000000000000040797c2f93298a44a893f43edf1b33b63d7ba333", + "0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc": "0x00000000000000000000000039e780d8800f7396e8b7530a8925b14025aedc77" + } + }, + { + "contractName": "PolygonZkEVMGlobalExitRootL2 implementation", + "balance": "0", + "nonce": "1", + "address": "0x77Fc57b154fCF8320Df2C2e6C044AA50141c023b", + "bytecode": "0x608060405234801561001057600080fd5b506004361061004c5760003560e01c806301fd904414610051578063257b36321461006d57806333d6247d1461008d578063a3c573eb146100a2575b600080fd5b61005a60015481565b6040519081526020015b60405180910390f35b61005a61007b366004610162565b60006020819052908152604090205481565b6100a061009b366004610162565b6100ee565b005b6100c97f000000000000000000000000f6beeebb578e214ca9e23b0e9683454ff88ed2a781565b60405173ffffffffffffffffffffffffffffffffffffffff9091168152602001610064565b3373ffffffffffffffffffffffffffffffffffffffff7f000000000000000000000000f6beeebb578e214ca9e23b0e9683454ff88ed2a7161461015d576040517fb49365dd00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600155565b60006020828403121561017457600080fd5b503591905056fea2646970667358221220a187fc278346c1b61c449ea3641002b6eac2bda3351a122a12c35099f933696864736f6c63430008110033" + }, + { + "contractName": "PolygonZkEVMGlobalExitRootL2 proxy", + "balance": "0", + "nonce": "1", + "address": "0xa40d5f56745a118d0906a34e69aec8c0db1cb8fa", + "bytecode": "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", + "storage": { + "0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103": "0x00000000000000000000000040797c2f93298a44a893f43edf1b33b63d7ba333", + "0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc": "0x00000000000000000000000077fc57b154fcf8320df2c2e6c044aa50141c023b" + } + }, + { + "contractName": "PolygonZkEVMTimelock", + "balance": "0", + "nonce": "1", + "address": "0x02245d7B6CB0b6870d1e28AC877EE355b9588869", + "bytecode": "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", + "storage": { + "0x0000000000000000000000000000000000000000000000000000000000000002": "0x0000000000000000000000000000000000000000000000000000000000015180", + "0xbdd73c6ebfb442c137537be0985acf11af8e6133078bc51ef9094071cb0ca475": "0x0000000000000000000000000000000000000000000000000000000000000001", + "0x92b79801e6a3d148a516c908cc0bbad93771fa74468b7757a14aa55532d092de": "0x0000000000000000000000000000000000000000000000000000000000000001", + "0x64494413541ff93b31aa309254e3fed72a7456e9845988b915b4c7a7ceba8814": "0x5f58e3a2316349923ce3780f8d587db2d72378aed66a8261c916544fa6846ca5", + "0x43e090632490f7d46c400129311fff008a7688bb3d4aebdf80607456b452cf04": "0x0000000000000000000000000000000000000000000000000000000000000001", + "0x3412d5605ac6cd444957cedb533e5dacad6378b4bc819ebe3652188a665066d6": "0x5f58e3a2316349923ce3780f8d587db2d72378aed66a8261c916544fa6846ca5", + "0x5af21cf0316499c6925cf9be0331b8bd150a1fa4c19d24a043b45f0cf15357c3": "0x0000000000000000000000000000000000000000000000000000000000000001", + "0xdae2aa361dfd1ca020a396615627d436107c35eff9fe7738a3512819782d706a": "0x5f58e3a2316349923ce3780f8d587db2d72378aed66a8261c916544fa6846ca5", + "0xaf021eeb38644155cd697b3ce0ec4fdac818d29c448a9f9d9bafc293723c6cd8": "0x0000000000000000000000000000000000000000000000000000000000000001", + "0xc3ad33e20b0c56a223ad5104fff154aa010f8715b9c981fd38fdc60a4d1a52fc": "0x5f58e3a2316349923ce3780f8d587db2d72378aed66a8261c916544fa6846ca5" + } + }, + { + "accountName": "keyless Deployer", + "balance": "0", + "nonce": "1", + "address": "0xB83a574B3966F7dc1d38d162FA154F2A57D608Bb" + }, + { + "accountName": "deployer", + "balance": "0", + "nonce": "8", + "address": "0xA0B02B28920812324f1cC3255bd8840867d3f227" + } + ] + } + +` diff --git a/config/types/duration.go b/config/types/duration.go new file mode 100644 index 0000000..7612291 --- /dev/null +++ b/config/types/duration.go @@ -0,0 +1,40 @@ +package types + +import ( + "time" + + "github.com/invopop/jsonschema" +) + +// Duration is a wrapper type that parses time duration from text. +type Duration struct { + time.Duration `validate:"required"` +} + +// UnmarshalText unmarshalls time duration from text. +func (d *Duration) UnmarshalText(data []byte) error { + duration, err := time.ParseDuration(string(data)) + if err != nil { + return err + } + d.Duration = duration + return nil +} + +// NewDuration returns Duration wrapper +func NewDuration(duration time.Duration) Duration { + return Duration{duration} +} + +// JSONSchema returns a custom schema to be used for the JSON Schema generation of this type +func (Duration) JSONSchema() *jsonschema.Schema { + return &jsonschema.Schema{ + Type: "string", + Title: "Duration", + Description: "Duration expressed in units: [ns, us, ms, s, m, h, d]", + Examples: []interface{}{ + "1m", + "300ms", + }, + } +} diff --git a/config/types/duration_test.go b/config/types/duration_test.go new file mode 100644 index 0000000..71e06a0 --- /dev/null +++ b/config/types/duration_test.go @@ -0,0 +1,54 @@ +package types + +import ( + "encoding/json" + "fmt" + "testing" + "time" + + "github.com/stretchr/testify/require" +) + +func TestDurationUnmarshal(t *testing.T) { + type testCase struct { + name string + input string + expectedResult *Duration + expectedErr error + } + + testCases := []testCase{ + { + name: "valid duration", + input: "60s", + expectedResult: &Duration{Duration: time.Minute}, + }, + { + name: "int value", + input: "60", + expectedErr: fmt.Errorf("time: missing unit in duration \"60\""), + }, + { + name: "no duration value", + input: "abc", + expectedErr: fmt.Errorf("time: invalid duration \"abc\""), + }, + } + + for _, testCase := range testCases { + t.Run(testCase.name, func(t *testing.T) { + var d Duration + input, err := json.Marshal(testCase.input) + require.NoError(t, err) + err = json.Unmarshal(input, &d) + + if testCase.expectedResult != nil { + require.Equal(t, (*testCase.expectedResult).Nanoseconds(), d.Nanoseconds()) + } + + if err != nil { + require.Equal(t, testCase.expectedErr.Error(), err.Error()) + } + }) + } +} diff --git a/config/types/keystore.go b/config/types/keystore.go new file mode 100644 index 0000000..620834e --- /dev/null +++ b/config/types/keystore.go @@ -0,0 +1,10 @@ +package types + +// KeystoreFileConfig has all the information needed to load a private key from a key store file +type KeystoreFileConfig struct { + // Path is the file path for the key store file + Path string `mapstructure:"Path"` + + // Password is the password to decrypt the key store file + Password string `mapstructure:"Password"` +} diff --git a/db/config.go b/db/config.go new file mode 100644 index 0000000..ad56155 --- /dev/null +++ b/db/config.go @@ -0,0 +1,25 @@ +package db + +// Config provide fields to configure the pool +type Config struct { + // Database name + Name string `mapstructure:"Name"` + + // Database User name + User string `mapstructure:"User"` + + // Database Password of the user + Password string `mapstructure:"Password"` + + // Host address of database + Host string `mapstructure:"Host"` + + // Port Number of database + Port string `mapstructure:"Port"` + + // EnableLog + EnableLog bool `mapstructure:"EnableLog"` + + // MaxConns is the maximum number of connections in the pool. + MaxConns int `mapstructure:"MaxConns"` +} diff --git a/db/db.go b/db/db.go new file mode 100644 index 0000000..7a2350e --- /dev/null +++ b/db/db.go @@ -0,0 +1,123 @@ +package db + +import ( + "context" + "fmt" + + "github.com/0xPolygonHermez/zkevm-ethtx-manager/log" + "github.com/gobuffalo/packr/v2" + "github.com/jackc/pgx/v4" + "github.com/jackc/pgx/v4/pgxpool" + "github.com/jackc/pgx/v4/stdlib" + migrate "github.com/rubenv/sql-migrate" +) + +const ( + // EthTxManagerMigrationName is the name of the migration used by packr to pack the migration file + EthTxManagerMigrationName = "zkevm-state-db" +) + +var packrMigrations = map[string]*packr.Box{ + EthTxManagerMigrationName: packr.New(EthTxManagerMigrationName, "./migrations"), +} + +// NewSQLDB creates a new SQL DB +func NewSQLDB(cfg Config) (*pgxpool.Pool, error) { + config, err := pgxpool.ParseConfig(fmt.Sprintf("postgres://%s:%s@%s:%s/%s?pool_max_conns=%d", cfg.User, cfg.Password, cfg.Host, cfg.Port, cfg.Name, cfg.MaxConns)) + if err != nil { + log.Errorf("Unable to parse DB config: %v\n", err) + return nil, err + } + if cfg.EnableLog { + config.ConnConfig.Logger = logger{} + } + conn, err := pgxpool.ConnectConfig(context.Background(), config) + if err != nil { + log.Errorf("Unable to connect to database: %v\n", err) + return nil, err + } + return conn, nil +} + +// RunMigrationsUp runs migrate-up for the given config. +func RunMigrationsUp(cfg Config, name string) error { + log.Info("running migrations up") + return runMigrations(cfg, name, migrate.Up) +} + +// CheckMigrations runs migrate-up for the given config. +func CheckMigrations(cfg Config, name string) error { + return checkMigrations(cfg, name, migrate.Up) +} + +// RunMigrationsDown runs migrate-down for the given config. +func RunMigrationsDown(cfg Config, name string) error { + log.Info("running migrations down") + return runMigrations(cfg, name, migrate.Down) +} + +// runMigrations will execute pending migrations if needed to keep +// the database updated with the latest changes in either direction, +// up or down. +func runMigrations(cfg Config, packrName string, direction migrate.MigrationDirection) error { + c, err := pgx.ParseConfig(fmt.Sprintf("postgres://%s:%s@%s:%s/%s", cfg.User, cfg.Password, cfg.Host, cfg.Port, cfg.Name)) + if err != nil { + return err + } + db := stdlib.OpenDB(*c) + + box, ok := packrMigrations[packrName] + if !ok { + return fmt.Errorf("packr box not found with name: %v", packrName) + } + + var migrations = &migrate.PackrMigrationSource{Box: box} + nMigrations, err := migrate.Exec(db, "postgres", migrations, direction) + if err != nil { + return err + } + + log.Info("successfully ran ", nMigrations, " migrations") + return nil +} + +func checkMigrations(cfg Config, packrName string, direction migrate.MigrationDirection) error { + c, err := pgx.ParseConfig(fmt.Sprintf("postgres://%s:%s@%s:%s/%s", cfg.User, cfg.Password, cfg.Host, cfg.Port, cfg.Name)) + if err != nil { + return err + } + db := stdlib.OpenDB(*c) + + box, ok := packrMigrations[packrName] + if !ok { + return fmt.Errorf("packr box not found with name: %v", packrName) + } + + migrationSource := &migrate.PackrMigrationSource{Box: box} + migrations, err := migrationSource.FindMigrations() + if err != nil { + log.Errorf("error getting migrations from source: %v", err) + return err + } + + var expected int + for _, migration := range migrations { + if len(migration.Up) != 0 { + expected++ + } + } + + var actual int + query := `SELECT COUNT(1) FROM public.gorp_migrations` + err = db.QueryRow(query).Scan(&actual) + if err != nil { + log.Error("error getting migrations count: ", err) + return err + } + if expected == actual { + log.Infof("Found %d migrations as expected", actual) + } else { + return fmt.Errorf("error the component needs to run %d migrations before starting. DB only contains %d migrations", expected, actual) + } + return nil +} diff --git a/db/logger.go b/db/logger.go new file mode 100644 index 0000000..316040c --- /dev/null +++ b/db/logger.go @@ -0,0 +1,27 @@ +package db + +import ( + "context" + "fmt" + + "github.com/0xPolygonHermez/zkevm-ethtx-manager/log" + "github.com/jackc/pgx/v4" +) + +type logger struct{} + +func (l logger) Log(ctx context.Context, level pgx.LogLevel, msg string, data map[string]interface{}) { + m := fmt.Sprintf("%s %v", msg, data) + + switch level { + case pgx.LogLevelInfo: + log.Info(m) + case pgx.LogLevelWarn: + log.Warn(m) + case pgx.LogLevelError: + log.Error(m) + default: + m = fmt.Sprintf("%s %s %v", level.String(), msg, data) + log.Debug(m) + } +} diff --git a/db/migrations/0001.sql b/db/migrations/0001.sql new file mode 100644 index 0000000..2456567 --- /dev/null +++ b/db/migrations/0001.sql @@ -0,0 +1,25 @@ +-- +migrate Down +DROP SCHEMA IF EXISTS ethtxmgr CASCADE; + +-- +migrate Up +CREATE SCHEMA ethtxmgr; + +CREATE TABLE ethtxmgr.monitored_txs +( + owner VARCHAR NOT NULL, + id VARCHAR NOT NULL, + from_addr VARCHAR NOT NULL, + to_addr VARCHAR, + nonce DECIMAL(78, 0) NOT NULL, + value DECIMAL(78, 0), + data VARCHAR, + gas DECIMAL(78, 0) NOT NULL, + gas_price DECIMAL(78, 0) NOT NULL, + status VARCHAR NOT NULL, + history VARCHAR[], + block_num BIGINT, + gas_offset DECIMAL(78, 0) NOT NULL DEFAULT 0, + created_at TIMESTAMP WITH TIME ZONE NOT NULL, + updated_at TIMESTAMP WITH TIME ZONE NOT NULL, + PRIMARY KEY (owner, id) +); diff --git a/docker-compose.yml b/docker-compose.yml new file mode 100644 index 0000000..2856325 --- /dev/null +++ b/docker-compose.yml @@ -0,0 +1,52 @@ +version: "3.5" +networks: + default: + name: zkevm +services: + zkevm-ethtx-manager-db: + container_name: zkevm-ethtx-manager-db + restart: unless-stopped + image: postgres:15 + healthcheck: + test: ["CMD-SHELL", "pg_isready -d $${POSTGRES_DB} -U $${POSTGRES_USER}"] + interval: 10s + timeout: 5s + retries: 5 + ports: + - 5432:5432 + volumes: + - ${ZKEVM_ETHTXMANAGER_DATA_DIR}:/var/lib/postgresql/data + - ${ZKEVM_ADVANCED_CONFIG_DIR:-./config/environments/${ZKEVM_NETWORK}}/postgresql.conf:/etc/postgresql.conf + environment: + - POSTGRES_USER=ethtxmanager_user + - POSTGRES_PASSWORD=ethtxmanager_password + - POSTGRES_DB=ethtxmanager_db + command: + - "postgres" + - "-N" + - "500" + - "-c" + - "config_file=/etc/postgresql.conf" + zkevm-ethtx-manager: + container_name: zkevm-ethtx-manager + restart: unless-stopped + depends_on: + zkevm-ethtx-manager-db: + condition: service_healthy + image: zkevm-ethtx-manager + ports: + - 9092:9091 # needed if metrics enabled + deploy: + resources: + limits: + memory: 1G + reservations: + memory: 512M + environment: + - ZKEVM_ETHERMAN_URL=${ZKEVM_ETHERMAN_URL} + volumes: + - ${ZKEVM_ADVANCED_CONFIG_DIR:-./config/environments/${ZKEVM_NETWORK}}/ethtxmanager.config.toml:/app/config.toml + command: + - "/bin/sh" + - "-c" + - "/app/zkevm-ethtx-manager run --network ${ZKEVM_NETWORK} --cfg /app/config.toml --components ethtx-manager" diff --git a/encoding/encoding.go b/encoding/encoding.go new file mode 100644 index 0000000..bdd30f4 --- /dev/null +++ b/encoding/encoding.go @@ -0,0 +1,110 @@ +package encoding + +import ( + "fmt" + "math/big" + "strconv" + "strings" + + "github.com/0xPolygonHermez/zkevm-ethtx-manager/hex" + "github.com/ethereum/go-ethereum/common" +) + +const ( + // Base10 decimal base + Base10 = 10 + // TenToThePowerOf18 represents 1000000000000000000 + TenToThePowerOf18 = 1000000000000000000 + // Gwei represents 1000000000 wei + Gwei = 1000000000 + // MaxUint256StrNumber represents 2**256 -1 as string + MaxUint256StrNumber = "115792089237316195423570985008687907853269984665640564039457584007913129639935" +) + +// DecodeUint64orHex decodes a string uint64 or hex string into a uint64 +func DecodeUint64orHex(val *string) (uint64, error) { + if val == nil { + return 0, nil + } + + str := *val + base := 10 + if strings.HasPrefix(str, "0x") { + str = str[2:] + base = 16 + } + return strconv.ParseUint(str, base, hex.BitSize64) +} + +// DecodeUint256orHex decodes a string uint256 or hex string into a bit.Int +func DecodeUint256orHex(val *string) (*big.Int, error) { + if val == nil { + return nil, nil + } + + str := *val + base := 10 + if strings.HasPrefix(str, "0x") { + str = str[2:] + base = 16 + } + b, ok := new(big.Int).SetString(str, base) + if !ok { + return nil, fmt.Errorf("could not parse") + } + return b, nil +} + +// DecodeInt64orHex decodes a string int64 or hex string into a int64 +func DecodeInt64orHex(val *string) (int64, error) { + i, err := DecodeUint64orHex(val) + return int64(i), err +} + +// DecodeBytes decodes a hex string into a []byte +func DecodeBytes(val *string) ([]byte, error) { + if val == nil { + return []byte{}, nil + } + + str := strings.TrimPrefix(*val, "0x") + + return hex.DecodeString(str) +} + +// EncodeUint64 encodes a uint64 into a hex string +func EncodeUint64(b uint64) *string { + res := fmt.Sprintf("0x%x", b) + return &res +} + +// EncodeBytes encodes a []bytes into a hex string +func EncodeBytes(b []byte) *string { + res := "0x" + hex.EncodeToString(b) + return &res +} + +// EncodeBigInt encodes a big.Int into a hex string +func EncodeBigInt(b *big.Int) *string { + res := "0x" + b.Text(hex.Base) + return &res +} + +// DecodeBigIntHexOrDecimal parses a string that can be decimal or hexa (starts with 0x) +// into a *big.Int +func DecodeBigIntHexOrDecimal(s string) (*big.Int, error) { + var r *big.Int + if strings.HasPrefix(s, "0x") { // nolint + // Value in hex format + s = s[2:] + r = new(big.Int).SetBytes(common.Hex2Bytes(s)) + } else { + // Value in decimal format + value, ok := new(big.Int).SetString(s, Base10) + if !ok { + return nil, fmt.Errorf("Could not set base10 %q to big.Int", s) + } + r = value + } + return r, nil +} diff --git a/etherman/config.go b/etherman/config.go new file mode 100644 index 0000000..367c030 --- /dev/null +++ b/etherman/config.go @@ -0,0 +1,17 @@ +package etherman + +import "github.com/0xPolygonHermez/zkevm-ethtx-manager/etherman/etherscan" + +// Config represents the configuration of the etherman +type Config struct { + // URL is the URL of the Ethereum node for L1 + URL string `mapstructure:"URL"` + + // ForkIDChunkSize is the max interval for each call to L1 provider to get the forkIDs + ForkIDChunkSize uint64 `mapstructure:"ForkIDChunkSize"` + + // allow that L1 gas price calculation use multiples sources + MultiGasProvider bool `mapstructure:"MultiGasProvider"` + // Configuration for use Etherscan as used as gas provider, basically it needs the API-KEY + Etherscan etherscan.Config +} diff --git a/etherman/errors.go b/etherman/errors.go new file mode 100644 index 0000000..d98bce5 --- /dev/null +++ b/etherman/errors.go @@ -0,0 +1,48 @@ +package etherman + +import ( + "errors" + "strings" +) + +var ( + // ErrGasRequiredExceedsAllowance gas required exceeds the allowance + ErrGasRequiredExceedsAllowance = errors.New("gas required exceeds allowance") + // ErrContentLengthTooLarge content length is too large + ErrContentLengthTooLarge = errors.New("content length too large") + //ErrTimestampMustBeInsideRange Timestamp must be inside range + ErrTimestampMustBeInsideRange = errors.New("timestamp must be inside range") + //ErrInsufficientAllowance insufficient allowance + ErrInsufficientAllowance = errors.New("insufficient allowance") + // ErrBothGasPriceAndMaxFeeGasAreSpecified both gasPrice and (maxFeePerGas or maxPriorityFeePerGas) specified + ErrBothGasPriceAndMaxFeeGasAreSpecified = errors.New("both gasPrice and (maxFeePerGas or maxPriorityFeePerGas) specified") + // ErrMaxFeeGasAreSpecifiedButLondonNotActive maxFeePerGas or maxPriorityFeePerGas specified but london is not active yet + ErrMaxFeeGasAreSpecifiedButLondonNotActive = errors.New("maxFeePerGas or maxPriorityFeePerGas specified but london is not active yet") + // ErrNoSigner no signer to authorize the transaction with + ErrNoSigner = errors.New("no signer to authorize the transaction with") + // ErrMissingTrieNode means that a node is missing on the trie + ErrMissingTrieNode = errors.New("missing trie node") + + errorsCache = map[string]error{ + ErrGasRequiredExceedsAllowance.Error(): ErrGasRequiredExceedsAllowance, + ErrContentLengthTooLarge.Error(): ErrContentLengthTooLarge, + ErrTimestampMustBeInsideRange.Error(): ErrTimestampMustBeInsideRange, + ErrInsufficientAllowance.Error(): ErrInsufficientAllowance, + ErrBothGasPriceAndMaxFeeGasAreSpecified.Error(): ErrBothGasPriceAndMaxFeeGasAreSpecified, + ErrMaxFeeGasAreSpecifiedButLondonNotActive.Error(): ErrMaxFeeGasAreSpecifiedButLondonNotActive, + ErrNoSigner.Error(): ErrNoSigner, + ErrMissingTrieNode.Error(): ErrMissingTrieNode, + } +) + +func tryParseError(err error) (error, bool) { + parsedError, exists := errorsCache[err.Error()] + if !exists { + for errStr, actualErr := range errorsCache { + if strings.Contains(err.Error(), errStr) { + return actualErr, true + } + } + } + return parsedError, exists +} diff --git a/etherman/etherman.go b/etherman/etherman.go new file mode 100644 index 0000000..15d643b --- /dev/null +++ b/etherman/etherman.go @@ -0,0 +1,1754 @@ +package etherman + +import ( + "context" + "encoding/json" + "errors" + "fmt" + "math/big" + "os" + "path/filepath" + "strings" + "time" + + "github.com/0xPolygonHermez/zkevm-ethtx-manager/encoding" + "github.com/0xPolygonHermez/zkevm-ethtx-manager/etherman/etherscan" + "github.com/0xPolygonHermez/zkevm-ethtx-manager/etherman/ethgasstation" + "github.com/0xPolygonHermez/zkevm-ethtx-manager/etherman/metrics" + "github.com/0xPolygonHermez/zkevm-ethtx-manager/etherman/smartcontracts/oldpolygonzkevm" + "github.com/0xPolygonHermez/zkevm-ethtx-manager/etherman/smartcontracts/oldpolygonzkevmglobalexitroot" + "github.com/0xPolygonHermez/zkevm-ethtx-manager/etherman/smartcontracts/pol" + "github.com/0xPolygonHermez/zkevm-ethtx-manager/etherman/smartcontracts/polygonrollupmanager" + "github.com/0xPolygonHermez/zkevm-ethtx-manager/etherman/smartcontracts/polygonzkevm" + "github.com/0xPolygonHermez/zkevm-ethtx-manager/etherman/smartcontracts/polygonzkevmglobalexitroot" + ethmanTypes "github.com/0xPolygonHermez/zkevm-ethtx-manager/etherman/types" + "github.com/0xPolygonHermez/zkevm-ethtx-manager/log" + "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/accounts/keystore" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/ethclient" + "github.com/ethereum/go-ethereum/rpc" + "golang.org/x/crypto/sha3" +) + +var ( + // Events RollupManager + setBatchFeeSignatureHash = crypto.Keccak256Hash([]byte("SetBatchFee(uint256)")) + setTrustedAggregatorSignatureHash = crypto.Keccak256Hash([]byte("SetTrustedAggregator(address)")) // Used in oldZkEvm as well + setVerifyBatchTimeTargetSignatureHash = crypto.Keccak256Hash([]byte("SetVerifyBatchTimeTarget(uint64)")) // Used in oldZkEvm as well + setMultiplierBatchFeeSignatureHash = crypto.Keccak256Hash([]byte("SetMultiplierBatchFee(uint16)")) // Used in oldZkEvm as well + setPendingStateTimeoutSignatureHash = crypto.Keccak256Hash([]byte("SetPendingStateTimeout(uint64)")) // Used in oldZkEvm as well + setTrustedAggregatorTimeoutSignatureHash = crypto.Keccak256Hash([]byte("SetTrustedAggregatorTimeout(uint64)")) // Used in oldZkEvm as well + overridePendingStateSignatureHash = crypto.Keccak256Hash([]byte("OverridePendingState(uint32,uint64,bytes32,bytes32,address)")) + proveNonDeterministicPendingStateSignatureHash = crypto.Keccak256Hash([]byte("ProveNonDeterministicPendingState(bytes32,bytes32)")) // Used in oldZkEvm as well + consolidatePendingStateSignatureHash = crypto.Keccak256Hash([]byte("ConsolidatePendingState(uint32,uint64,bytes32,bytes32,uint64)")) + verifyBatchesTrustedAggregatorSignatureHash = crypto.Keccak256Hash([]byte("VerifyBatchesTrustedAggregator(uint32,uint64,bytes32,bytes32,address)")) + rollupManagerVerifyBatchesSignatureHash = crypto.Keccak256Hash([]byte("VerifyBatches(uint32,uint64,bytes32,bytes32,address)")) + onSequenceBatchesSignatureHash = crypto.Keccak256Hash([]byte("OnSequenceBatches(uint32,uint64)")) + updateRollupSignatureHash = crypto.Keccak256Hash([]byte("UpdateRollup(uint32,uint32,uint64)")) + addExistingRollupSignatureHash = crypto.Keccak256Hash([]byte("AddExistingRollup(uint32,uint64,address,uint64,uint8,uint64)")) + createNewRollupSignatureHash = crypto.Keccak256Hash([]byte("CreateNewRollup(uint32,uint32,address,uint64,address)")) + obsoleteRollupTypeSignatureHash = crypto.Keccak256Hash([]byte("ObsoleteRollupType(uint32)")) + addNewRollupTypeSignatureHash = crypto.Keccak256Hash([]byte("AddNewRollupType(uint32,address,address,uint64,uint8,bytes32,string)")) + + // Events new ZkEvm/RollupBase + acceptAdminRoleSignatureHash = crypto.Keccak256Hash([]byte("AcceptAdminRole(address)")) // Used in oldZkEvm as well + transferAdminRoleSignatureHash = crypto.Keccak256Hash([]byte("TransferAdminRole(address)")) // Used in oldZkEvm as well + activateForceBatchesSignatureHash = crypto.Keccak256Hash([]byte("ActivateForceBatches()")) // Used in oldZkEvm as well + setForceBatchTimeoutSignatureHash = crypto.Keccak256Hash([]byte("SetForceBatchTimeout(uint64)")) // Used in oldZkEvm as well + setTrustedSequencerURLSignatureHash = crypto.Keccak256Hash([]byte("SetTrustedSequencerURL(string)")) // Used in oldZkEvm as well + setTrustedSequencerSignatureHash = crypto.Keccak256Hash([]byte("SetTrustedSequencer(address)")) // Used in oldZkEvm as well + verifyBatchesSignatureHash = crypto.Keccak256Hash([]byte("VerifyBatches(uint64,bytes32,address)")) // Used in oldZkEvm as well + sequenceForceBatchesSignatureHash = crypto.Keccak256Hash([]byte("SequenceForceBatches(uint64)")) // Used in oldZkEvm as well + forceBatchSignatureHash = crypto.Keccak256Hash([]byte("ForceBatch(uint64,bytes32,address,bytes)")) // Used in oldZkEvm as well + sequenceBatchesSignatureHash = crypto.Keccak256Hash([]byte("SequenceBatches(uint64,bytes32)")) // Used in oldZkEvm as well + initialSequenceBatchesSignatureHash = crypto.Keccak256Hash([]byte("InitialSequenceBatches(bytes,bytes32,address)")) + + // Extra RollupManager + initializedSignatureHash = crypto.Keccak256Hash([]byte("Initialized(uint64)")) // Initializable. Used in RollupBase as well + roleAdminChangedSignatureHash = crypto.Keccak256Hash([]byte("RoleAdminChanged(bytes32,bytes32,bytes32)")) // IAccessControlUpgradeable + roleGrantedSignatureHash = crypto.Keccak256Hash([]byte("RoleGranted(bytes32,address,address)")) // IAccessControlUpgradeable + roleRevokedSignatureHash = crypto.Keccak256Hash([]byte("RoleRevoked(bytes32,address,address)")) // IAccessControlUpgradeable + emergencyStateActivatedSignatureHash = crypto.Keccak256Hash([]byte("EmergencyStateActivated()")) // EmergencyManager. Used in oldZkEvm as well + emergencyStateDeactivatedSignatureHash = crypto.Keccak256Hash([]byte("EmergencyStateDeactivated()")) // EmergencyManager. Used in oldZkEvm as well + + // New GER event Etrog + updateL1InfoTreeSignatureHash = crypto.Keccak256Hash([]byte("UpdateL1InfoTree(bytes32,bytes32)")) + + // PreLxLy events + updateGlobalExitRootSignatureHash = crypto.Keccak256Hash([]byte("UpdateGlobalExitRoot(bytes32,bytes32)")) + oldVerifyBatchesTrustedAggregatorSignatureHash = crypto.Keccak256Hash([]byte("VerifyBatchesTrustedAggregator(uint64,bytes32,address)")) + transferOwnershipSignatureHash = crypto.Keccak256Hash([]byte("OwnershipTransferred(address,address)")) + updateZkEVMVersionSignatureHash = crypto.Keccak256Hash([]byte("UpdateZkEVMVersion(uint64,uint64,string)")) + oldConsolidatePendingStateSignatureHash = crypto.Keccak256Hash([]byte("ConsolidatePendingState(uint64,bytes32,uint64)")) + oldOverridePendingStateSignatureHash = crypto.Keccak256Hash([]byte("OverridePendingState(uint64,bytes32,address)")) + sequenceBatchesPreEtrogSignatureHash = crypto.Keccak256Hash([]byte("SequenceBatches(uint64)")) + + // Proxy events + initializedProxySignatureHash = crypto.Keccak256Hash([]byte("Initialized(uint8)")) + adminChangedSignatureHash = crypto.Keccak256Hash([]byte("AdminChanged(address,address)")) + beaconUpgradedSignatureHash = crypto.Keccak256Hash([]byte("BeaconUpgraded(address)")) + upgradedSignatureHash = crypto.Keccak256Hash([]byte("Upgraded(address)")) + + // ErrNotFound is used when the object is not found + ErrNotFound = errors.New("not found") + // ErrIsReadOnlyMode is used when the EtherMan client is in read-only mode. + ErrIsReadOnlyMode = errors.New("etherman client in read-only mode: no account configured to send transactions to L1. " + + "please check the [Etherman] PrivateKeyPath and PrivateKeyPassword configuration") + // ErrPrivateKeyNotFound used when the provided sender does not have a private key registered to be used + ErrPrivateKeyNotFound = errors.New("can't find sender private key to sign tx") +) + +// SequencedBatchesSigHash returns the hash for the `SequenceBatches` event. +func SequencedBatchesSigHash() common.Hash { return sequenceBatchesSignatureHash } + +// TrustedVerifyBatchesSigHash returns the hash for the `TrustedVerifyBatches` event. +func TrustedVerifyBatchesSigHash() common.Hash { return verifyBatchesTrustedAggregatorSignatureHash } + +// EventOrder is the the type used to identify the events order +type EventOrder string + +const ( + // GlobalExitRootsOrder identifies a GlobalExitRoot event + GlobalExitRootsOrder EventOrder = "GlobalExitRoots" + // L1InfoTreeOrder identifies a L1InTree event + L1InfoTreeOrder EventOrder = "L1InfoTreeOrder" + // SequenceBatchesOrder identifies a VerifyBatch event + SequenceBatchesOrder EventOrder = "SequenceBatches" + // ForcedBatchesOrder identifies a ForcedBatches event + ForcedBatchesOrder EventOrder = "ForcedBatches" + // TrustedVerifyBatchOrder identifies a TrustedVerifyBatch event + TrustedVerifyBatchOrder EventOrder = "TrustedVerifyBatch" + // VerifyBatchOrder identifies a VerifyBatch event + VerifyBatchOrder EventOrder = "VerifyBatch" + // SequenceForceBatchesOrder identifies a SequenceForceBatches event + SequenceForceBatchesOrder EventOrder = "SequenceForceBatches" + // ForkIDsOrder identifies an updateZkevmVersion event + ForkIDsOrder EventOrder = "forkIDs" +) + +type ethereumClient interface { + ethereum.ChainReader + ethereum.ChainStateReader + ethereum.ContractCaller + ethereum.GasEstimator + ethereum.GasPricer + ethereum.LogFilterer + ethereum.TransactionReader + ethereum.TransactionSender + + bind.DeployBackend +} + +// L1Config represents the configuration of the network used in L1 +type L1Config struct { + // Chain ID of the L1 network + L1ChainID uint64 `json:"chainId"` + // ZkEVMAddr Address of the L1 contract polygonZkEVMAddress + ZkEVMAddr common.Address `json:"polygonZkEVMAddress"` + // RollupManagerAddr Address of the L1 contract + RollupManagerAddr common.Address `json:"polygonRollupManagerAddress"` + // PolAddr Address of the L1 Pol token Contract + PolAddr common.Address `json:"polTokenAddress"` + // GlobalExitRootManagerAddr Address of the L1 GlobalExitRootManager contract + GlobalExitRootManagerAddr common.Address `json:"polygonZkEVMGlobalExitRootAddress"` +} + +type externalGasProviders struct { + MultiGasProvider bool + Providers []ethereum.GasPricer +} + +// Client is a simple implementation of EtherMan. +type Client struct { + EthClient ethereumClient + OldZkEVM *oldpolygonzkevm.Oldpolygonzkevm + ZkEVM *polygonzkevm.Polygonzkevm + RollupManager *polygonrollupmanager.Polygonrollupmanager + GlobalExitRootManager *polygonzkevmglobalexitroot.Polygonzkevmglobalexitroot + OldGlobalExitRootManager *oldpolygonzkevmglobalexitroot.Oldpolygonzkevmglobalexitroot + Pol *pol.Pol + SCAddresses []common.Address + + RollupID uint32 + + GasProviders externalGasProviders + + l1Cfg L1Config + cfg Config + auth map[common.Address]bind.TransactOpts // empty in case of read-only client +} + +// NewClient creates a new etherman. +func NewClient(cfg Config, l1Config L1Config) (*Client, error) { + // Connect to ethereum node + ethClient, err := ethclient.Dial(cfg.URL) + if err != nil { + log.Errorf("error connecting to %s: %+v", cfg.URL, err) + return nil, err + } + // Create smc clients + zkevm, err := polygonzkevm.NewPolygonzkevm(l1Config.ZkEVMAddr, ethClient) + if err != nil { + return nil, err + } + oldZkevm, err := oldpolygonzkevm.NewOldpolygonzkevm(l1Config.RollupManagerAddr, ethClient) + if err != nil { + return nil, err + } + rollupManager, err := polygonrollupmanager.NewPolygonrollupmanager(l1Config.RollupManagerAddr, ethClient) + if err != nil { + return nil, err + } + globalExitRoot, err := polygonzkevmglobalexitroot.NewPolygonzkevmglobalexitroot(l1Config.GlobalExitRootManagerAddr, ethClient) + if err != nil { + return nil, err + } + pol, err := pol.NewPol(l1Config.PolAddr, ethClient) + if err != nil { + return nil, err + } + var scAddresses []common.Address + scAddresses = append(scAddresses, l1Config.ZkEVMAddr, l1Config.RollupManagerAddr, l1Config.GlobalExitRootManagerAddr) + + gProviders := []ethereum.GasPricer{ethClient} + if cfg.MultiGasProvider { + if cfg.Etherscan.ApiKey == "" { + log.Info("No ApiKey provided for etherscan. Ignoring provider...") + } else { + log.Info("ApiKey detected for etherscan") + gProviders = append(gProviders, etherscan.NewEtherscanService(cfg.Etherscan.ApiKey)) + } + gProviders = append(gProviders, ethgasstation.NewEthGasStationService()) + } + metrics.Register() + // Get RollupID + rollupID, err := rollupManager.RollupAddressToID(&bind.CallOpts{Pending: false}, l1Config.ZkEVMAddr) + if err != nil { + return nil, err + } + log.Debug("rollupID: ", rollupID) + + return &Client{ + EthClient: ethClient, + ZkEVM: zkevm, + OldZkEVM: oldZkevm, + RollupManager: rollupManager, + Pol: pol, + GlobalExitRootManager: globalExitRoot, + SCAddresses: scAddresses, + RollupID: rollupID, + GasProviders: externalGasProviders{ + MultiGasProvider: cfg.MultiGasProvider, + Providers: gProviders, + }, + l1Cfg: l1Config, + cfg: cfg, + auth: map[common.Address]bind.TransactOpts{}, + }, nil +} + +// VerifyGenBlockNumber verifies if the genesis Block Number is valid +func (etherMan *Client) VerifyGenBlockNumber(ctx context.Context, genBlockNumber uint64) (bool, error) { + start := time.Now() + log.Info("Verifying genesis blockNumber: ", genBlockNumber) + // Filter query + genBlock := new(big.Int).SetUint64(genBlockNumber) + query := ethereum.FilterQuery{ + FromBlock: genBlock, + ToBlock: genBlock, + Addresses: etherMan.SCAddresses, + Topics: [][]common.Hash{{updateZkEVMVersionSignatureHash, createNewRollupSignatureHash}}, + } + logs, err := etherMan.EthClient.FilterLogs(ctx, query) + if err != nil { + return false, err + } + if len(logs) == 0 { + return false, fmt.Errorf("the specified genBlockNumber in config file does not contain any forkID event. Please use the proper blockNumber.") + } + var zkevmVersion oldpolygonzkevm.OldpolygonzkevmUpdateZkEVMVersion + switch logs[0].Topics[0] { + case updateZkEVMVersionSignatureHash: + log.Debug("UpdateZkEVMVersion event detected during the Verification of the GenBlockNumber") + zkevmV, err := etherMan.OldZkEVM.ParseUpdateZkEVMVersion(logs[0]) + if err != nil { + return false, err + } + if zkevmV != nil { + zkevmVersion = *zkevmV + } + case createNewRollupSignatureHash: + log.Debug("CreateNewRollup event detected during the Verification of the GenBlockNumber") + createNewRollupEvent, err := etherMan.RollupManager.ParseCreateNewRollup(logs[0]) + if err != nil { + return false, err + } + // Query to get the forkID + rollupType, err := etherMan.RollupManager.RollupTypeMap(&bind.CallOpts{Pending: false}, createNewRollupEvent.RollupTypeID) + if err != nil { + log.Error(err) + return false, err + } + zkevmVersion.ForkID = rollupType.ForkID + zkevmVersion.NumBatch = 0 + } + if zkevmVersion.NumBatch != 0 { + return false, fmt.Errorf("the specified genBlockNumber in config file does not contain the initial forkID event (BatchNum: %d). Please use the proper blockNumber.", zkevmVersion.NumBatch) + } + metrics.VerifyGenBlockTime(time.Since(start)) + return true, nil +} + +/* +// GetForks returns fork information +func (etherMan *Client) GetForks(ctx context.Context, genBlockNumber uint64, lastL1BlockSynced uint64) ([]state.ForkIDInterval, error) { + log.Debug("Getting forkIDs from blockNumber: ", genBlockNumber) + start := time.Now() + var logs []types.Log + log.Debug("Using ForkIDChunkSize: ", etherMan.cfg.ForkIDChunkSize) + for i := genBlockNumber; i <= lastL1BlockSynced; i = i + etherMan.cfg.ForkIDChunkSize + 1 { + final := i + etherMan.cfg.ForkIDChunkSize + if final > lastL1BlockSynced { + // Limit the query to the last l1BlockSynced + final = lastL1BlockSynced + } + log.Debug("INTERVAL. Initial: ", i, ". Final: ", final) + // Filter query + query := ethereum.FilterQuery{ + FromBlock: new(big.Int).SetUint64(i), + ToBlock: new(big.Int).SetUint64(final), + Addresses: etherMan.SCAddresses, + Topics: [][]common.Hash{{updateZkEVMVersionSignatureHash, updateRollupSignatureHash, addExistingRollupSignatureHash, createNewRollupSignatureHash}}, + } + l, err := etherMan.EthClient.FilterLogs(ctx, query) + if err != nil { + return []state.ForkIDInterval{}, err + } + logs = append(logs, l...) + } + + var forks []state.ForkIDInterval + for i, l := range logs { + var zkevmVersion oldpolygonzkevm.OldpolygonzkevmUpdateZkEVMVersion + switch l.Topics[0] { + case updateZkEVMVersionSignatureHash: + log.Debug("updateZkEVMVersion Event received") + zkevmV, err := etherMan.OldZkEVM.ParseUpdateZkEVMVersion(l) + if err != nil { + return []state.ForkIDInterval{}, err + } + if zkevmV != nil { + zkevmVersion = *zkevmV + } + case updateRollupSignatureHash: + log.Debug("updateRollup Event received") + updateRollupEvent, err := etherMan.RollupManager.ParseUpdateRollup(l) + if err != nil { + return []state.ForkIDInterval{}, err + } + if etherMan.RollupID != updateRollupEvent.RollupID { + continue + } + // Query to get the forkID + rollupType, err := etherMan.RollupManager.RollupTypeMap(&bind.CallOpts{Pending: false}, updateRollupEvent.NewRollupTypeID) + if err != nil { + return []state.ForkIDInterval{}, err + } + zkevmVersion.ForkID = rollupType.ForkID + zkevmVersion.NumBatch = updateRollupEvent.LastVerifiedBatchBeforeUpgrade + + case addExistingRollupSignatureHash: + log.Debug("addExistingRollup Event received") + addExistingRollupEvent, err := etherMan.RollupManager.ParseAddExistingRollup(l) + if err != nil { + return []state.ForkIDInterval{}, err + } + if etherMan.RollupID != addExistingRollupEvent.RollupID { + continue + } + zkevmVersion.ForkID = addExistingRollupEvent.ForkID + zkevmVersion.NumBatch = addExistingRollupEvent.LastVerifiedBatchBeforeUpgrade + + case createNewRollupSignatureHash: + log.Debug("createNewRollup Event received") + createNewRollupEvent, err := etherMan.RollupManager.ParseCreateNewRollup(l) + if err != nil { + return []state.ForkIDInterval{}, err + } + if etherMan.RollupID != createNewRollupEvent.RollupID { + continue + } + // Query to get the forkID + rollupType, err := etherMan.RollupManager.RollupTypeMap(&bind.CallOpts{Pending: false}, createNewRollupEvent.RollupTypeID) + if err != nil { + log.Error(err) + return []state.ForkIDInterval{}, err + } + zkevmVersion.ForkID = rollupType.ForkID + zkevmVersion.NumBatch = 0 + } + var fork state.ForkIDInterval + if i == 0 { + fork = state.ForkIDInterval{ + FromBatchNumber: zkevmVersion.NumBatch + 1, + ToBatchNumber: math.MaxUint64, + ForkId: zkevmVersion.ForkID, + Version: zkevmVersion.Version, + BlockNumber: l.BlockNumber, + } + } else { + forks[len(forks)-1].ToBatchNumber = zkevmVersion.NumBatch + fork = state.ForkIDInterval{ + FromBatchNumber: zkevmVersion.NumBatch + 1, + ToBatchNumber: math.MaxUint64, + ForkId: zkevmVersion.ForkID, + Version: zkevmVersion.Version, + BlockNumber: l.BlockNumber, + } + } + forks = append(forks, fork) + } + metrics.GetForksTime(time.Since(start)) + log.Debugf("ForkIDs found: %+v", forks) + return forks, nil +} +*/ + +// GetRollupInfoByBlockRange function retrieves the Rollup information that are included in all this ethereum blocks +// from block x to block y. +func (etherMan *Client) GetRollupInfoByBlockRange(ctx context.Context, fromBlock uint64, toBlock *uint64) ([]Block, map[common.Hash][]Order, error) { + // Filter query + query := ethereum.FilterQuery{ + FromBlock: new(big.Int).SetUint64(fromBlock), + Addresses: etherMan.SCAddresses, + } + if toBlock != nil { + query.ToBlock = new(big.Int).SetUint64(*toBlock) + } + blocks, blocksOrder, err := etherMan.readEvents(ctx, query) + if err != nil { + return nil, nil, err + } + return blocks, blocksOrder, nil +} + +// Order contains the event order to let the synchronizer store the information following this order. +type Order struct { + Name EventOrder + Pos int +} + +func (etherMan *Client) readEvents(ctx context.Context, query ethereum.FilterQuery) ([]Block, map[common.Hash][]Order, error) { + start := time.Now() + logs, err := etherMan.EthClient.FilterLogs(ctx, query) + metrics.GetEventsTime(time.Since(start)) + if err != nil { + return nil, nil, err + } + var blocks []Block + blocksOrder := make(map[common.Hash][]Order) + startProcess := time.Now() + for _, vLog := range logs { + startProcessSingleEvent := time.Now() + err := etherMan.processEvent(ctx, vLog, &blocks, &blocksOrder) + metrics.ProcessSingleEventTime(time.Since(startProcessSingleEvent)) + metrics.EventCounter() + if err != nil { + log.Warnf("error processing event. Retrying... Error: %s. vLog: %+v", err.Error(), vLog) + return nil, nil, err + } + } + metrics.ProcessAllEventTime(time.Since(startProcess)) + metrics.ReadAndProcessAllEventsTime(time.Since(start)) + return blocks, blocksOrder, nil +} + +func (etherMan *Client) processEvent(ctx context.Context, vLog types.Log, blocks *[]Block, blocksOrder *map[common.Hash][]Order) error { + switch vLog.Topics[0] { + case sequenceBatchesSignatureHash: + return etherMan.sequencedBatchesEvent(ctx, vLog, blocks, blocksOrder) + case sequenceBatchesPreEtrogSignatureHash: + return etherMan.sequencedBatchesPreEtrogEvent(ctx, vLog, blocks, blocksOrder) + case updateGlobalExitRootSignatureHash: + return etherMan.updateGlobalExitRootEvent(ctx, vLog, blocks, blocksOrder) + case updateL1InfoTreeSignatureHash: + return etherMan.updateL1InfoTreeEvent(ctx, vLog, blocks, blocksOrder) + case forceBatchSignatureHash: + return etherMan.forcedBatchEvent(ctx, vLog, blocks, blocksOrder) + case initialSequenceBatchesSignatureHash: + return etherMan.initialSequenceBatches(ctx, vLog, blocks, blocksOrder) + case verifyBatchesTrustedAggregatorSignatureHash: + log.Debug("VerifyBatchesTrustedAggregator event detected. Ignoring...") + return nil + case rollupManagerVerifyBatchesSignatureHash: + log.Debug("RollupManagerVerifyBatches event detected. Ignoring...") + return nil + case oldVerifyBatchesTrustedAggregatorSignatureHash: + return etherMan.oldVerifyBatchesTrustedAggregatorEvent(ctx, vLog, blocks, blocksOrder) + case verifyBatchesSignatureHash: + return etherMan.verifyBatchesEvent(ctx, vLog, blocks, blocksOrder) + case sequenceForceBatchesSignatureHash: + return etherMan.forceSequencedBatchesEvent(ctx, vLog, blocks, blocksOrder) + case setTrustedSequencerURLSignatureHash: + log.Debug("SetTrustedSequencerURL event detected. Ignoring...") + return nil + case setTrustedSequencerSignatureHash: + log.Debug("SetTrustedSequencer event detected. Ignoring...") + return nil + case initializedSignatureHash: + log.Debug("Initialized event detected. Ignoring...") + return nil + case initializedProxySignatureHash: + log.Debug("InitializedProxy event detected. Ignoring...") + return nil + case adminChangedSignatureHash: + log.Debug("AdminChanged event detected. Ignoring...") + return nil + case beaconUpgradedSignatureHash: + log.Debug("BeaconUpgraded event detected. Ignoring...") + return nil + case upgradedSignatureHash: + log.Debug("Upgraded event detected. Ignoring...") + return nil + case transferOwnershipSignatureHash: + log.Debug("TransferOwnership event detected. Ignoring...") + return nil + case emergencyStateActivatedSignatureHash: + log.Debug("EmergencyStateActivated event detected. Ignoring...") + return nil + case emergencyStateDeactivatedSignatureHash: + log.Debug("EmergencyStateDeactivated event detected. Ignoring...") + return nil + case updateZkEVMVersionSignatureHash: + return etherMan.updateZkevmVersion(ctx, vLog, blocks, blocksOrder) + case consolidatePendingStateSignatureHash: + log.Debug("ConsolidatePendingState event detected. Ignoring...") + return nil + case oldConsolidatePendingStateSignatureHash: + log.Debug("OldConsolidatePendingState event detected. Ignoring...") + return nil + case setTrustedAggregatorTimeoutSignatureHash: + log.Debug("SetTrustedAggregatorTimeout event detected. Ignoring...") + return nil + case setTrustedAggregatorSignatureHash: + log.Debug("SetTrustedAggregator event detected. Ignoring...") + return nil + case setPendingStateTimeoutSignatureHash: + log.Debug("SetPendingStateTimeout event detected. Ignoring...") + return nil + case setMultiplierBatchFeeSignatureHash: + log.Debug("SetMultiplierBatchFee event detected. Ignoring...") + return nil + case setVerifyBatchTimeTargetSignatureHash: + log.Debug("SetVerifyBatchTimeTarget event detected. Ignoring...") + return nil + case setForceBatchTimeoutSignatureHash: + log.Debug("SetForceBatchTimeout event detected. Ignoring...") + return nil + case activateForceBatchesSignatureHash: + log.Debug("ActivateForceBatches event detected. Ignoring...") + return nil + case transferAdminRoleSignatureHash: + log.Debug("TransferAdminRole event detected. Ignoring...") + return nil + case acceptAdminRoleSignatureHash: + log.Debug("AcceptAdminRole event detected. Ignoring...") + return nil + case proveNonDeterministicPendingStateSignatureHash: + log.Debug("ProveNonDeterministicPendingState event detected. Ignoring...") + return nil + case overridePendingStateSignatureHash: + log.Debug("OverridePendingState event detected. Ignoring...") + return nil + case oldOverridePendingStateSignatureHash: + log.Debug("OldOverridePendingState event detected. Ignoring...") + return nil + case roleAdminChangedSignatureHash: + log.Debug("RoleAdminChanged event detected. Ignoring...") + return nil + case roleGrantedSignatureHash: + log.Debug("RoleGranted event detected. Ignoring...") + return nil + case roleRevokedSignatureHash: + log.Debug("RoleRevoked event detected. Ignoring...") + return nil + case onSequenceBatchesSignatureHash: + log.Debug("OnSequenceBatches event detected. Ignoring...") + return nil + case updateRollupSignatureHash: + return etherMan.updateRollup(ctx, vLog, blocks, blocksOrder) + case addExistingRollupSignatureHash: + return etherMan.addExistingRollup(ctx, vLog, blocks, blocksOrder) + case createNewRollupSignatureHash: + return etherMan.createNewRollup(ctx, vLog, blocks, blocksOrder) + case obsoleteRollupTypeSignatureHash: + log.Debug("ObsoleteRollupType event detected. Ignoring...") + return nil + case addNewRollupTypeSignatureHash: + log.Debug("addNewRollupType event detected but not implemented. Ignoring...") + return nil + case setBatchFeeSignatureHash: + log.Debug("SetBatchFee event detected. Ignoring...") + return nil + } + log.Warnf("Event not registered: %+v", vLog) + return nil +} + +func (etherMan *Client) updateZkevmVersion(ctx context.Context, vLog types.Log, blocks *[]Block, blocksOrder *map[common.Hash][]Order) error { + log.Debug("UpdateZkEVMVersion event detected") + zkevmVersion, err := etherMan.OldZkEVM.ParseUpdateZkEVMVersion(vLog) + if err != nil { + log.Error("error parsing UpdateZkEVMVersion event. Error: ", err) + return err + } + return etherMan.updateForkId(ctx, vLog, blocks, blocksOrder, zkevmVersion.NumBatch, zkevmVersion.ForkID, zkevmVersion.Version) +} + +func (etherMan *Client) updateRollup(ctx context.Context, vLog types.Log, blocks *[]Block, blocksOrder *map[common.Hash][]Order) error { + log.Debug("UpdateRollup event detected") + updateRollup, err := etherMan.RollupManager.ParseUpdateRollup(vLog) + if err != nil { + log.Error("error parsing UpdateRollup event. Error: ", err) + return err + } + rollupType, err := etherMan.RollupManager.RollupTypeMap(&bind.CallOpts{Pending: false}, updateRollup.NewRollupTypeID) + if err != nil { + return err + } + return etherMan.updateForkId(ctx, vLog, blocks, blocksOrder, updateRollup.LastVerifiedBatchBeforeUpgrade, rollupType.ForkID, "") +} + +func (etherMan *Client) createNewRollup(ctx context.Context, vLog types.Log, blocks *[]Block, blocksOrder *map[common.Hash][]Order) error { + log.Debug("createNewRollup event detected") + createRollup, err := etherMan.RollupManager.ParseCreateNewRollup(vLog) + if err != nil { + log.Error("error parsing createNewRollup event. Error: ", err) + return err + } + rollupType, err := etherMan.RollupManager.RollupTypeMap(&bind.CallOpts{Pending: false}, createRollup.RollupTypeID) + if err != nil { + return err + } + return etherMan.updateForkId(ctx, vLog, blocks, blocksOrder, 0, rollupType.ForkID, "") +} + +func (etherMan *Client) addExistingRollup(ctx context.Context, vLog types.Log, blocks *[]Block, blocksOrder *map[common.Hash][]Order) error { + log.Debug("addExistingRollup event detected") + addExistingRollup, err := etherMan.RollupManager.ParseAddExistingRollup(vLog) + if err != nil { + log.Error("error parsing createNewRollup event. Error: ", err) + return err + } + if etherMan.RollupID != addExistingRollup.RollupID { + return nil + } + return etherMan.updateForkId(ctx, vLog, blocks, blocksOrder, addExistingRollup.LastVerifiedBatchBeforeUpgrade, addExistingRollup.ForkID, "") +} + +func (etherMan *Client) initialSequenceBatches(ctx context.Context, vLog types.Log, blocks *[]Block, blocksOrder *map[common.Hash][]Order) error { + log.Debug("initialSequenceBatches event detected") + initialSequenceBatches, err := etherMan.ZkEVM.ParseInitialSequenceBatches(vLog) + if err != nil { + log.Error("error parsing createNewRollup event. Error: ", err) + return err + } + + // Read the tx for this event. + tx, err := etherMan.EthClient.TransactionInBlock(ctx, vLog.BlockHash, vLog.TxIndex) + if err != nil { + return err + } + if tx.Hash() != vLog.TxHash { + return fmt.Errorf("error: tx hash mismatch. want: %s have: %s", vLog.TxHash, tx.Hash().String()) + } + msg, err := core.TransactionToMessage(tx, types.NewLondonSigner(tx.ChainId()), big.NewInt(0)) + if err != nil { + return err + } + fullBlock, err := etherMan.EthClient.BlockByHash(ctx, vLog.BlockHash) + if err != nil { + return fmt.Errorf("error getting fullBlockInfo. BlockNumber: %d. Error: %w", vLog.BlockNumber, err) + } + + var sequences []SequencedBatch + log.Info("initial transaction sequence...") + sequences = append(sequences, SequencedBatch{ + BatchNumber: 1, + SequencerAddr: msg.From, + TxHash: vLog.TxHash, + Nonce: msg.Nonce, + PolygonRollupBaseEtrogBatchData: &polygonzkevm.PolygonRollupBaseEtrogBatchData{ + Transactions: initialSequenceBatches.Transactions, + ForcedGlobalExitRoot: initialSequenceBatches.LastGlobalExitRoot, + ForcedTimestamp: fullBlock.Time(), + ForcedBlockHashL1: fullBlock.ParentHash(), + }, + }) + + if len(*blocks) == 0 || ((*blocks)[len(*blocks)-1].BlockHash != vLog.BlockHash || (*blocks)[len(*blocks)-1].BlockNumber != vLog.BlockNumber) { + block := prepareBlock(vLog, time.Unix(int64(fullBlock.Time()), 0), fullBlock) + block.SequencedBatches = append(block.SequencedBatches, sequences) + *blocks = append(*blocks, block) + } else if (*blocks)[len(*blocks)-1].BlockHash == vLog.BlockHash && (*blocks)[len(*blocks)-1].BlockNumber == vLog.BlockNumber { + (*blocks)[len(*blocks)-1].SequencedBatches = append((*blocks)[len(*blocks)-1].SequencedBatches, sequences) + } else { + log.Error("Error processing SequencedBatches event. BlockHash:", vLog.BlockHash, ". BlockNumber: ", vLog.BlockNumber) + return fmt.Errorf("error processing SequencedBatches event") + } + or := Order{ + Name: SequenceBatchesOrder, + Pos: len((*blocks)[len(*blocks)-1].SequencedBatches) - 1, + } + (*blocksOrder)[(*blocks)[len(*blocks)-1].BlockHash] = append((*blocksOrder)[(*blocks)[len(*blocks)-1].BlockHash], or) + return nil +} +func (etherMan *Client) updateForkId(ctx context.Context, vLog types.Log, blocks *[]Block, blocksOrder *map[common.Hash][]Order, batchNum, forkID uint64, version string) error { + fork := ForkID{ + BatchNumber: batchNum, + ForkID: forkID, + Version: version, + } + if len(*blocks) == 0 || ((*blocks)[len(*blocks)-1].BlockHash != vLog.BlockHash || (*blocks)[len(*blocks)-1].BlockNumber != vLog.BlockNumber) { + fullBlock, err := etherMan.EthClient.BlockByHash(ctx, vLog.BlockHash) + if err != nil { + return fmt.Errorf("error getting hashParent. BlockNumber: %d. Error: %w", vLog.BlockNumber, err) + } + t := time.Unix(int64(fullBlock.Time()), 0) + block := prepareBlock(vLog, t, fullBlock) + block.ForkIDs = append(block.ForkIDs, fork) + *blocks = append(*blocks, block) + } else if (*blocks)[len(*blocks)-1].BlockHash == vLog.BlockHash && (*blocks)[len(*blocks)-1].BlockNumber == vLog.BlockNumber { + (*blocks)[len(*blocks)-1].ForkIDs = append((*blocks)[len(*blocks)-1].ForkIDs, fork) + } else { + log.Error("Error processing updateZkevmVersion event. BlockHash:", vLog.BlockHash, ". BlockNumber: ", vLog.BlockNumber) + return fmt.Errorf("error processing updateZkevmVersion event") + } + or := Order{ + Name: ForkIDsOrder, + Pos: len((*blocks)[len(*blocks)-1].ForkIDs) - 1, + } + (*blocksOrder)[(*blocks)[len(*blocks)-1].BlockHash] = append((*blocksOrder)[(*blocks)[len(*blocks)-1].BlockHash], or) + return nil +} + +func (etherMan *Client) updateL1InfoTreeEvent(ctx context.Context, vLog types.Log, blocks *[]Block, blocksOrder *map[common.Hash][]Order) error { + log.Debug("UpdateL1InfoTree event detected") + globalExitRootL1InfoTree, err := etherMan.GlobalExitRootManager.ParseUpdateL1InfoTree(vLog) + if err != nil { + return err + } + + var gExitRoot GlobalExitRoot + gExitRoot.MainnetExitRoot = globalExitRootL1InfoTree.MainnetExitRoot + gExitRoot.RollupExitRoot = globalExitRootL1InfoTree.RollupExitRoot + gExitRoot.BlockNumber = vLog.BlockNumber + gExitRoot.GlobalExitRoot = hash(globalExitRootL1InfoTree.MainnetExitRoot, globalExitRootL1InfoTree.RollupExitRoot) + var block *Block + if !isheadBlockInArray(blocks, vLog.BlockHash, vLog.BlockNumber) { + // Need to add the block, doesnt mind if inside the blocks because I have to respect the order so insert at end + block, err = etherMan.retrieveFullBlockForEvent(ctx, vLog) + if err != nil { + return err + } + *blocks = append(*blocks, *block) + } + // Get the block in the HEAD of the array that contain the current block + block = &(*blocks)[len(*blocks)-1] + gExitRoot.PreviousBlockHash = block.ParentHash + gExitRoot.Timestamp = block.ReceivedAt + // Add the event to the block + block.L1InfoTree = append(block.L1InfoTree, gExitRoot) + order := Order{ + Name: L1InfoTreeOrder, + Pos: len(block.L1InfoTree) - 1, + } + (*blocksOrder)[block.BlockHash] = append((*blocksOrder)[block.BlockHash], order) + return nil +} + +func (etherMan *Client) retrieveFullBlockForEvent(ctx context.Context, vLog types.Log) (*Block, error) { + fullBlock, err := etherMan.EthClient.BlockByHash(ctx, vLog.BlockHash) + if err != nil { + return nil, fmt.Errorf("error getting hashParent. BlockNumber: %d. Error: %w", vLog.BlockNumber, err) + } + t := time.Unix(int64(fullBlock.Time()), 0) + block := prepareBlock(vLog, t, fullBlock) + return &block, nil +} + +// Check if head block in blocks array is the same as blockHash / blockNumber +func isheadBlockInArray(blocks *[]Block, blockHash common.Hash, blockNumber uint64) bool { + // Check last item on array blocks if match Hash and Number + headBlockIsNotExpected := len(*blocks) == 0 || ((*blocks)[len(*blocks)-1].BlockHash != blockHash || (*blocks)[len(*blocks)-1].BlockNumber != blockNumber) + return !headBlockIsNotExpected +} + +func (etherMan *Client) updateGlobalExitRootEvent(ctx context.Context, vLog types.Log, blocks *[]Block, blocksOrder *map[common.Hash][]Order) error { + log.Debug("UpdateGlobalExitRoot event detected") + oldglobalExitRoot, err := etherMan.OldGlobalExitRootManager.ParseUpdateGlobalExitRoot(vLog) + if err != nil { + return err + } + return etherMan.processUpdateGlobalExitRootEvent(ctx, oldglobalExitRoot.MainnetExitRoot, oldglobalExitRoot.RollupExitRoot, vLog, blocks, blocksOrder) +} + +func (etherMan *Client) processUpdateGlobalExitRootEvent(ctx context.Context, mainnetExitRoot, rollupExitRoot common.Hash, vLog types.Log, blocks *[]Block, blocksOrder *map[common.Hash][]Order) error { + var gExitRoot GlobalExitRoot + gExitRoot.MainnetExitRoot = mainnetExitRoot + gExitRoot.RollupExitRoot = rollupExitRoot + gExitRoot.BlockNumber = vLog.BlockNumber + gExitRoot.GlobalExitRoot = hash(mainnetExitRoot, rollupExitRoot) + + fullBlock, err := etherMan.EthClient.BlockByHash(ctx, vLog.BlockHash) + if err != nil { + return fmt.Errorf("error getting hashParent. BlockNumber: %d. Error: %w", vLog.BlockNumber, err) + } + t := time.Unix(int64(fullBlock.Time()), 0) + gExitRoot.Timestamp = t + + if len(*blocks) == 0 || ((*blocks)[len(*blocks)-1].BlockHash != vLog.BlockHash || (*blocks)[len(*blocks)-1].BlockNumber != vLog.BlockNumber) { + block := prepareBlock(vLog, t, fullBlock) + block.GlobalExitRoots = append(block.GlobalExitRoots, gExitRoot) + *blocks = append(*blocks, block) + } else if (*blocks)[len(*blocks)-1].BlockHash == vLog.BlockHash && (*blocks)[len(*blocks)-1].BlockNumber == vLog.BlockNumber { + (*blocks)[len(*blocks)-1].GlobalExitRoots = append((*blocks)[len(*blocks)-1].GlobalExitRoots, gExitRoot) + } else { + log.Error("Error processing UpdateGlobalExitRoot event. BlockHash:", vLog.BlockHash, ". BlockNumber: ", vLog.BlockNumber) + return fmt.Errorf("error processing UpdateGlobalExitRoot event") + } + or := Order{ + Name: GlobalExitRootsOrder, + Pos: len((*blocks)[len(*blocks)-1].GlobalExitRoots) - 1, + } + (*blocksOrder)[(*blocks)[len(*blocks)-1].BlockHash] = append((*blocksOrder)[(*blocks)[len(*blocks)-1].BlockHash], or) + return nil +} + +// WaitTxToBeMined waits for an L1 tx to be mined. It will return error if the tx is reverted or timeout is exceeded +func (etherMan *Client) WaitTxToBeMined(ctx context.Context, tx *types.Transaction, timeout time.Duration) (bool, error) { + err := WaitTxToBeMined(ctx, etherMan.EthClient, tx, timeout) + if errors.Is(err, context.DeadlineExceeded) { + return false, nil + } + if err != nil { + return false, err + } + return true, nil +} + +// EstimateGasSequenceBatches estimates gas for sending batches +func (etherMan *Client) EstimateGasSequenceBatches(sender common.Address, sequences []ethmanTypes.Sequence, l2Coinbase common.Address) (*types.Transaction, error) { + opts, err := etherMan.getAuthByAddress(sender) + if err == ErrNotFound { + return nil, ErrPrivateKeyNotFound + } + opts.NoSend = true + + tx, err := etherMan.sequenceBatches(opts, sequences, l2Coinbase) + if err != nil { + return nil, err + } + + return tx, nil +} + +// BuildSequenceBatchesTxData builds a []bytes to be sent to the PoE SC method SequenceBatches. +func (etherMan *Client) BuildSequenceBatchesTxData(sender common.Address, sequences []ethmanTypes.Sequence, l2Coinbase common.Address) (to *common.Address, data []byte, err error) { + opts, err := etherMan.getAuthByAddress(sender) + if err == ErrNotFound { + return nil, nil, fmt.Errorf("failed to build sequence batches, err: %w", ErrPrivateKeyNotFound) + } + opts.NoSend = true + // force nonce, gas limit and gas price to avoid querying it from the chain + opts.Nonce = big.NewInt(1) + opts.GasLimit = uint64(1) + opts.GasPrice = big.NewInt(1) + + tx, err := etherMan.sequenceBatches(opts, sequences, l2Coinbase) + if err != nil { + return nil, nil, err + } + + return tx.To(), tx.Data(), nil +} + +func (etherMan *Client) sequenceBatches(opts bind.TransactOpts, sequences []ethmanTypes.Sequence, l2Coinbase common.Address) (*types.Transaction, error) { + var batches []polygonzkevm.PolygonRollupBaseEtrogBatchData + for _, seq := range sequences { + batch := polygonzkevm.PolygonRollupBaseEtrogBatchData{ + Transactions: seq.BatchL2Data, + ForcedGlobalExitRoot: seq.GlobalExitRoot, + ForcedTimestamp: uint64(seq.ForcedBatchTimestamp), + ForcedBlockHashL1: seq.PrevBlockHash, + } + + batches = append(batches, batch) + } + + tx, err := etherMan.ZkEVM.SequenceBatches(&opts, batches, l2Coinbase) + if err != nil { + log.Debugf("Batches to send: %+v", batches) + log.Debug("l2CoinBase: ", l2Coinbase) + log.Debug("Sequencer address: ", opts.From) + a, err2 := polygonzkevm.PolygonzkevmMetaData.GetAbi() + if err2 != nil { + log.Error("error getting abi. Error: ", err2) + } + input, err3 := a.Pack("sequenceBatches", batches, l2Coinbase) + if err3 != nil { + log.Error("error packing call. Error: ", err3) + } + ctx := context.Background() + var b string + block, err4 := etherMan.EthClient.BlockByNumber(ctx, nil) + if err4 != nil { + log.Error("error getting blockNumber. Error: ", err4) + b = "latest" + } else { + b = fmt.Sprintf("%x", block.Number()) + } + log.Warnf(`Use the next command to debug it manually. + curl --location --request POST 'http://localhost:8545' \ + --header 'Content-Type: application/json' \ + --data-raw '{ + "jsonrpc": "2.0", + "method": "eth_call", + "params": [{"from": "%s","to":"%s","data":"0x%s"},"0x%s"], + "id": 1 + }'`, opts.From, ðerMan.SCAddresses[0], common.Bytes2Hex(input), b) + if parsedErr, ok := tryParseError(err); ok { + err = parsedErr + } + } + + return tx, err +} + +// BuildTrustedVerifyBatchesTxData builds a []bytes to be sent to the PoE SC method TrustedVerifyBatches. +func (etherMan *Client) BuildTrustedVerifyBatchesTxData(lastVerifiedBatch, newVerifiedBatch uint64, inputs *ethmanTypes.FinalProofInputs, beneficiary common.Address) (to *common.Address, data []byte, err error) { + opts, err := etherMan.generateRandomAuth() + if err != nil { + return nil, nil, fmt.Errorf("failed to build trusted verify batches, err: %w", err) + } + opts.NoSend = true + // force nonce, gas limit and gas price to avoid querying it from the chain + opts.Nonce = big.NewInt(1) + opts.GasLimit = uint64(1) + opts.GasPrice = big.NewInt(1) + + var newLocalExitRoot [32]byte + copy(newLocalExitRoot[:], inputs.NewLocalExitRoot) + + var newStateRoot [32]byte + copy(newStateRoot[:], inputs.NewStateRoot) + + proof, err := convertProof(inputs.FinalProof.Proof) + if err != nil { + log.Errorf("error converting proof. Error: %v, Proof: %s", err, inputs.FinalProof.Proof) + return nil, nil, err + } + + const pendStateNum = 0 // TODO hardcoded for now until we implement the pending state feature + + tx, err := etherMan.RollupManager.VerifyBatchesTrustedAggregator( + &opts, + etherMan.RollupID, + pendStateNum, + lastVerifiedBatch, + newVerifiedBatch, + newLocalExitRoot, + newStateRoot, + beneficiary, + proof, + ) + if err != nil { + if parsedErr, ok := tryParseError(err); ok { + err = parsedErr + } + return nil, nil, err + } + + return tx.To(), tx.Data(), nil +} + +func convertProof(p string) ([24][32]byte, error) { + if len(p) != 24*32*2+2 { + return [24][32]byte{}, fmt.Errorf("invalid proof length. Length: %d", len(p)) + } + p = strings.TrimPrefix(p, "0x") + proof := [24][32]byte{} + for i := 0; i < 24; i++ { + data := p[i*64 : (i+1)*64] + p, err := encoding.DecodeBytes(&data) + if err != nil { + return [24][32]byte{}, fmt.Errorf("failed to decode proof, err: %w", err) + } + var aux [32]byte + copy(aux[:], p) + proof[i] = aux + } + return proof, nil +} + +// GetSendSequenceFee get super/trusted sequencer fee +func (etherMan *Client) GetSendSequenceFee(numBatches uint64) (*big.Int, error) { + f, err := etherMan.RollupManager.GetBatchFee(&bind.CallOpts{Pending: false}) + if err != nil { + return nil, err + } + fee := new(big.Int).Mul(f, new(big.Int).SetUint64(numBatches)) + return fee, nil +} + +// TrustedSequencer gets trusted sequencer address +func (etherMan *Client) TrustedSequencer() (common.Address, error) { + return etherMan.ZkEVM.TrustedSequencer(&bind.CallOpts{Pending: false}) +} + +func (etherMan *Client) forcedBatchEvent(ctx context.Context, vLog types.Log, blocks *[]Block, blocksOrder *map[common.Hash][]Order) error { + log.Debug("ForceBatch event detected") + fb, err := etherMan.ZkEVM.ParseForceBatch(vLog) + if err != nil { + return err + } + var forcedBatch ForcedBatch + forcedBatch.BlockNumber = vLog.BlockNumber + forcedBatch.ForcedBatchNumber = fb.ForceBatchNum + forcedBatch.GlobalExitRoot = fb.LastGlobalExitRoot + + // Read the tx for this batch. + tx, err := etherMan.EthClient.TransactionInBlock(ctx, vLog.BlockHash, vLog.TxIndex) + if err != nil { + return err + } + if tx.Hash() != vLog.TxHash { + return fmt.Errorf("error: tx hash mismatch. want: %s have: %s", vLog.TxHash, tx.Hash().String()) + } + + msg, err := core.TransactionToMessage(tx, types.NewLondonSigner(tx.ChainId()), big.NewInt(0)) + if err != nil { + return err + } + if fb.Sequencer == msg.From { + txData := tx.Data() + // Extract coded txs. + // Load contract ABI + abi, err := abi.JSON(strings.NewReader(polygonzkevm.PolygonzkevmABI)) + if err != nil { + return err + } + + // Recover Method from signature and ABI + method, err := abi.MethodById(txData[:4]) + if err != nil { + return err + } + + // Unpack method inputs + data, err := method.Inputs.Unpack(txData[4:]) + if err != nil { + return err + } + bytedata := data[0].([]byte) + forcedBatch.RawTxsData = bytedata + } else { + forcedBatch.RawTxsData = fb.Transactions + } + forcedBatch.Sequencer = fb.Sequencer + fullBlock, err := etherMan.EthClient.BlockByHash(ctx, vLog.BlockHash) + if err != nil { + return fmt.Errorf("error getting hashParent. BlockNumber: %d. Error: %w", vLog.BlockNumber, err) + } + t := time.Unix(int64(fullBlock.Time()), 0) + forcedBatch.ForcedAt = t + if len(*blocks) == 0 || ((*blocks)[len(*blocks)-1].BlockHash != vLog.BlockHash || (*blocks)[len(*blocks)-1].BlockNumber != vLog.BlockNumber) { + block := prepareBlock(vLog, t, fullBlock) + block.ForcedBatches = append(block.ForcedBatches, forcedBatch) + *blocks = append(*blocks, block) + } else if (*blocks)[len(*blocks)-1].BlockHash == vLog.BlockHash && (*blocks)[len(*blocks)-1].BlockNumber == vLog.BlockNumber { + (*blocks)[len(*blocks)-1].ForcedBatches = append((*blocks)[len(*blocks)-1].ForcedBatches, forcedBatch) + } else { + log.Error("Error processing ForceBatch event. BlockHash:", vLog.BlockHash, ". BlockNumber: ", vLog.BlockNumber) + return fmt.Errorf("error processing ForceBatch event") + } + or := Order{ + Name: ForcedBatchesOrder, + Pos: len((*blocks)[len(*blocks)-1].ForcedBatches) - 1, + } + (*blocksOrder)[(*blocks)[len(*blocks)-1].BlockHash] = append((*blocksOrder)[(*blocks)[len(*blocks)-1].BlockHash], or) + return nil +} + +func (etherMan *Client) sequencedBatchesEvent(ctx context.Context, vLog types.Log, blocks *[]Block, blocksOrder *map[common.Hash][]Order) error { + log.Debug("SequenceBatches event detected") + sb, err := etherMan.ZkEVM.ParseSequenceBatches(vLog) + if err != nil { + return err + } + + // Read the tx for this event. + tx, err := etherMan.EthClient.TransactionInBlock(ctx, vLog.BlockHash, vLog.TxIndex) + if err != nil { + return err + } + if tx.Hash() != vLog.TxHash { + return fmt.Errorf("error: tx hash mismatch. want: %s have: %s", vLog.TxHash, tx.Hash().String()) + } + msg, err := core.TransactionToMessage(tx, types.NewLondonSigner(tx.ChainId()), big.NewInt(0)) + if err != nil { + return err + } + + var sequences []SequencedBatch + if sb.NumBatch != 1 { + sequences, err = decodeSequences(tx.Data(), sb.NumBatch, msg.From, vLog.TxHash, msg.Nonce, sb.L1InfoRoot) + if err != nil { + return fmt.Errorf("error decoding the sequences: %v", err) + } + } else { + log.Info("initial transaction sequence...") + sequences = append(sequences, SequencedBatch{ + BatchNumber: 1, + SequencerAddr: msg.From, + TxHash: vLog.TxHash, + Nonce: msg.Nonce, + }) + } + + if len(*blocks) == 0 || ((*blocks)[len(*blocks)-1].BlockHash != vLog.BlockHash || (*blocks)[len(*blocks)-1].BlockNumber != vLog.BlockNumber) { + fullBlock, err := etherMan.EthClient.BlockByHash(ctx, vLog.BlockHash) + if err != nil { + return fmt.Errorf("error getting hashParent. BlockNumber: %d. Error: %w", vLog.BlockNumber, err) + } + block := prepareBlock(vLog, time.Unix(int64(fullBlock.Time()), 0), fullBlock) + block.SequencedBatches = append(block.SequencedBatches, sequences) + *blocks = append(*blocks, block) + } else if (*blocks)[len(*blocks)-1].BlockHash == vLog.BlockHash && (*blocks)[len(*blocks)-1].BlockNumber == vLog.BlockNumber { + (*blocks)[len(*blocks)-1].SequencedBatches = append((*blocks)[len(*blocks)-1].SequencedBatches, sequences) + } else { + log.Error("Error processing SequencedBatches event. BlockHash:", vLog.BlockHash, ". BlockNumber: ", vLog.BlockNumber) + return fmt.Errorf("error processing SequencedBatches event") + } + or := Order{ + Name: SequenceBatchesOrder, + Pos: len((*blocks)[len(*blocks)-1].SequencedBatches) - 1, + } + (*blocksOrder)[(*blocks)[len(*blocks)-1].BlockHash] = append((*blocksOrder)[(*blocks)[len(*blocks)-1].BlockHash], or) + return nil +} + +func (etherMan *Client) sequencedBatchesPreEtrogEvent(ctx context.Context, vLog types.Log, blocks *[]Block, blocksOrder *map[common.Hash][]Order) error { + log.Debug("Pre etrog SequenceBatches event detected") + sb, err := etherMan.OldZkEVM.ParseSequenceBatches(vLog) + if err != nil { + return err + } + + // Read the tx for this event. + tx, err := etherMan.EthClient.TransactionInBlock(ctx, vLog.BlockHash, vLog.TxIndex) + if err != nil { + return err + } + if tx.Hash() != vLog.TxHash { + return fmt.Errorf("error: tx hash mismatch. want: %s have: %s", vLog.TxHash, tx.Hash().String()) + } + msg, err := core.TransactionToMessage(tx, types.NewLondonSigner(tx.ChainId()), big.NewInt(0)) + if err != nil { + return err + } + + sequences, err := decodeSequencesPreEtrog(tx.Data(), sb.NumBatch, msg.From, vLog.TxHash, msg.Nonce) + if err != nil { + return fmt.Errorf("error decoding the sequences: %v", err) + } + + if len(*blocks) == 0 || ((*blocks)[len(*blocks)-1].BlockHash != vLog.BlockHash || (*blocks)[len(*blocks)-1].BlockNumber != vLog.BlockNumber) { + fullBlock, err := etherMan.EthClient.BlockByHash(ctx, vLog.BlockHash) + if err != nil { + return fmt.Errorf("error getting hashParent. BlockNumber: %d. Error: %w", vLog.BlockNumber, err) + } + block := prepareBlock(vLog, time.Unix(int64(fullBlock.Time()), 0), fullBlock) + block.SequencedBatches = append(block.SequencedBatches, sequences) + *blocks = append(*blocks, block) + } else if (*blocks)[len(*blocks)-1].BlockHash == vLog.BlockHash && (*blocks)[len(*blocks)-1].BlockNumber == vLog.BlockNumber { + (*blocks)[len(*blocks)-1].SequencedBatches = append((*blocks)[len(*blocks)-1].SequencedBatches, sequences) + } else { + log.Error("Error processing SequencedBatches event. BlockHash:", vLog.BlockHash, ". BlockNumber: ", vLog.BlockNumber) + return fmt.Errorf("error processing SequencedBatches event") + } + or := Order{ + Name: SequenceBatchesOrder, + Pos: len((*blocks)[len(*blocks)-1].SequencedBatches) - 1, + } + (*blocksOrder)[(*blocks)[len(*blocks)-1].BlockHash] = append((*blocksOrder)[(*blocks)[len(*blocks)-1].BlockHash], or) + return nil +} + +func decodeSequences(txData []byte, lastBatchNumber uint64, sequencer common.Address, txHash common.Hash, nonce uint64, l1InfoRoot common.Hash) ([]SequencedBatch, error) { + // Extract coded txs. + // Load contract ABI + smcAbi, err := abi.JSON(strings.NewReader(polygonzkevm.PolygonzkevmABI)) + if err != nil { + return nil, err + } + + // Recover Method from signature and ABI + method, err := smcAbi.MethodById(txData[:4]) + if err != nil { + return nil, err + } + + // Unpack method inputs + data, err := method.Inputs.Unpack(txData[4:]) + if err != nil { + return nil, err + } + var sequences []polygonzkevm.PolygonRollupBaseEtrogBatchData + bytedata, err := json.Marshal(data[0]) + if err != nil { + return nil, err + } + err = json.Unmarshal(bytedata, &sequences) + if err != nil { + return nil, err + } + coinbase := (data[1]).(common.Address) + sequencedBatches := make([]SequencedBatch, len(sequences)) + for i, seq := range sequences { + bn := lastBatchNumber - uint64(len(sequences)-(i+1)) + s := seq + sequencedBatches[i] = SequencedBatch{ + BatchNumber: bn, + L1InfoRoot: &l1InfoRoot, + SequencerAddr: sequencer, + TxHash: txHash, + Nonce: nonce, + Coinbase: coinbase, + PolygonRollupBaseEtrogBatchData: &s, + } + } + + return sequencedBatches, nil +} + +func decodeSequencesPreEtrog(txData []byte, lastBatchNumber uint64, sequencer common.Address, txHash common.Hash, nonce uint64) ([]SequencedBatch, error) { + // Extract coded txs. + // Load contract ABI + smcAbi, err := abi.JSON(strings.NewReader(oldpolygonzkevm.OldpolygonzkevmABI)) + if err != nil { + return nil, err + } + + // Recover Method from signature and ABI + method, err := smcAbi.MethodById(txData[:4]) + if err != nil { + return nil, err + } + + // Unpack method inputs + data, err := method.Inputs.Unpack(txData[4:]) + if err != nil { + return nil, err + } + var sequences []oldpolygonzkevm.PolygonZkEVMBatchData + bytedata, err := json.Marshal(data[0]) + if err != nil { + return nil, err + } + err = json.Unmarshal(bytedata, &sequences) + if err != nil { + return nil, err + } + coinbase := (data[1]).(common.Address) + sequencedBatches := make([]SequencedBatch, len(sequences)) + for i, seq := range sequences { + bn := lastBatchNumber - uint64(len(sequences)-(i+1)) + s := seq + sequencedBatches[i] = SequencedBatch{ + BatchNumber: bn, + SequencerAddr: sequencer, + TxHash: txHash, + Nonce: nonce, + Coinbase: coinbase, + PolygonZkEVMBatchData: &s, + } + } + + return sequencedBatches, nil +} + +func (etherMan *Client) oldVerifyBatchesTrustedAggregatorEvent(ctx context.Context, vLog types.Log, blocks *[]Block, blocksOrder *map[common.Hash][]Order) error { + log.Debug("TrustedVerifyBatches event detected") + var vb *oldpolygonzkevm.OldpolygonzkevmVerifyBatchesTrustedAggregator + vb, err := etherMan.OldZkEVM.ParseVerifyBatchesTrustedAggregator(vLog) + if err != nil { + log.Error("error parsing TrustedVerifyBatches event. Error: ", err) + return err + } + return etherMan.verifyBatches(ctx, vLog, blocks, blocksOrder, vb.NumBatch, vb.StateRoot, vb.Aggregator, TrustedVerifyBatchOrder) +} + +func (etherMan *Client) verifyBatchesEvent(ctx context.Context, vLog types.Log, blocks *[]Block, blocksOrder *map[common.Hash][]Order) error { + log.Debug("VerifyBatches event detected") + vb, err := etherMan.ZkEVM.ParseVerifyBatches(vLog) + if err != nil { + log.Error("error parsing VerifyBatches event. Error: ", err) + return err + } + return etherMan.verifyBatches(ctx, vLog, blocks, blocksOrder, vb.NumBatch, vb.StateRoot, vb.Aggregator, VerifyBatchOrder) +} +func (etherMan *Client) verifyBatches( + ctx context.Context, + vLog types.Log, + blocks *[]Block, + blocksOrder *map[common.Hash][]Order, + numBatch uint64, + stateRoot common.Hash, + aggregator common.Address, + orderName EventOrder) error { + var verifyBatch VerifiedBatch + verifyBatch.BlockNumber = vLog.BlockNumber + verifyBatch.BatchNumber = numBatch + verifyBatch.TxHash = vLog.TxHash + verifyBatch.StateRoot = stateRoot + verifyBatch.Aggregator = aggregator + + if len(*blocks) == 0 || ((*blocks)[len(*blocks)-1].BlockHash != vLog.BlockHash || (*blocks)[len(*blocks)-1].BlockNumber != vLog.BlockNumber) { + fullBlock, err := etherMan.EthClient.BlockByHash(ctx, vLog.BlockHash) + if err != nil { + return fmt.Errorf("error getting hashParent. BlockNumber: %d. Error: %w", vLog.BlockNumber, err) + } + block := prepareBlock(vLog, time.Unix(int64(fullBlock.Time()), 0), fullBlock) + block.VerifiedBatches = append(block.VerifiedBatches, verifyBatch) + *blocks = append(*blocks, block) + } else if (*blocks)[len(*blocks)-1].BlockHash == vLog.BlockHash && (*blocks)[len(*blocks)-1].BlockNumber == vLog.BlockNumber { + (*blocks)[len(*blocks)-1].VerifiedBatches = append((*blocks)[len(*blocks)-1].VerifiedBatches, verifyBatch) + } else { + log.Error("Error processing verifyBatch event. BlockHash:", vLog.BlockHash, ". BlockNumber: ", vLog.BlockNumber) + return fmt.Errorf("error processing verifyBatch event") + } + or := Order{ + Name: orderName, + Pos: len((*blocks)[len(*blocks)-1].VerifiedBatches) - 1, + } + (*blocksOrder)[(*blocks)[len(*blocks)-1].BlockHash] = append((*blocksOrder)[(*blocks)[len(*blocks)-1].BlockHash], or) + return nil +} + +func (etherMan *Client) forceSequencedBatchesEvent(ctx context.Context, vLog types.Log, blocks *[]Block, blocksOrder *map[common.Hash][]Order) error { + log.Debug("SequenceForceBatches event detect") + fsb, err := etherMan.ZkEVM.ParseSequenceForceBatches(vLog) + if err != nil { + return err + } + // TODO completar los datos de forcedBlockHas, forcedGer y forcedTimestamp + + // Read the tx for this batch. + tx, err := etherMan.EthClient.TransactionInBlock(ctx, vLog.BlockHash, vLog.TxIndex) + if err != nil { + return err + } + if tx.Hash() != vLog.TxHash { + return fmt.Errorf("error: tx hash mismatch. want: %s have: %s", vLog.TxHash, tx.Hash().String()) + } + msg, err := core.TransactionToMessage(tx, types.NewLondonSigner(tx.ChainId()), big.NewInt(0)) + if err != nil { + return err + } + fullBlock, err := etherMan.EthClient.BlockByHash(ctx, vLog.BlockHash) + if err != nil { + return fmt.Errorf("error getting hashParent. BlockNumber: %d. Error: %w", vLog.BlockNumber, err) + } + sequencedForceBatch, err := decodeSequencedForceBatches(tx.Data(), fsb.NumBatch, msg.From, vLog.TxHash, fullBlock, msg.Nonce) + if err != nil { + return err + } + + if len(*blocks) == 0 || ((*blocks)[len(*blocks)-1].BlockHash != vLog.BlockHash || (*blocks)[len(*blocks)-1].BlockNumber != vLog.BlockNumber) { + block := prepareBlock(vLog, time.Unix(int64(fullBlock.Time()), 0), fullBlock) + block.SequencedForceBatches = append(block.SequencedForceBatches, sequencedForceBatch) + *blocks = append(*blocks, block) + } else if (*blocks)[len(*blocks)-1].BlockHash == vLog.BlockHash && (*blocks)[len(*blocks)-1].BlockNumber == vLog.BlockNumber { + (*blocks)[len(*blocks)-1].SequencedForceBatches = append((*blocks)[len(*blocks)-1].SequencedForceBatches, sequencedForceBatch) + } else { + log.Error("Error processing ForceSequencedBatches event. BlockHash:", vLog.BlockHash, ". BlockNumber: ", vLog.BlockNumber) + return fmt.Errorf("error processing ForceSequencedBatches event") + } + or := Order{ + Name: SequenceForceBatchesOrder, + Pos: len((*blocks)[len(*blocks)-1].SequencedForceBatches) - 1, + } + (*blocksOrder)[(*blocks)[len(*blocks)-1].BlockHash] = append((*blocksOrder)[(*blocks)[len(*blocks)-1].BlockHash], or) + + return nil +} + +func decodeSequencedForceBatches(txData []byte, lastBatchNumber uint64, sequencer common.Address, txHash common.Hash, block *types.Block, nonce uint64) ([]SequencedForceBatch, error) { + // Extract coded txs. + // Load contract ABI + abi, err := abi.JSON(strings.NewReader(polygonzkevm.PolygonzkevmABI)) + if err != nil { + return nil, err + } + + // Recover Method from signature and ABI + method, err := abi.MethodById(txData[:4]) + if err != nil { + return nil, err + } + + // Unpack method inputs + data, err := method.Inputs.Unpack(txData[4:]) + if err != nil { + return nil, err + } + + var forceBatches []polygonzkevm.PolygonRollupBaseEtrogBatchData + bytedata, err := json.Marshal(data[0]) + if err != nil { + return nil, err + } + err = json.Unmarshal(bytedata, &forceBatches) + if err != nil { + return nil, err + } + + sequencedForcedBatches := make([]SequencedForceBatch, len(forceBatches)) + for i, force := range forceBatches { + bn := lastBatchNumber - uint64(len(forceBatches)-(i+1)) + sequencedForcedBatches[i] = SequencedForceBatch{ + BatchNumber: bn, + Coinbase: sequencer, + TxHash: txHash, + Timestamp: time.Unix(int64(block.Time()), 0), + Nonce: nonce, + PolygonRollupBaseEtrogBatchData: force, + } + } + return sequencedForcedBatches, nil +} + +func prepareBlock(vLog types.Log, t time.Time, fullBlock *types.Block) Block { + var block Block + block.BlockNumber = vLog.BlockNumber + block.BlockHash = vLog.BlockHash + block.ParentHash = fullBlock.ParentHash() + block.ReceivedAt = t + return block +} + +func hash(data ...[32]byte) [32]byte { + var res [32]byte + hash := sha3.NewLegacyKeccak256() + for _, d := range data { + hash.Write(d[:]) //nolint:errcheck,gosec + } + copy(res[:], hash.Sum(nil)) + return res +} + +// HeaderByNumber returns a block header from the current canonical chain. If number is +// nil, the latest known header is returned. +func (etherMan *Client) HeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error) { + return etherMan.EthClient.HeaderByNumber(ctx, number) +} + +// EthBlockByNumber function retrieves the ethereum block information by ethereum block number. +func (etherMan *Client) EthBlockByNumber(ctx context.Context, blockNumber uint64) (*types.Block, error) { + block, err := etherMan.EthClient.BlockByNumber(ctx, new(big.Int).SetUint64(blockNumber)) + if err != nil { + if errors.Is(err, ethereum.NotFound) || err.Error() == "block does not exist in blockchain" { + return nil, ErrNotFound + } + return nil, err + } + return block, nil +} + +// GetGapLastBatchTimestamp function allows to retrieve the gaplastTimestamp value in the smc +// TODO: If nobody uses this function delete +func (etherMan *Client) GetGapLastBatchTimestamp() (uint64, error) { + return etherMan.ZkEVM.GapLastTimestamp(&bind.CallOpts{Pending: false}) +} + +// GetLatestBatchNumber function allows to retrieve the latest proposed batch in the smc +func (etherMan *Client) GetLatestBatchNumber() (uint64, error) { + rollupData, err := etherMan.RollupManager.RollupIDToRollupData(&bind.CallOpts{Pending: false}, etherMan.RollupID) + if err != nil { + return 0, err + } + return rollupData.LastBatchSequenced, nil +} + +// GetLatestBlockNumber gets the latest block number from the ethereum +func (etherMan *Client) GetLatestBlockNumber(ctx context.Context) (uint64, error) { + return etherMan.getBlockNumber(ctx, rpc.LatestBlockNumber) +} + +// GetSafeBlockNumber gets the safe block number from the ethereum +func (etherMan *Client) GetSafeBlockNumber(ctx context.Context) (uint64, error) { + return etherMan.getBlockNumber(ctx, rpc.SafeBlockNumber) +} + +// GetFinalizedBlockNumber gets the Finalized block number from the ethereum +func (etherMan *Client) GetFinalizedBlockNumber(ctx context.Context) (uint64, error) { + return etherMan.getBlockNumber(ctx, rpc.FinalizedBlockNumber) +} + +// getBlockNumber gets the block header by the provided block number from the ethereum +func (etherMan *Client) getBlockNumber(ctx context.Context, blockNumber rpc.BlockNumber) (uint64, error) { + header, err := etherMan.EthClient.HeaderByNumber(ctx, big.NewInt(int64(blockNumber))) + if err != nil || header == nil { + return 0, err + } + return header.Number.Uint64(), nil +} + +// GetLatestBlockTimestamp gets the latest block timestamp from the ethereum +func (etherMan *Client) GetLatestBlockTimestamp(ctx context.Context) (uint64, error) { + header, err := etherMan.EthClient.HeaderByNumber(ctx, nil) + if err != nil || header == nil { + return 0, err + } + return header.Time, nil +} + +// GetLatestVerifiedBatchNum gets latest verified batch from ethereum +func (etherMan *Client) GetLatestVerifiedBatchNum() (uint64, error) { + rollupData, err := etherMan.RollupManager.RollupIDToRollupData(&bind.CallOpts{Pending: false}, etherMan.RollupID) + if err != nil { + return 0, err + } + return rollupData.LastVerifiedBatch, nil +} + +// GetTx function get ethereum tx +func (etherMan *Client) GetTx(ctx context.Context, txHash common.Hash) (*types.Transaction, bool, error) { + return etherMan.EthClient.TransactionByHash(ctx, txHash) +} + +// GetTxReceipt function gets ethereum tx receipt +func (etherMan *Client) GetTxReceipt(ctx context.Context, txHash common.Hash) (*types.Receipt, error) { + return etherMan.EthClient.TransactionReceipt(ctx, txHash) +} + +// ApprovePol function allow to approve tokens in pol smc +func (etherMan *Client) ApprovePol(ctx context.Context, account common.Address, polAmount *big.Int, to common.Address) (*types.Transaction, error) { + opts, err := etherMan.getAuthByAddress(account) + if err == ErrNotFound { + return nil, errors.New("can't find account private key to sign tx") + } + if etherMan.GasProviders.MultiGasProvider { + opts.GasPrice = etherMan.GetL1GasPrice(ctx) + } + tx, err := etherMan.Pol.Approve(&opts, etherMan.l1Cfg.ZkEVMAddr, polAmount) + if err != nil { + if parsedErr, ok := tryParseError(err); ok { + err = parsedErr + } + return nil, fmt.Errorf("error approving balance to send the batch. Error: %w", err) + } + + return tx, nil +} + +// GetTrustedSequencerURL Gets the trusted sequencer url from rollup smc +func (etherMan *Client) GetTrustedSequencerURL() (string, error) { + return etherMan.ZkEVM.TrustedSequencerURL(&bind.CallOpts{Pending: false}) +} + +// GetL2ChainID returns L2 Chain ID +func (etherMan *Client) GetL2ChainID() (uint64, error) { + chainID, err := etherMan.OldZkEVM.ChainID(&bind.CallOpts{Pending: false}) + log.Debug("chainID read from oldZkevm: ", chainID) + if err != nil || chainID == 0 { + log.Debug("error from oldZkevm: ", err) + rollupData, err := etherMan.RollupManager.RollupIDToRollupData(&bind.CallOpts{Pending: false}, etherMan.RollupID) + log.Debug("chainID read from rollupManager: ", rollupData.ChainID) + if err != nil { + log.Debug("error from rollupManager: ", err) + return 0, err + } else if rollupData.ChainID == 0 { + return rollupData.ChainID, fmt.Errorf("error: chainID received is 0!!") + } + return rollupData.ChainID, nil + } + return chainID, nil +} + +// GetL1GasPrice gets the l1 gas price +func (etherMan *Client) GetL1GasPrice(ctx context.Context) *big.Int { + // Get gasPrice from providers + gasPrice := big.NewInt(0) + for i, prov := range etherMan.GasProviders.Providers { + gp, err := prov.SuggestGasPrice(ctx) + if err != nil { + log.Warnf("error getting gas price from provider %d. Error: %s", i+1, err.Error()) + } else if gasPrice.Cmp(gp) == -1 { // gasPrice < gp + gasPrice = gp + } + } + log.Debug("gasPrice chose: ", gasPrice) + return gasPrice +} + +// SendTx sends a tx to L1 +func (etherMan *Client) SendTx(ctx context.Context, tx *types.Transaction) error { + return etherMan.EthClient.SendTransaction(ctx, tx) +} + +// CurrentNonce returns the current nonce for the provided account +func (etherMan *Client) CurrentNonce(ctx context.Context, account common.Address) (uint64, error) { + return etherMan.EthClient.NonceAt(ctx, account, nil) +} + +// SuggestedGasPrice returns the suggest nonce for the network at the moment +func (etherMan *Client) SuggestedGasPrice(ctx context.Context) (*big.Int, error) { + suggestedGasPrice := etherMan.GetL1GasPrice(ctx) + if suggestedGasPrice.Cmp(big.NewInt(0)) == 0 { + return nil, errors.New("failed to get the suggested gas price") + } + return suggestedGasPrice, nil +} + +// EstimateGas returns the estimated gas for the tx +func (etherMan *Client) EstimateGas(ctx context.Context, from common.Address, to *common.Address, value *big.Int, data []byte) (uint64, error) { + return etherMan.EthClient.EstimateGas(ctx, ethereum.CallMsg{ + From: from, + To: to, + Value: value, + Data: data, + }) +} + +// CheckTxWasMined check if a tx was already mined +func (etherMan *Client) CheckTxWasMined(ctx context.Context, txHash common.Hash) (bool, *types.Receipt, error) { + receipt, err := etherMan.EthClient.TransactionReceipt(ctx, txHash) + if errors.Is(err, ethereum.NotFound) { + return false, nil, nil + } else if err != nil { + return false, nil, err + } + + return true, receipt, nil +} + +// SignTx tries to sign a transaction accordingly to the provided sender +func (etherMan *Client) SignTx(ctx context.Context, sender common.Address, tx *types.Transaction) (*types.Transaction, error) { + auth, err := etherMan.getAuthByAddress(sender) + if err == ErrNotFound { + return nil, ErrPrivateKeyNotFound + } + signedTx, err := auth.Signer(auth.From, tx) + if err != nil { + return nil, err + } + return signedTx, nil +} + +// GetRevertMessage tries to get a revert message of a transaction +func (etherMan *Client) GetRevertMessage(ctx context.Context, tx *types.Transaction) (string, error) { + if tx == nil { + return "", nil + } + + receipt, err := etherMan.GetTxReceipt(ctx, tx.Hash()) + if err != nil { + return "", err + } + + if receipt.Status == types.ReceiptStatusFailed { + revertMessage, err := RevertReason(ctx, etherMan.EthClient, tx, receipt.BlockNumber) + if err != nil { + return "", err + } + return revertMessage, nil + } + return "", nil +} + +// AddOrReplaceAuth adds an authorization or replace an existent one to the same account +func (etherMan *Client) AddOrReplaceAuth(auth bind.TransactOpts) error { + log.Infof("added or replaced authorization for address: %v", auth.From.String()) + etherMan.auth[auth.From] = auth + return nil +} + +// LoadAuthFromKeyStore loads an authorization from a key store file +func (etherMan *Client) LoadAuthFromKeyStore(path, password string) (*bind.TransactOpts, error) { + auth, err := newAuthFromKeystore(path, password, etherMan.l1Cfg.L1ChainID) + if err != nil { + return nil, err + } + + log.Infof("loaded authorization for address: %v", auth.From.String()) + etherMan.auth[auth.From] = auth + return &auth, nil +} + +// newKeyFromKeystore creates an instance of a keystore key from a keystore file +func newKeyFromKeystore(path, password string) (*keystore.Key, error) { + if path == "" && password == "" { + return nil, nil + } + keystoreEncrypted, err := os.ReadFile(filepath.Clean(path)) + if err != nil { + return nil, err + } + log.Infof("decrypting key from: %v", path) + key, err := keystore.DecryptKey(keystoreEncrypted, password) + if err != nil { + return nil, err + } + return key, nil +} + +// newAuthFromKeystore an authorization instance from a keystore file +func newAuthFromKeystore(path, password string, chainID uint64) (bind.TransactOpts, error) { + log.Infof("reading key from: %v", path) + key, err := newKeyFromKeystore(path, password) + if err != nil { + return bind.TransactOpts{}, err + } + if key == nil { + return bind.TransactOpts{}, nil + } + auth, err := bind.NewKeyedTransactorWithChainID(key.PrivateKey, new(big.Int).SetUint64(chainID)) + if err != nil { + return bind.TransactOpts{}, err + } + return *auth, nil +} + +// getAuthByAddress tries to get an authorization from the authorizations map +func (etherMan *Client) getAuthByAddress(addr common.Address) (bind.TransactOpts, error) { + auth, found := etherMan.auth[addr] + if !found { + return bind.TransactOpts{}, ErrNotFound + } + return auth, nil +} + +// generateRandomAuth generates an authorization instance from a +// randomly generated private key to be used to estimate gas for PoE +// operations NOT restricted to the Trusted Sequencer +func (etherMan *Client) generateRandomAuth() (bind.TransactOpts, error) { + privateKey, err := crypto.GenerateKey() + if err != nil { + return bind.TransactOpts{}, errors.New("failed to generate a private key to estimate L1 txs") + } + chainID := big.NewInt(0).SetUint64(etherMan.l1Cfg.L1ChainID) + auth, err := bind.NewKeyedTransactorWithChainID(privateKey, chainID) + if err != nil { + return bind.TransactOpts{}, errors.New("failed to generate a fake authorization to estimate L1 txs") + } + + return *auth, nil +} diff --git a/etherman/etherscan/etherscan.go b/etherman/etherscan/etherscan.go new file mode 100644 index 0000000..5c98a47 --- /dev/null +++ b/etherman/etherscan/etherscan.go @@ -0,0 +1,77 @@ +package etherscan + +import ( + "context" + "encoding/json" + "fmt" + "io" + "math/big" + "net/http" + + "github.com/0xPolygonHermez/zkevm-ethtx-manager/encoding" +) + +type etherscanResponse struct { + Status string `json:"status"` + Message string `json:"message"` + Result gasPriceEtherscan `json:"result"` +} + +// gasPriceEtherscan definition +type gasPriceEtherscan struct { + LastBlock string `json:"LastBlock"` + SafeGasPrice string `json:"SafeGasPrice"` + ProposeGasPrice string `json:"ProposeGasPrice"` + FastGasPrice string `json:"FastGasPrice"` +} + +// Config structure +type Config struct { + // Need API key to use etherscan, if it's empty etherscan is not used + ApiKey string `mapstructure:"ApiKey"` + // URL of the etherscan API. Overwritten with a hardcoded URL: "https://api.etherscan.io/api?module=gastracker&action=gasoracle&apikey=" + Url string +} + +// Client for etherscan +type Client struct { + config Config + Http http.Client +} + +// NewEtherscanService is the constructor that creates an etherscanService +func NewEtherscanService(apikey string) *Client { + const url = "https://api.etherscan.io/api?module=gastracker&action=gasoracle&apikey=" + return &Client{ + config: Config{ + Url: url, + ApiKey: apikey, + }, + Http: http.Client{}, + } +} + +// SuggestGasPrice retrieves the gas price estimation from etherscan +func (e *Client) SuggestGasPrice(ctx context.Context) (*big.Int, error) { + var resBody etherscanResponse + url := e.config.Url + e.config.ApiKey + res, err := e.Http.Get(url) + if err != nil { + return big.NewInt(0), err + } + defer res.Body.Close() + body, err := io.ReadAll(res.Body) + if err != nil { + return big.NewInt(0), err + } + if res.StatusCode != http.StatusOK { + return big.NewInt(0), fmt.Errorf("http response is %d", res.StatusCode) + } + // Unmarshal result + err = json.Unmarshal(body, &resBody) + if err != nil { + return big.NewInt(0), fmt.Errorf("Reading body failed: %w", err) + } + fgp, _ := big.NewInt(0).SetString(resBody.Result.FastGasPrice, encoding.Base10) + return new(big.Int).Mul(fgp, big.NewInt(encoding.Gwei)), nil +} diff --git a/etherman/etherscan/etherscan_test.go b/etherman/etherscan/etherscan_test.go new file mode 100644 index 0000000..537e163 --- /dev/null +++ b/etherman/etherscan/etherscan_test.go @@ -0,0 +1,39 @@ +package etherscan + +import ( + "context" + "fmt" + "math/big" + "net/http" + "net/http/httptest" + "testing" + + "github.com/0xPolygonHermez/zkevm-ethtx-manager/log" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func init() { + log.Init(log.Config{ + Level: "debug", + Outputs: []string{"stderr"}, + }) +} + +func TestGetGasPrice(t *testing.T) { + ctx := context.Background() + data := `{"status":"1","message":"OK","result":{"LastBlock":"15816910","SafeGasPrice":"10","ProposeGasPrice":"11","FastGasPrice":"55","suggestBaseFee":"9.849758735","gasUsedRatio":"0.779364333333333,0.2434028,0.610012833333333,0.1246597,0.995500566666667"}}` + svr := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + fmt.Fprint(w, data) + })) + defer svr.Close() + + apiKey := "" + c := NewEtherscanService(apiKey) + c.config.Url = svr.URL + + gp, err := c.SuggestGasPrice(ctx) + require.NoError(t, err) + log.Debug("Etherscan GasPrice: ", gp) + assert.Equal(t, big.NewInt(55000000000), gp) +} diff --git a/etherman/ethgasstation/ethgasstation.go b/etherman/ethgasstation/ethgasstation.go new file mode 100644 index 0000000..233ec96 --- /dev/null +++ b/etherman/ethgasstation/ethgasstation.go @@ -0,0 +1,64 @@ +package ethgasstation + +import ( + "context" + "encoding/json" + "fmt" + "io" + "math/big" + "net/http" + + "github.com/0xPolygonHermez/zkevm-ethtx-manager/encoding" +) + +type ethGasStationResponse struct { + BaseFee uint64 `json:"baseFee"` + BlockNumber uint64 `json:"blockNumber"` + GasPrice gasPriceEthGasStation `json:"gasPrice"` +} + +// gasPriceEthGasStation definition +type gasPriceEthGasStation struct { + Standard uint64 `json:"standard"` + Instant uint64 `json:"instant"` + Fast uint64 `json:"fast"` +} + +// Client for ethGasStation +type Client struct { + Http http.Client + Url string +} + +// NewEthGasStationService is the constructor that creates an ethGasStationService +func NewEthGasStationService() *Client { + const url = "https://api.ethgasstation.info/api/fee-estimate" + return &Client{ + Http: http.Client{}, + Url: url, + } +} + +// SuggestGasPrice retrieves the gas price estimation from ethGasStation +func (e *Client) SuggestGasPrice(ctx context.Context) (*big.Int, error) { + var resBody ethGasStationResponse + res, err := e.Http.Get(e.Url) + if err != nil { + return big.NewInt(0), err + } + defer res.Body.Close() + body, err := io.ReadAll(res.Body) + if err != nil { + return big.NewInt(0), err + } + if res.StatusCode != http.StatusOK { + return big.NewInt(0), fmt.Errorf("http response is %d", res.StatusCode) + } + // Unmarshal result + err = json.Unmarshal(body, &resBody) + if err != nil { + return big.NewInt(0), fmt.Errorf("Reading body failed: %w", err) + } + fgp := big.NewInt(0).SetUint64(resBody.GasPrice.Instant) + return new(big.Int).Mul(fgp, big.NewInt(encoding.Gwei)), nil +} diff --git a/etherman/ethgasstation/ethgasstation_test.go b/etherman/ethgasstation/ethgasstation_test.go new file mode 100644 index 0000000..4cfa2fd --- /dev/null +++ b/etherman/ethgasstation/ethgasstation_test.go @@ -0,0 +1,37 @@ +package ethgasstation + +import ( + "context" + "fmt" + "math/big" + "net/http" + "net/http/httptest" + "testing" + + "github.com/0xPolygonHermez/zkevm-ethtx-manager/log" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func init() { + log.Init(log.Config{ + Level: "debug", + Outputs: []string{"stderr"}, + }) +} + +func TestGetGasPrice(t *testing.T) { + ctx := context.Background() + data := `{"baseFee":10,"blockNumber":15817089,"blockTime":11.88,"gasPrice":{"fast":11,"instant":66,"standard":10},"nextBaseFee":10,"priorityFee":{"fast":2,"instant":2,"standard":1}}` + svr := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + fmt.Fprint(w, data) + })) + defer svr.Close() + c := NewEthGasStationService() + c.Url = svr.URL + + gp, err := c.SuggestGasPrice(ctx) + require.NoError(t, err) + log.Debug("EthGasStation GasPrice: ", gp) + assert.Equal(t, big.NewInt(66000000000), gp) +} diff --git a/etherman/metrics/metrics.go b/etherman/metrics/metrics.go new file mode 100644 index 0000000..1e293c7 --- /dev/null +++ b/etherman/metrics/metrics.go @@ -0,0 +1,120 @@ +package metrics + +import ( + "time" + + "github.com/0xPolygonHermez/zkevm-ethtx-manager/metrics" + "github.com/prometheus/client_golang/prometheus" +) + +const ( + // Prefix for the metrics of the etherman package. + Prefix = "etherman_" + + // ReadAndProcessAllEventsTimeName is the name of the label read and process all event. + ReadAndProcessAllEventsTimeName = Prefix + "read_and_process_all_event_time" + + // ProcessAllEventTimeName is the name of the label to process all event. + ProcessAllEventTimeName = Prefix + "process_all_event_time" + + // ProcessSingleEventTimeName is the name of the label to process a single event. + ProcessSingleEventTimeName = Prefix + "process_single_event_time" + + // GetEventsTimeName is the name of the label to get L1 events. + GetEventsTimeName = Prefix + "get_events_time" + + // GetForksTimeName is the name of the label to get forkIDs intervals. + GetForksTimeName = Prefix + "get_forkIDs_time" + + // VerifyGenBlockTimeName is the name of the label to verify the genesis block. + VerifyGenBlockTimeName = Prefix + "verify_genesisBlockNum_time" + + // EventCounterName is the name of the label to count the processed events. + EventCounterName = Prefix + "processed_events_counter" +) + +// Register the metrics for the etherman package. +func Register() { + var ( + counters []prometheus.CounterOpts + histograms []prometheus.HistogramOpts + ) + + counters = []prometheus.CounterOpts{ + { + Name: EventCounterName, + Help: "[ETHERMAN] count processed events", + }, + } + + histograms = []prometheus.HistogramOpts{ + { + Name: ReadAndProcessAllEventsTimeName, + Help: "[ETHERMAN] read and process all event time", + }, + { + Name: ProcessAllEventTimeName, + Help: "[ETHERMAN] process all event time", + }, + { + Name: ProcessSingleEventTimeName, + Help: "[ETHERMAN] process single event time", + }, + { + Name: GetEventsTimeName, + Help: "[ETHERMAN] get L1 events time", + }, + { + Name: GetForksTimeName, + Help: "[ETHERMAN] get forkIDs time", + }, + { + Name: VerifyGenBlockTimeName, + Help: "[ETHERMAN] verify genesis block number time", + }, + } + + metrics.RegisterCounters(counters...) + metrics.RegisterHistograms(histograms...) +} + +// ReadAndProcessAllEventsTime observes the time read and process all event on the histogram. +func ReadAndProcessAllEventsTime(lastProcessTime time.Duration) { + execTimeInSeconds := float64(lastProcessTime) / float64(time.Second) + metrics.HistogramObserve(ReadAndProcessAllEventsTimeName, execTimeInSeconds) +} + +// ProcessAllEventTime observes the time to process all event on the histogram. +func ProcessAllEventTime(lastProcessTime time.Duration) { + execTimeInSeconds := float64(lastProcessTime) / float64(time.Second) + metrics.HistogramObserve(ProcessAllEventTimeName, execTimeInSeconds) +} + +// ProcessSingleEventTime observes the time to process a single event on the histogram. +func ProcessSingleEventTime(lastProcessTime time.Duration) { + execTimeInSeconds := float64(lastProcessTime) / float64(time.Second) + metrics.HistogramObserve(ProcessSingleEventTimeName, execTimeInSeconds) +} + +// GetEventsTime observes the time to get the events from L1 on the histogram. +func GetEventsTime(lastProcessTime time.Duration) { + execTimeInSeconds := float64(lastProcessTime) / float64(time.Second) + metrics.HistogramObserve(GetEventsTimeName, execTimeInSeconds) +} + +// GetForksTime observes the time to get the forkIDs on the histogram. +func GetForksTime(lastProcessTime time.Duration) { + execTimeInSeconds := float64(lastProcessTime) / float64(time.Second) + metrics.HistogramObserve(GetForksTimeName, execTimeInSeconds) +} + +// VerifyGenBlockTime observes the time for etherman to verify the genesis blocknumber on the histogram. +func VerifyGenBlockTime(lastProcessTime time.Duration) { + execTimeInSeconds := float64(lastProcessTime) / float64(time.Second) + metrics.HistogramObserve(VerifyGenBlockTimeName, execTimeInSeconds) +} + +// EventCounter increases the counter for the processed events +func EventCounter() { + metrics.CounterInc(EventCounterName) +} diff --git a/etherman/smartcontracts/abi/mockpolygonrollupmanager.abi b/etherman/smartcontracts/abi/mockpolygonrollupmanager.abi new file mode 100644 index 0000000..5e6c372 --- /dev/null +++ b/etherman/smartcontracts/abi/mockpolygonrollupmanager.abi @@ -0,0 +1,1983 @@ +[ + { + "inputs": [ + { + "internalType": "contract IPolygonZkEVMGlobalExitRoot", + "name": "_globalExitRootManager", + "type": "address" + }, + { + "internalType": "contract IERC20Upgradeable", + "name": "_pol", + "type": "address" + }, + { + "internalType": "contract IPolygonZkEVMBridge", + "name": "_bridgeAddress", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "constructor" + }, + { + "inputs": [], + "name": "AccessControlOnlyCanRenounceRolesForSelf", + "type": "error" + }, + { + "inputs": [], + "name": "AddressDoNotHaveRequiredRole", + "type": "error" + }, + { + "inputs": [], + "name": "AllzkEVMSequencedBatchesMustBeVerified", + "type": "error" + }, + { + "inputs": [], + "name": "BatchFeeOutOfRange", + "type": "error" + }, + { + "inputs": [], + "name": "ChainIDAlreadyExist", + "type": "error" + }, + { + "inputs": [], + "name": "ExceedMaxVerifyBatches", + "type": "error" + }, + { + "inputs": [], + "name": "FinalNumBatchBelowLastVerifiedBatch", + "type": "error" + }, + { + "inputs": [], + "name": "FinalNumBatchDoesNotMatchPendingState", + "type": "error" + }, + { + "inputs": [], + "name": "FinalPendingStateNumInvalid", + "type": "error" + }, + { + "inputs": [], + "name": "HaltTimeoutNotExpired", + "type": "error" + }, + { + "inputs": [], + "name": "InitBatchMustMatchCurrentForkID", + "type": "error" + }, + { + "inputs": [], + "name": "InitNumBatchAboveLastVerifiedBatch", + "type": "error" + }, + { + "inputs": [], + "name": "InitNumBatchDoesNotMatchPendingState", + "type": "error" + }, + { + "inputs": [], + "name": "InvalidProof", + "type": "error" + }, + { + "inputs": [], + "name": "InvalidRangeBatchTimeTarget", + "type": "error" + }, + { + "inputs": [], + "name": "InvalidRangeMultiplierBatchFee", + "type": "error" + }, + { + "inputs": [], + "name": "MustSequenceSomeBatch", + "type": "error" + }, + { + "inputs": [], + "name": "NewAccInputHashDoesNotExist", + "type": "error" + }, + { + "inputs": [], + "name": "NewPendingStateTimeoutMustBeLower", + "type": "error" + }, + { + "inputs": [], + "name": "NewStateRootNotInsidePrime", + "type": "error" + }, + { + "inputs": [], + "name": "NewTrustedAggregatorTimeoutMustBeLower", + "type": "error" + }, + { + "inputs": [], + "name": "OldAccInputHashDoesNotExist", + "type": "error" + }, + { + "inputs": [], + "name": "OldStateRootDoesNotExist", + "type": "error" + }, + { + "inputs": [], + "name": "OnlyEmergencyState", + "type": "error" + }, + { + "inputs": [], + "name": "OnlyNotEmergencyState", + "type": "error" + }, + { + "inputs": [], + "name": "PendingStateDoesNotExist", + "type": "error" + }, + { + "inputs": [], + "name": "PendingStateInvalid", + "type": "error" + }, + { + "inputs": [], + "name": "PendingStateNotConsolidable", + "type": "error" + }, + { + "inputs": [], + "name": "RollupMustExist", + "type": "error" + }, + { + "inputs": [], + "name": "RollupTypeDoesNotExist", + "type": "error" + }, + { + "inputs": [], + "name": "RollupTypeObsolete", + "type": "error" + }, + { + "inputs": [], + "name": "SenderMustBeRollup", + "type": "error" + }, + { + "inputs": [], + "name": "StoredRootMustBeDifferentThanNewRoot", + "type": "error" + }, + { + "inputs": [], + "name": "TrustedAggregatorTimeoutNotExpired", + "type": "error" + }, + { + "inputs": [], + "name": "UpdateNotCompatible", + "type": "error" + }, + { + "inputs": [], + "name": "UpdateToSameRollupTypeID", + "type": "error" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint32", + "name": "rollupID", + "type": "uint32" + }, + { + "indexed": false, + "internalType": "uint64", + "name": "forkID", + "type": "uint64" + }, + { + "indexed": false, + "internalType": "address", + "name": "rollupAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint64", + "name": "chainID", + "type": "uint64" + }, + { + "indexed": false, + "internalType": "uint8", + "name": "rollupCompatibilityID", + "type": "uint8" + }, + { + "indexed": false, + "internalType": "uint64", + "name": "lastVerifiedBatchBeforeUpgrade", + "type": "uint64" + } + ], + "name": "AddExistingRollup", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint32", + "name": "rollupTypeID", + "type": "uint32" + }, + { + "indexed": false, + "internalType": "address", + "name": "consensusImplementation", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "verifier", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint64", + "name": "forkID", + "type": "uint64" + }, + { + "indexed": false, + "internalType": "uint8", + "name": "rollupCompatibilityID", + "type": "uint8" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "genesis", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "string", + "name": "description", + "type": "string" + } + ], + "name": "AddNewRollupType", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint32", + "name": "rollupID", + "type": "uint32" + }, + { + "indexed": false, + "internalType": "uint64", + "name": "numBatch", + "type": "uint64" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "stateRoot", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "exitRoot", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "uint64", + "name": "pendingStateNum", + "type": "uint64" + } + ], + "name": "ConsolidatePendingState", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint32", + "name": "rollupID", + "type": "uint32" + }, + { + "indexed": false, + "internalType": "uint32", + "name": "rollupTypeID", + "type": "uint32" + }, + { + "indexed": false, + "internalType": "address", + "name": "rollupAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint64", + "name": "chainID", + "type": "uint64" + }, + { + "indexed": false, + "internalType": "address", + "name": "gasTokenAddress", + "type": "address" + } + ], + "name": "CreateNewRollup", + "type": "event" + }, + { + "anonymous": false, + "inputs": [], + "name": "EmergencyStateActivated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [], + "name": "EmergencyStateDeactivated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "uint8", + "name": "version", + "type": "uint8" + } + ], + "name": "Initialized", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint32", + "name": "rollupTypeID", + "type": "uint32" + } + ], + "name": "ObsoleteRollupType", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint32", + "name": "rollupID", + "type": "uint32" + }, + { + "indexed": false, + "internalType": "uint64", + "name": "lastBatchSequenced", + "type": "uint64" + } + ], + "name": "OnSequenceBatches", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint32", + "name": "rollupID", + "type": "uint32" + }, + { + "indexed": false, + "internalType": "uint64", + "name": "numBatch", + "type": "uint64" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "stateRoot", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "exitRoot", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "OverridePendingState", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bytes32", + "name": "storedStateRoot", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "provedStateRoot", + "type": "bytes32" + } + ], + "name": "ProveNonDeterministicPendingState", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "role", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "previousAdminRole", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "newAdminRole", + "type": "bytes32" + } + ], + "name": "RoleAdminChanged", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "role", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "account", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "RoleGranted", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "role", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "account", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "RoleRevoked", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "uint256", + "name": "newBatchFee", + "type": "uint256" + } + ], + "name": "SetBatchFee", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "uint16", + "name": "newMultiplierBatchFee", + "type": "uint16" + } + ], + "name": "SetMultiplierBatchFee", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "uint64", + "name": "newPendingStateTimeout", + "type": "uint64" + } + ], + "name": "SetPendingStateTimeout", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "newTrustedAggregator", + "type": "address" + } + ], + "name": "SetTrustedAggregator", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "uint64", + "name": "newTrustedAggregatorTimeout", + "type": "uint64" + } + ], + "name": "SetTrustedAggregatorTimeout", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "uint64", + "name": "newVerifyBatchTimeTarget", + "type": "uint64" + } + ], + "name": "SetVerifyBatchTimeTarget", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint32", + "name": "rollupID", + "type": "uint32" + }, + { + "indexed": false, + "internalType": "uint32", + "name": "newRollupTypeID", + "type": "uint32" + }, + { + "indexed": false, + "internalType": "uint64", + "name": "lastVerifiedBatchBeforeUpgrade", + "type": "uint64" + } + ], + "name": "UpdateRollup", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint32", + "name": "rollupID", + "type": "uint32" + }, + { + "indexed": false, + "internalType": "uint64", + "name": "numBatch", + "type": "uint64" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "stateRoot", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "exitRoot", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "VerifyBatches", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint32", + "name": "rollupID", + "type": "uint32" + }, + { + "indexed": false, + "internalType": "uint64", + "name": "numBatch", + "type": "uint64" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "stateRoot", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "exitRoot", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "VerifyBatchesTrustedAggregator", + "type": "event" + }, + { + "inputs": [], + "name": "DEFAULT_ADMIN_ROLE", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "activateEmergencyState", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract IPolygonRollupBase", + "name": "rollupAddress", + "type": "address" + }, + { + "internalType": "contract IVerifierRollup", + "name": "verifier", + "type": "address" + }, + { + "internalType": "uint64", + "name": "forkID", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "chainID", + "type": "uint64" + }, + { + "internalType": "bytes32", + "name": "genesis", + "type": "bytes32" + }, + { + "internalType": "uint8", + "name": "rollupCompatibilityID", + "type": "uint8" + } + ], + "name": "addExistingRollup", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "consensusImplementation", + "type": "address" + }, + { + "internalType": "contract IVerifierRollup", + "name": "verifier", + "type": "address" + }, + { + "internalType": "uint64", + "name": "forkID", + "type": "uint64" + }, + { + "internalType": "uint8", + "name": "rollupCompatibilityID", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "genesis", + "type": "bytes32" + }, + { + "internalType": "string", + "name": "description", + "type": "string" + } + ], + "name": "addNewRollupType", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "bridgeAddress", + "outputs": [ + { + "internalType": "contract IPolygonZkEVMBridge", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "calculateRewardPerBatch", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint64", + "name": "chainID", + "type": "uint64" + } + ], + "name": "chainIDToRollupID", + "outputs": [ + { + "internalType": "uint32", + "name": "rollupID", + "type": "uint32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint32", + "name": "rollupID", + "type": "uint32" + }, + { + "internalType": "uint64", + "name": "pendingStateNum", + "type": "uint64" + } + ], + "name": "consolidatePendingState", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint32", + "name": "rollupTypeID", + "type": "uint32" + }, + { + "internalType": "uint64", + "name": "chainID", + "type": "uint64" + }, + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "internalType": "address", + "name": "sequencer", + "type": "address" + }, + { + "internalType": "address", + "name": "gasTokenAddress", + "type": "address" + }, + { + "internalType": "string", + "name": "sequencerURL", + "type": "string" + }, + { + "internalType": "string", + "name": "networkName", + "type": "string" + } + ], + "name": "createNewRollup", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "deactivateEmergencyState", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getBatchFee", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "getForcedBatchFee", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint32", + "name": "rollupID", + "type": "uint32" + }, + { + "internalType": "uint64", + "name": "initNumBatch", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "finalNewBatch", + "type": "uint64" + }, + { + "internalType": "bytes32", + "name": "newLocalExitRoot", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "oldStateRoot", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "newStateRoot", + "type": "bytes32" + } + ], + "name": "getInputSnarkBytes", + "outputs": [ + { + "internalType": "bytes", + "name": "", + "type": "bytes" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint32", + "name": "rollupID", + "type": "uint32" + } + ], + "name": "getLastVerifiedBatch", + "outputs": [ + { + "internalType": "uint64", + "name": "", + "type": "uint64" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "role", + "type": "bytes32" + } + ], + "name": "getRoleAdmin", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint32", + "name": "rollupID", + "type": "uint32" + }, + { + "internalType": "uint64", + "name": "batchNum", + "type": "uint64" + } + ], + "name": "getRollupBatchNumToStateRoot", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "getRollupExitRoot", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint32", + "name": "rollupID", + "type": "uint32" + }, + { + "internalType": "uint64", + "name": "batchNum", + "type": "uint64" + } + ], + "name": "getRollupPendingStateTransitions", + "outputs": [ + { + "components": [ + { + "internalType": "uint64", + "name": "timestamp", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "lastVerifiedBatch", + "type": "uint64" + }, + { + "internalType": "bytes32", + "name": "exitRoot", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "stateRoot", + "type": "bytes32" + } + ], + "internalType": "struct LegacyZKEVMStateVariables.PendingState", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint32", + "name": "rollupID", + "type": "uint32" + }, + { + "internalType": "uint64", + "name": "batchNum", + "type": "uint64" + } + ], + "name": "getRollupSequencedBatches", + "outputs": [ + { + "components": [ + { + "internalType": "bytes32", + "name": "accInputHash", + "type": "bytes32" + }, + { + "internalType": "uint64", + "name": "sequencedTimestamp", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "previousLastBatchSequenced", + "type": "uint64" + } + ], + "internalType": "struct LegacyZKEVMStateVariables.SequencedBatchData", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "globalExitRootManager", + "outputs": [ + { + "internalType": "contract IPolygonZkEVMGlobalExitRoot", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "role", + "type": "bytes32" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "grantRole", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "role", + "type": "bytes32" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasRole", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "trustedAggregator", + "type": "address" + }, + { + "internalType": "uint64", + "name": "_pendingStateTimeout", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "_trustedAggregatorTimeout", + "type": "uint64" + }, + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "internalType": "address", + "name": "timelock", + "type": "address" + }, + { + "internalType": "address", + "name": "emergencyCouncil", + "type": "address" + }, + { + "internalType": "contract PolygonZkEVMV2Existent", + "name": "polygonZkEVM", + "type": "address" + }, + { + "internalType": "contract IVerifierRollup", + "name": "zkEVMVerifier", + "type": "address" + }, + { + "internalType": "uint64", + "name": "zkEVMForkID", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "zkEVMChainID", + "type": "uint64" + } + ], + "name": "initialize", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "trustedAggregator", + "type": "address" + }, + { + "internalType": "uint64", + "name": "_pendingStateTimeout", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "_trustedAggregatorTimeout", + "type": "uint64" + }, + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "internalType": "address", + "name": "timelock", + "type": "address" + }, + { + "internalType": "address", + "name": "emergencyCouncil", + "type": "address" + } + ], + "name": "initializeMock", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "isEmergencyState", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint32", + "name": "rollupID", + "type": "uint32" + }, + { + "internalType": "uint64", + "name": "pendingStateNum", + "type": "uint64" + } + ], + "name": "isPendingStateConsolidable", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "lastAggregationTimestamp", + "outputs": [ + { + "internalType": "uint64", + "name": "", + "type": "uint64" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "multiplierBatchFee", + "outputs": [ + { + "internalType": "uint16", + "name": "", + "type": "uint16" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint32", + "name": "rollupTypeID", + "type": "uint32" + } + ], + "name": "obsoleteRollupType", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint64", + "name": "newSequencedBatches", + "type": "uint64" + }, + { + "internalType": "bytes32", + "name": "newAccInputHash", + "type": "bytes32" + } + ], + "name": "onSequenceBatches", + "outputs": [ + { + "internalType": "uint64", + "name": "", + "type": "uint64" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint32", + "name": "rollupID", + "type": "uint32" + }, + { + "internalType": "uint64", + "name": "initPendingStateNum", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "finalPendingStateNum", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "initNumBatch", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "finalNewBatch", + "type": "uint64" + }, + { + "internalType": "bytes32", + "name": "newLocalExitRoot", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "newStateRoot", + "type": "bytes32" + }, + { + "internalType": "bytes32[24]", + "name": "proof", + "type": "bytes32[24]" + } + ], + "name": "overridePendingState", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "pendingStateTimeout", + "outputs": [ + { + "internalType": "uint64", + "name": "", + "type": "uint64" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "pol", + "outputs": [ + { + "internalType": "contract IERC20Upgradeable", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint32", + "name": "rollupID", + "type": "uint32" + }, + { + "internalType": "uint64", + "name": "initPendingStateNum", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "finalPendingStateNum", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "initNumBatch", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "finalNewBatch", + "type": "uint64" + }, + { + "internalType": "bytes32", + "name": "newLocalExitRoot", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "newStateRoot", + "type": "bytes32" + }, + { + "internalType": "bytes32[24]", + "name": "proof", + "type": "bytes32[24]" + } + ], + "name": "proveNonDeterministicPendingState", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "role", + "type": "bytes32" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "renounceRole", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "role", + "type": "bytes32" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "revokeRole", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "rollupAddress", + "type": "address" + } + ], + "name": "rollupAddressToID", + "outputs": [ + { + "internalType": "uint32", + "name": "rollupID", + "type": "uint32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "rollupCount", + "outputs": [ + { + "internalType": "uint32", + "name": "", + "type": "uint32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint32", + "name": "rollupID", + "type": "uint32" + } + ], + "name": "rollupIDToRollupData", + "outputs": [ + { + "internalType": "contract IPolygonRollupBase", + "name": "rollupContract", + "type": "address" + }, + { + "internalType": "uint64", + "name": "chainID", + "type": "uint64" + }, + { + "internalType": "contract IVerifierRollup", + "name": "verifier", + "type": "address" + }, + { + "internalType": "uint64", + "name": "forkID", + "type": "uint64" + }, + { + "internalType": "bytes32", + "name": "lastLocalExitRoot", + "type": "bytes32" + }, + { + "internalType": "uint64", + "name": "lastBatchSequenced", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "lastVerifiedBatch", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "lastPendingState", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "lastPendingStateConsolidated", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "lastVerifiedBatchBeforeUpgrade", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "rollupTypeID", + "type": "uint64" + }, + { + "internalType": "uint8", + "name": "rollupCompatibilityID", + "type": "uint8" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "rollupTypeCount", + "outputs": [ + { + "internalType": "uint32", + "name": "", + "type": "uint32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint32", + "name": "rollupTypeID", + "type": "uint32" + } + ], + "name": "rollupTypeMap", + "outputs": [ + { + "internalType": "address", + "name": "consensusImplementation", + "type": "address" + }, + { + "internalType": "contract IVerifierRollup", + "name": "verifier", + "type": "address" + }, + { + "internalType": "uint64", + "name": "forkID", + "type": "uint64" + }, + { + "internalType": "uint8", + "name": "rollupCompatibilityID", + "type": "uint8" + }, + { + "internalType": "bool", + "name": "obsolete", + "type": "bool" + }, + { + "internalType": "bytes32", + "name": "genesis", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "newBatchFee", + "type": "uint256" + } + ], + "name": "setBatchFee", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint16", + "name": "newMultiplierBatchFee", + "type": "uint16" + } + ], + "name": "setMultiplierBatchFee", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint64", + "name": "newPendingStateTimeout", + "type": "uint64" + } + ], + "name": "setPendingStateTimeout", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint64", + "name": "newTrustedAggregatorTimeout", + "type": "uint64" + } + ], + "name": "setTrustedAggregatorTimeout", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint64", + "name": "newVerifyBatchTimeTarget", + "type": "uint64" + } + ], + "name": "setVerifyBatchTimeTarget", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "totalSequencedBatches", + "outputs": [ + { + "internalType": "uint64", + "name": "", + "type": "uint64" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "totalVerifiedBatches", + "outputs": [ + { + "internalType": "uint64", + "name": "", + "type": "uint64" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "trustedAggregatorTimeout", + "outputs": [ + { + "internalType": "uint64", + "name": "", + "type": "uint64" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract ITransparentUpgradeableProxy", + "name": "rollupContract", + "type": "address" + }, + { + "internalType": "uint32", + "name": "newRollupTypeID", + "type": "uint32" + }, + { + "internalType": "bytes", + "name": "upgradeData", + "type": "bytes" + } + ], + "name": "updateRollup", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "verifyBatchTimeTarget", + "outputs": [ + { + "internalType": "uint64", + "name": "", + "type": "uint64" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint32", + "name": "rollupID", + "type": "uint32" + }, + { + "internalType": "uint64", + "name": "pendingStateNum", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "initNumBatch", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "finalNewBatch", + "type": "uint64" + }, + { + "internalType": "bytes32", + "name": "newLocalExitRoot", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "newStateRoot", + "type": "bytes32" + }, + { + "internalType": "address", + "name": "beneficiary", + "type": "address" + }, + { + "internalType": "bytes32[24]", + "name": "proof", + "type": "bytes32[24]" + } + ], + "name": "verifyBatches", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint32", + "name": "rollupID", + "type": "uint32" + }, + { + "internalType": "uint64", + "name": "pendingStateNum", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "initNumBatch", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "finalNewBatch", + "type": "uint64" + }, + { + "internalType": "bytes32", + "name": "newLocalExitRoot", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "newStateRoot", + "type": "bytes32" + }, + { + "internalType": "address", + "name": "beneficiary", + "type": "address" + }, + { + "internalType": "bytes32[24]", + "name": "proof", + "type": "bytes32[24]" + } + ], + "name": "verifyBatchesTrustedAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } +] \ No newline at end of file diff --git a/etherman/smartcontracts/abi/mockverifier.abi b/etherman/smartcontracts/abi/mockverifier.abi new file mode 100644 index 0000000..2c532b8 --- /dev/null +++ b/etherman/smartcontracts/abi/mockverifier.abi @@ -0,0 +1,26 @@ +[ + { + "inputs": [ + { + "internalType": "bytes32[24]", + "name": "proof", + "type": "bytes32[24]" + }, + { + "internalType": "uint256[1]", + "name": "pubSignals", + "type": "uint256[1]" + } + ], + "name": "verifyProof", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "pure", + "type": "function" + } +] \ No newline at end of file diff --git a/etherman/smartcontracts/abi/oldpolygonzkevm.abi b/etherman/smartcontracts/abi/oldpolygonzkevm.abi new file mode 100644 index 0000000..3007afc --- /dev/null +++ b/etherman/smartcontracts/abi/oldpolygonzkevm.abi @@ -0,0 +1,1709 @@ +[ + { + "inputs": [ + { + "internalType": "contract IPolygonZkEVMGlobalExitRoot", + "name": "_globalExitRootManager", + "type": "address" + }, + { + "internalType": "contract IERC20Upgradeable", + "name": "_matic", + "type": "address" + }, + { + "internalType": "contract IVerifierRollup", + "name": "_rollupVerifier", + "type": "address" + }, + { + "internalType": "contract IPolygonZkEVMBridge", + "name": "_bridgeAddress", + "type": "address" + }, + { + "internalType": "uint64", + "name": "_chainID", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "_forkID", + "type": "uint64" + } + ], + "stateMutability": "nonpayable", + "type": "constructor" + }, + { + "inputs": [], + "name": "BatchAlreadyVerified", + "type": "error" + }, + { + "inputs": [], + "name": "BatchNotSequencedOrNotSequenceEnd", + "type": "error" + }, + { + "inputs": [], + "name": "ExceedMaxVerifyBatches", + "type": "error" + }, + { + "inputs": [], + "name": "FinalNumBatchBelowLastVerifiedBatch", + "type": "error" + }, + { + "inputs": [], + "name": "FinalNumBatchDoesNotMatchPendingState", + "type": "error" + }, + { + "inputs": [], + "name": "FinalPendingStateNumInvalid", + "type": "error" + }, + { + "inputs": [], + "name": "ForceBatchNotAllowed", + "type": "error" + }, + { + "inputs": [], + "name": "ForceBatchTimeoutNotExpired", + "type": "error" + }, + { + "inputs": [], + "name": "ForceBatchesAlreadyActive", + "type": "error" + }, + { + "inputs": [], + "name": "ForceBatchesOverflow", + "type": "error" + }, + { + "inputs": [], + "name": "ForcedDataDoesNotMatch", + "type": "error" + }, + { + "inputs": [], + "name": "GlobalExitRootNotExist", + "type": "error" + }, + { + "inputs": [], + "name": "HaltTimeoutNotExpired", + "type": "error" + }, + { + "inputs": [], + "name": "InitNumBatchAboveLastVerifiedBatch", + "type": "error" + }, + { + "inputs": [], + "name": "InitNumBatchDoesNotMatchPendingState", + "type": "error" + }, + { + "inputs": [], + "name": "InvalidProof", + "type": "error" + }, + { + "inputs": [], + "name": "InvalidRangeBatchTimeTarget", + "type": "error" + }, + { + "inputs": [], + "name": "InvalidRangeForceBatchTimeout", + "type": "error" + }, + { + "inputs": [], + "name": "InvalidRangeMultiplierBatchFee", + "type": "error" + }, + { + "inputs": [], + "name": "NewAccInputHashDoesNotExist", + "type": "error" + }, + { + "inputs": [], + "name": "NewPendingStateTimeoutMustBeLower", + "type": "error" + }, + { + "inputs": [], + "name": "NewStateRootNotInsidePrime", + "type": "error" + }, + { + "inputs": [], + "name": "NewTrustedAggregatorTimeoutMustBeLower", + "type": "error" + }, + { + "inputs": [], + "name": "NotEnoughMaticAmount", + "type": "error" + }, + { + "inputs": [], + "name": "OldAccInputHashDoesNotExist", + "type": "error" + }, + { + "inputs": [], + "name": "OldStateRootDoesNotExist", + "type": "error" + }, + { + "inputs": [], + "name": "OnlyAdmin", + "type": "error" + }, + { + "inputs": [], + "name": "OnlyEmergencyState", + "type": "error" + }, + { + "inputs": [], + "name": "OnlyNotEmergencyState", + "type": "error" + }, + { + "inputs": [], + "name": "OnlyPendingAdmin", + "type": "error" + }, + { + "inputs": [], + "name": "OnlyTrustedAggregator", + "type": "error" + }, + { + "inputs": [], + "name": "OnlyTrustedSequencer", + "type": "error" + }, + { + "inputs": [], + "name": "PendingStateDoesNotExist", + "type": "error" + }, + { + "inputs": [], + "name": "PendingStateInvalid", + "type": "error" + }, + { + "inputs": [], + "name": "PendingStateNotConsolidable", + "type": "error" + }, + { + "inputs": [], + "name": "PendingStateTimeoutExceedHaltAggregationTimeout", + "type": "error" + }, + { + "inputs": [], + "name": "SequenceZeroBatches", + "type": "error" + }, + { + "inputs": [], + "name": "SequencedTimestampBelowForcedTimestamp", + "type": "error" + }, + { + "inputs": [], + "name": "SequencedTimestampInvalid", + "type": "error" + }, + { + "inputs": [], + "name": "StoredRootMustBeDifferentThanNewRoot", + "type": "error" + }, + { + "inputs": [], + "name": "TransactionsLengthAboveMax", + "type": "error" + }, + { + "inputs": [], + "name": "TrustedAggregatorTimeoutExceedHaltAggregationTimeout", + "type": "error" + }, + { + "inputs": [], + "name": "TrustedAggregatorTimeoutNotExpired", + "type": "error" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "newAdmin", + "type": "address" + } + ], + "name": "AcceptAdminRole", + "type": "event" + }, + { + "anonymous": false, + "inputs": [], + "name": "ActivateForceBatches", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint64", + "name": "numBatch", + "type": "uint64" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "stateRoot", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "uint64", + "name": "pendingStateNum", + "type": "uint64" + } + ], + "name": "ConsolidatePendingState", + "type": "event" + }, + { + "anonymous": false, + "inputs": [], + "name": "EmergencyStateActivated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [], + "name": "EmergencyStateDeactivated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint64", + "name": "forceBatchNum", + "type": "uint64" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "lastGlobalExitRoot", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sequencer", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "transactions", + "type": "bytes" + } + ], + "name": "ForceBatch", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "uint8", + "name": "version", + "type": "uint8" + } + ], + "name": "Initialized", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint64", + "name": "numBatch", + "type": "uint64" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "stateRoot", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "OverridePendingState", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bytes32", + "name": "storedStateRoot", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "provedStateRoot", + "type": "bytes32" + } + ], + "name": "ProveNonDeterministicPendingState", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint64", + "name": "numBatch", + "type": "uint64" + } + ], + "name": "SequenceBatches", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint64", + "name": "numBatch", + "type": "uint64" + } + ], + "name": "SequenceForceBatches", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "uint64", + "name": "newforceBatchTimeout", + "type": "uint64" + } + ], + "name": "SetForceBatchTimeout", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "uint16", + "name": "newMultiplierBatchFee", + "type": "uint16" + } + ], + "name": "SetMultiplierBatchFee", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "uint64", + "name": "newPendingStateTimeout", + "type": "uint64" + } + ], + "name": "SetPendingStateTimeout", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "newTrustedAggregator", + "type": "address" + } + ], + "name": "SetTrustedAggregator", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "uint64", + "name": "newTrustedAggregatorTimeout", + "type": "uint64" + } + ], + "name": "SetTrustedAggregatorTimeout", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "newTrustedSequencer", + "type": "address" + } + ], + "name": "SetTrustedSequencer", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "string", + "name": "newTrustedSequencerURL", + "type": "string" + } + ], + "name": "SetTrustedSequencerURL", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "uint64", + "name": "newVerifyBatchTimeTarget", + "type": "uint64" + } + ], + "name": "SetVerifyBatchTimeTarget", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "newPendingAdmin", + "type": "address" + } + ], + "name": "TransferAdminRole", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "uint64", + "name": "numBatch", + "type": "uint64" + }, + { + "indexed": false, + "internalType": "uint64", + "name": "forkID", + "type": "uint64" + }, + { + "indexed": false, + "internalType": "string", + "name": "version", + "type": "string" + } + ], + "name": "UpdateZkEVMVersion", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint64", + "name": "numBatch", + "type": "uint64" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "stateRoot", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "VerifyBatches", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint64", + "name": "numBatch", + "type": "uint64" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "stateRoot", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "VerifyBatchesTrustedAggregator", + "type": "event" + }, + { + "inputs": [], + "name": "acceptAdminRole", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint64", + "name": "sequencedBatchNum", + "type": "uint64" + } + ], + "name": "activateEmergencyState", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "activateForceBatches", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "admin", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "batchFee", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint64", + "name": "", + "type": "uint64" + } + ], + "name": "batchNumToStateRoot", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "bridgeAddress", + "outputs": [ + { + "internalType": "contract IPolygonZkEVMBridge", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "calculateRewardPerBatch", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "chainID", + "outputs": [ + { + "internalType": "uint64", + "name": "", + "type": "uint64" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "newStateRoot", + "type": "uint256" + } + ], + "name": "checkStateRootInsidePrime", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "pure", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint64", + "name": "pendingStateNum", + "type": "uint64" + } + ], + "name": "consolidatePendingState", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "deactivateEmergencyState", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes", + "name": "transactions", + "type": "bytes" + }, + { + "internalType": "uint256", + "name": "maticAmount", + "type": "uint256" + } + ], + "name": "forceBatch", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "forceBatchTimeout", + "outputs": [ + { + "internalType": "uint64", + "name": "", + "type": "uint64" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint64", + "name": "", + "type": "uint64" + } + ], + "name": "forcedBatches", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "forkID", + "outputs": [ + { + "internalType": "uint64", + "name": "", + "type": "uint64" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "getForcedBatchFee", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint64", + "name": "initNumBatch", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "finalNewBatch", + "type": "uint64" + }, + { + "internalType": "bytes32", + "name": "newLocalExitRoot", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "oldStateRoot", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "newStateRoot", + "type": "bytes32" + } + ], + "name": "getInputSnarkBytes", + "outputs": [ + { + "internalType": "bytes", + "name": "", + "type": "bytes" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "getLastVerifiedBatch", + "outputs": [ + { + "internalType": "uint64", + "name": "", + "type": "uint64" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "globalExitRootManager", + "outputs": [ + { + "internalType": "contract IPolygonZkEVMGlobalExitRoot", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "internalType": "address", + "name": "trustedSequencer", + "type": "address" + }, + { + "internalType": "uint64", + "name": "pendingStateTimeout", + "type": "uint64" + }, + { + "internalType": "address", + "name": "trustedAggregator", + "type": "address" + }, + { + "internalType": "uint64", + "name": "trustedAggregatorTimeout", + "type": "uint64" + } + ], + "internalType": "struct PolygonZkEVM.InitializePackedParameters", + "name": "initializePackedParameters", + "type": "tuple" + }, + { + "internalType": "bytes32", + "name": "genesisRoot", + "type": "bytes32" + }, + { + "internalType": "string", + "name": "_trustedSequencerURL", + "type": "string" + }, + { + "internalType": "string", + "name": "_networkName", + "type": "string" + }, + { + "internalType": "string", + "name": "_version", + "type": "string" + } + ], + "name": "initialize", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "isEmergencyState", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "isForcedBatchDisallowed", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint64", + "name": "pendingStateNum", + "type": "uint64" + } + ], + "name": "isPendingStateConsolidable", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "lastBatchSequenced", + "outputs": [ + { + "internalType": "uint64", + "name": "", + "type": "uint64" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "lastForceBatch", + "outputs": [ + { + "internalType": "uint64", + "name": "", + "type": "uint64" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "lastForceBatchSequenced", + "outputs": [ + { + "internalType": "uint64", + "name": "", + "type": "uint64" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "lastPendingState", + "outputs": [ + { + "internalType": "uint64", + "name": "", + "type": "uint64" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "lastPendingStateConsolidated", + "outputs": [ + { + "internalType": "uint64", + "name": "", + "type": "uint64" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "lastTimestamp", + "outputs": [ + { + "internalType": "uint64", + "name": "", + "type": "uint64" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "lastVerifiedBatch", + "outputs": [ + { + "internalType": "uint64", + "name": "", + "type": "uint64" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "matic", + "outputs": [ + { + "internalType": "contract IERC20Upgradeable", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "multiplierBatchFee", + "outputs": [ + { + "internalType": "uint16", + "name": "", + "type": "uint16" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "networkName", + "outputs": [ + { + "internalType": "string", + "name": "", + "type": "string" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint64", + "name": "initPendingStateNum", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "finalPendingStateNum", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "initNumBatch", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "finalNewBatch", + "type": "uint64" + }, + { + "internalType": "bytes32", + "name": "newLocalExitRoot", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "newStateRoot", + "type": "bytes32" + }, + { + "internalType": "bytes32[24]", + "name": "proof", + "type": "bytes32[24]" + } + ], + "name": "overridePendingState", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "pendingAdmin", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "pendingStateTimeout", + "outputs": [ + { + "internalType": "uint64", + "name": "", + "type": "uint64" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "pendingStateTransitions", + "outputs": [ + { + "internalType": "uint64", + "name": "timestamp", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "lastVerifiedBatch", + "type": "uint64" + }, + { + "internalType": "bytes32", + "name": "exitRoot", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "stateRoot", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint64", + "name": "initPendingStateNum", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "finalPendingStateNum", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "initNumBatch", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "finalNewBatch", + "type": "uint64" + }, + { + "internalType": "bytes32", + "name": "newLocalExitRoot", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "newStateRoot", + "type": "bytes32" + }, + { + "internalType": "bytes32[24]", + "name": "proof", + "type": "bytes32[24]" + } + ], + "name": "proveNonDeterministicPendingState", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "renounceOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "rollupVerifier", + "outputs": [ + { + "internalType": "contract IVerifierRollup", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "bytes", + "name": "transactions", + "type": "bytes" + }, + { + "internalType": "bytes32", + "name": "globalExitRoot", + "type": "bytes32" + }, + { + "internalType": "uint64", + "name": "timestamp", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "minForcedTimestamp", + "type": "uint64" + } + ], + "internalType": "struct PolygonZkEVM.BatchData[]", + "name": "batches", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "l2Coinbase", + "type": "address" + } + ], + "name": "sequenceBatches", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "bytes", + "name": "transactions", + "type": "bytes" + }, + { + "internalType": "bytes32", + "name": "globalExitRoot", + "type": "bytes32" + }, + { + "internalType": "uint64", + "name": "minForcedTimestamp", + "type": "uint64" + } + ], + "internalType": "struct PolygonZkEVM.ForcedBatchData[]", + "name": "batches", + "type": "tuple[]" + } + ], + "name": "sequenceForceBatches", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint64", + "name": "", + "type": "uint64" + } + ], + "name": "sequencedBatches", + "outputs": [ + { + "internalType": "bytes32", + "name": "accInputHash", + "type": "bytes32" + }, + { + "internalType": "uint64", + "name": "sequencedTimestamp", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "previousLastBatchSequenced", + "type": "uint64" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint64", + "name": "newforceBatchTimeout", + "type": "uint64" + } + ], + "name": "setForceBatchTimeout", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint16", + "name": "newMultiplierBatchFee", + "type": "uint16" + } + ], + "name": "setMultiplierBatchFee", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint64", + "name": "newPendingStateTimeout", + "type": "uint64" + } + ], + "name": "setPendingStateTimeout", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newTrustedAggregator", + "type": "address" + } + ], + "name": "setTrustedAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint64", + "name": "newTrustedAggregatorTimeout", + "type": "uint64" + } + ], + "name": "setTrustedAggregatorTimeout", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newTrustedSequencer", + "type": "address" + } + ], + "name": "setTrustedSequencer", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "string", + "name": "newTrustedSequencerURL", + "type": "string" + } + ], + "name": "setTrustedSequencerURL", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint64", + "name": "newVerifyBatchTimeTarget", + "type": "uint64" + } + ], + "name": "setVerifyBatchTimeTarget", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newPendingAdmin", + "type": "address" + } + ], + "name": "transferAdminRole", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "trustedAggregator", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "trustedAggregatorTimeout", + "outputs": [ + { + "internalType": "uint64", + "name": "", + "type": "uint64" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "trustedSequencer", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "trustedSequencerURL", + "outputs": [ + { + "internalType": "string", + "name": "", + "type": "string" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "verifyBatchTimeTarget", + "outputs": [ + { + "internalType": "uint64", + "name": "", + "type": "uint64" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint64", + "name": "pendingStateNum", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "initNumBatch", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "finalNewBatch", + "type": "uint64" + }, + { + "internalType": "bytes32", + "name": "newLocalExitRoot", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "newStateRoot", + "type": "bytes32" + }, + { + "internalType": "bytes32[24]", + "name": "proof", + "type": "bytes32[24]" + } + ], + "name": "verifyBatches", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint64", + "name": "pendingStateNum", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "initNumBatch", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "finalNewBatch", + "type": "uint64" + }, + { + "internalType": "bytes32", + "name": "newLocalExitRoot", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "newStateRoot", + "type": "bytes32" + }, + { + "internalType": "bytes32[24]", + "name": "proof", + "type": "bytes32[24]" + } + ], + "name": "verifyBatchesTrustedAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } +] \ No newline at end of file diff --git a/etherman/smartcontracts/abi/oldpolygonzkevmbridge.abi b/etherman/smartcontracts/abi/oldpolygonzkevmbridge.abi new file mode 100644 index 0000000..f7547c0 --- /dev/null +++ b/etherman/smartcontracts/abi/oldpolygonzkevmbridge.abi @@ -0,0 +1,774 @@ +[ + { + "inputs": [], + "name": "AlreadyClaimed", + "type": "error" + }, + { + "inputs": [], + "name": "AmountDoesNotMatchMsgValue", + "type": "error" + }, + { + "inputs": [], + "name": "DestinationNetworkInvalid", + "type": "error" + }, + { + "inputs": [], + "name": "EtherTransferFailed", + "type": "error" + }, + { + "inputs": [], + "name": "GlobalExitRootInvalid", + "type": "error" + }, + { + "inputs": [], + "name": "InvalidSmtProof", + "type": "error" + }, + { + "inputs": [], + "name": "MerkleTreeFull", + "type": "error" + }, + { + "inputs": [], + "name": "MessageFailed", + "type": "error" + }, + { + "inputs": [], + "name": "MsgValueNotZero", + "type": "error" + }, + { + "inputs": [], + "name": "NotValidAmount", + "type": "error" + }, + { + "inputs": [], + "name": "NotValidOwner", + "type": "error" + }, + { + "inputs": [], + "name": "NotValidSignature", + "type": "error" + }, + { + "inputs": [], + "name": "NotValidSpender", + "type": "error" + }, + { + "inputs": [], + "name": "OnlyEmergencyState", + "type": "error" + }, + { + "inputs": [], + "name": "OnlyNotEmergencyState", + "type": "error" + }, + { + "inputs": [], + "name": "OnlyPolygonZkEVM", + "type": "error" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "uint8", + "name": "leafType", + "type": "uint8" + }, + { + "indexed": false, + "internalType": "uint32", + "name": "originNetwork", + "type": "uint32" + }, + { + "indexed": false, + "internalType": "address", + "name": "originAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint32", + "name": "destinationNetwork", + "type": "uint32" + }, + { + "indexed": false, + "internalType": "address", + "name": "destinationAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "metadata", + "type": "bytes" + }, + { + "indexed": false, + "internalType": "uint32", + "name": "depositCount", + "type": "uint32" + } + ], + "name": "BridgeEvent", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "uint32", + "name": "index", + "type": "uint32" + }, + { + "indexed": false, + "internalType": "uint32", + "name": "originNetwork", + "type": "uint32" + }, + { + "indexed": false, + "internalType": "address", + "name": "originAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "destinationAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "ClaimEvent", + "type": "event" + }, + { + "anonymous": false, + "inputs": [], + "name": "EmergencyStateActivated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [], + "name": "EmergencyStateDeactivated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "uint8", + "name": "version", + "type": "uint8" + } + ], + "name": "Initialized", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "uint32", + "name": "originNetwork", + "type": "uint32" + }, + { + "indexed": false, + "internalType": "address", + "name": "originTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "wrappedTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "metadata", + "type": "bytes" + } + ], + "name": "NewWrappedToken", + "type": "event" + }, + { + "inputs": [], + "name": "activateEmergencyState", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint32", + "name": "destinationNetwork", + "type": "uint32" + }, + { + "internalType": "address", + "name": "destinationAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "internalType": "bool", + "name": "forceUpdateGlobalExitRoot", + "type": "bool" + }, + { + "internalType": "bytes", + "name": "permitData", + "type": "bytes" + } + ], + "name": "bridgeAsset", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint32", + "name": "destinationNetwork", + "type": "uint32" + }, + { + "internalType": "address", + "name": "destinationAddress", + "type": "address" + }, + { + "internalType": "bool", + "name": "forceUpdateGlobalExitRoot", + "type": "bool" + }, + { + "internalType": "bytes", + "name": "metadata", + "type": "bytes" + } + ], + "name": "bridgeMessage", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32[32]", + "name": "smtProof", + "type": "bytes32[32]" + }, + { + "internalType": "uint32", + "name": "index", + "type": "uint32" + }, + { + "internalType": "bytes32", + "name": "mainnetExitRoot", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "rollupExitRoot", + "type": "bytes32" + }, + { + "internalType": "uint32", + "name": "originNetwork", + "type": "uint32" + }, + { + "internalType": "address", + "name": "originTokenAddress", + "type": "address" + }, + { + "internalType": "uint32", + "name": "destinationNetwork", + "type": "uint32" + }, + { + "internalType": "address", + "name": "destinationAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "bytes", + "name": "metadata", + "type": "bytes" + } + ], + "name": "claimAsset", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32[32]", + "name": "smtProof", + "type": "bytes32[32]" + }, + { + "internalType": "uint32", + "name": "index", + "type": "uint32" + }, + { + "internalType": "bytes32", + "name": "mainnetExitRoot", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "rollupExitRoot", + "type": "bytes32" + }, + { + "internalType": "uint32", + "name": "originNetwork", + "type": "uint32" + }, + { + "internalType": "address", + "name": "originAddress", + "type": "address" + }, + { + "internalType": "uint32", + "name": "destinationNetwork", + "type": "uint32" + }, + { + "internalType": "address", + "name": "destinationAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "bytes", + "name": "metadata", + "type": "bytes" + } + ], + "name": "claimMessage", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "claimedBitMap", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "deactivateEmergencyState", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "depositCount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "getDepositRoot", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint8", + "name": "leafType", + "type": "uint8" + }, + { + "internalType": "uint32", + "name": "originNetwork", + "type": "uint32" + }, + { + "internalType": "address", + "name": "originAddress", + "type": "address" + }, + { + "internalType": "uint32", + "name": "destinationNetwork", + "type": "uint32" + }, + { + "internalType": "address", + "name": "destinationAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "bytes32", + "name": "metadataHash", + "type": "bytes32" + } + ], + "name": "getLeafValue", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "pure", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint32", + "name": "originNetwork", + "type": "uint32" + }, + { + "internalType": "address", + "name": "originTokenAddress", + "type": "address" + } + ], + "name": "getTokenWrappedAddress", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "globalExitRootManager", + "outputs": [ + { + "internalType": "contract IBasePolygonZkEVMGlobalExitRoot", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint32", + "name": "_networkID", + "type": "uint32" + }, + { + "internalType": "contract IBasePolygonZkEVMGlobalExitRoot", + "name": "_globalExitRootManager", + "type": "address" + }, + { + "internalType": "address", + "name": "_polygonZkEVMaddress", + "type": "address" + } + ], + "name": "initialize", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "index", + "type": "uint256" + } + ], + "name": "isClaimed", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "isEmergencyState", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "lastUpdatedDepositCount", + "outputs": [ + { + "internalType": "uint32", + "name": "", + "type": "uint32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "networkID", + "outputs": [ + { + "internalType": "uint32", + "name": "", + "type": "uint32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "polygonZkEVMaddress", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint32", + "name": "originNetwork", + "type": "uint32" + }, + { + "internalType": "address", + "name": "originTokenAddress", + "type": "address" + }, + { + "internalType": "string", + "name": "name", + "type": "string" + }, + { + "internalType": "string", + "name": "symbol", + "type": "string" + }, + { + "internalType": "uint8", + "name": "decimals", + "type": "uint8" + } + ], + "name": "precalculatedWrapperAddress", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "name": "tokenInfoToWrappedToken", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "updateGlobalExitRoot", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "leafHash", + "type": "bytes32" + }, + { + "internalType": "bytes32[32]", + "name": "smtProof", + "type": "bytes32[32]" + }, + { + "internalType": "uint32", + "name": "index", + "type": "uint32" + }, + { + "internalType": "bytes32", + "name": "root", + "type": "bytes32" + } + ], + "name": "verifyMerkleProof", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "pure", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "name": "wrappedTokenToTokenInfo", + "outputs": [ + { + "internalType": "uint32", + "name": "originNetwork", + "type": "uint32" + }, + { + "internalType": "address", + "name": "originTokenAddress", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + } +] \ No newline at end of file diff --git a/etherman/smartcontracts/abi/oldpolygonzkevmglobalexitroot.abi b/etherman/smartcontracts/abi/oldpolygonzkevmglobalexitroot.abi new file mode 100644 index 0000000..9b1be9d --- /dev/null +++ b/etherman/smartcontracts/abi/oldpolygonzkevmglobalexitroot.abi @@ -0,0 +1,139 @@ +[ + { + "inputs": [ + { + "internalType": "address", + "name": "_rollupManager", + "type": "address" + }, + { + "internalType": "address", + "name": "_bridgeAddress", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "constructor" + }, + { + "inputs": [], + "name": "OnlyAllowedContracts", + "type": "error" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "mainnetExitRoot", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "rollupExitRoot", + "type": "bytes32" + } + ], + "name": "UpdateGlobalExitRoot", + "type": "event" + }, + { + "inputs": [], + "name": "bridgeAddress", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "getLastGlobalExitRoot", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "name": "globalExitRootMap", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "lastMainnetExitRoot", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "lastRollupExitRoot", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "rollupManager", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "newRoot", + "type": "bytes32" + } + ], + "name": "updateExitRoot", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } +] \ No newline at end of file diff --git a/etherman/smartcontracts/abi/pol.abi b/etherman/smartcontracts/abi/pol.abi new file mode 100644 index 0000000..cb10275 --- /dev/null +++ b/etherman/smartcontracts/abi/pol.abi @@ -0,0 +1,408 @@ +[ + { + "constant": true, + "inputs": [], + "name": "name", + "outputs": [ + { + "name": "", + "type": "string" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "constant": false, + "inputs": [ + { + "name": "spender", + "type": "address" + }, + { + "name": "value", + "type": "uint256" + } + ], + "name": "approve", + "outputs": [ + { + "name": "", + "type": "bool" + } + ], + "payable": false, + "stateMutability": "nonpayable", + "type": "function" + }, + { + "constant": true, + "inputs": [], + "name": "totalSupply", + "outputs": [ + { + "name": "", + "type": "uint256" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "constant": false, + "inputs": [ + { + "name": "from", + "type": "address" + }, + { + "name": "to", + "type": "address" + }, + { + "name": "value", + "type": "uint256" + } + ], + "name": "transferFrom", + "outputs": [ + { + "name": "", + "type": "bool" + } + ], + "payable": false, + "stateMutability": "nonpayable", + "type": "function" + }, + { + "constant": true, + "inputs": [], + "name": "decimals", + "outputs": [ + { + "name": "", + "type": "uint8" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "constant": false, + "inputs": [ + { + "name": "spender", + "type": "address" + }, + { + "name": "addedValue", + "type": "uint256" + } + ], + "name": "increaseAllowance", + "outputs": [ + { + "name": "success", + "type": "bool" + } + ], + "payable": false, + "stateMutability": "nonpayable", + "type": "function" + }, + { + "constant": false, + "inputs": [], + "name": "unpause", + "outputs": [], + "payable": false, + "stateMutability": "nonpayable", + "type": "function" + }, + { + "constant": true, + "inputs": [ + { + "name": "account", + "type": "address" + } + ], + "name": "isPauser", + "outputs": [ + { + "name": "", + "type": "bool" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "constant": true, + "inputs": [], + "name": "paused", + "outputs": [ + { + "name": "", + "type": "bool" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "constant": false, + "inputs": [], + "name": "renouncePauser", + "outputs": [], + "payable": false, + "stateMutability": "nonpayable", + "type": "function" + }, + { + "constant": true, + "inputs": [ + { + "name": "owner", + "type": "address" + } + ], + "name": "balanceOf", + "outputs": [ + { + "name": "", + "type": "uint256" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "constant": false, + "inputs": [ + { + "name": "account", + "type": "address" + } + ], + "name": "addPauser", + "outputs": [], + "payable": false, + "stateMutability": "nonpayable", + "type": "function" + }, + { + "constant": false, + "inputs": [], + "name": "pause", + "outputs": [], + "payable": false, + "stateMutability": "nonpayable", + "type": "function" + }, + { + "constant": true, + "inputs": [], + "name": "symbol", + "outputs": [ + { + "name": "", + "type": "string" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "constant": false, + "inputs": [ + { + "name": "spender", + "type": "address" + }, + { + "name": "subtractedValue", + "type": "uint256" + } + ], + "name": "decreaseAllowance", + "outputs": [ + { + "name": "success", + "type": "bool" + } + ], + "payable": false, + "stateMutability": "nonpayable", + "type": "function" + }, + { + "constant": false, + "inputs": [ + { + "name": "to", + "type": "address" + }, + { + "name": "value", + "type": "uint256" + } + ], + "name": "transfer", + "outputs": [ + { + "name": "", + "type": "bool" + } + ], + "payable": false, + "stateMutability": "nonpayable", + "type": "function" + }, + { + "constant": true, + "inputs": [ + { + "name": "owner", + "type": "address" + }, + { + "name": "spender", + "type": "address" + } + ], + "name": "allowance", + "outputs": [ + { + "name": "", + "type": "uint256" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "name": "name", + "type": "string" + }, + { + "name": "symbol", + "type": "string" + }, + { + "name": "decimals", + "type": "uint8" + }, + { + "name": "totalSupply", + "type": "uint256" + } + ], + "payable": false, + "stateMutability": "nonpayable", + "type": "constructor" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "name": "account", + "type": "address" + } + ], + "name": "Paused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "name": "account", + "type": "address" + } + ], + "name": "Unpaused", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "name": "account", + "type": "address" + } + ], + "name": "PauserAdded", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "name": "account", + "type": "address" + } + ], + "name": "PauserRemoved", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "name": "from", + "type": "address" + }, + { + "indexed": true, + "name": "to", + "type": "address" + }, + { + "indexed": false, + "name": "value", + "type": "uint256" + } + ], + "name": "Transfer", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "name": "owner", + "type": "address" + }, + { + "indexed": true, + "name": "spender", + "type": "address" + }, + { + "indexed": false, + "name": "value", + "type": "uint256" + } + ], + "name": "Approval", + "type": "event" + } +] \ No newline at end of file diff --git a/etherman/smartcontracts/abi/polygonrollupmanager.abi b/etherman/smartcontracts/abi/polygonrollupmanager.abi new file mode 100644 index 0000000..3c6a927 --- /dev/null +++ b/etherman/smartcontracts/abi/polygonrollupmanager.abi @@ -0,0 +1,1945 @@ +[ + { + "inputs": [ + { + "internalType": "contract IPolygonZkEVMGlobalExitRoot", + "name": "_globalExitRootManager", + "type": "address" + }, + { + "internalType": "contract IERC20Upgradeable", + "name": "_pol", + "type": "address" + }, + { + "internalType": "contract IPolygonZkEVMBridge", + "name": "_bridgeAddress", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "constructor" + }, + { + "inputs": [], + "name": "AccessControlOnlyCanRenounceRolesForSelf", + "type": "error" + }, + { + "inputs": [], + "name": "AddressDoNotHaveRequiredRole", + "type": "error" + }, + { + "inputs": [], + "name": "AllzkEVMSequencedBatchesMustBeVerified", + "type": "error" + }, + { + "inputs": [], + "name": "BatchFeeOutOfRange", + "type": "error" + }, + { + "inputs": [], + "name": "ChainIDAlreadyExist", + "type": "error" + }, + { + "inputs": [], + "name": "ExceedMaxVerifyBatches", + "type": "error" + }, + { + "inputs": [], + "name": "FinalNumBatchBelowLastVerifiedBatch", + "type": "error" + }, + { + "inputs": [], + "name": "FinalNumBatchDoesNotMatchPendingState", + "type": "error" + }, + { + "inputs": [], + "name": "FinalPendingStateNumInvalid", + "type": "error" + }, + { + "inputs": [], + "name": "HaltTimeoutNotExpired", + "type": "error" + }, + { + "inputs": [], + "name": "InitBatchMustMatchCurrentForkID", + "type": "error" + }, + { + "inputs": [], + "name": "InitNumBatchAboveLastVerifiedBatch", + "type": "error" + }, + { + "inputs": [], + "name": "InitNumBatchDoesNotMatchPendingState", + "type": "error" + }, + { + "inputs": [], + "name": "InvalidProof", + "type": "error" + }, + { + "inputs": [], + "name": "InvalidRangeBatchTimeTarget", + "type": "error" + }, + { + "inputs": [], + "name": "InvalidRangeMultiplierBatchFee", + "type": "error" + }, + { + "inputs": [], + "name": "MustSequenceSomeBatch", + "type": "error" + }, + { + "inputs": [], + "name": "NewAccInputHashDoesNotExist", + "type": "error" + }, + { + "inputs": [], + "name": "NewPendingStateTimeoutMustBeLower", + "type": "error" + }, + { + "inputs": [], + "name": "NewStateRootNotInsidePrime", + "type": "error" + }, + { + "inputs": [], + "name": "NewTrustedAggregatorTimeoutMustBeLower", + "type": "error" + }, + { + "inputs": [], + "name": "OldAccInputHashDoesNotExist", + "type": "error" + }, + { + "inputs": [], + "name": "OldStateRootDoesNotExist", + "type": "error" + }, + { + "inputs": [], + "name": "OnlyEmergencyState", + "type": "error" + }, + { + "inputs": [], + "name": "OnlyNotEmergencyState", + "type": "error" + }, + { + "inputs": [], + "name": "PendingStateDoesNotExist", + "type": "error" + }, + { + "inputs": [], + "name": "PendingStateInvalid", + "type": "error" + }, + { + "inputs": [], + "name": "PendingStateNotConsolidable", + "type": "error" + }, + { + "inputs": [], + "name": "RollupMustExist", + "type": "error" + }, + { + "inputs": [], + "name": "RollupTypeDoesNotExist", + "type": "error" + }, + { + "inputs": [], + "name": "RollupTypeObsolete", + "type": "error" + }, + { + "inputs": [], + "name": "SenderMustBeRollup", + "type": "error" + }, + { + "inputs": [], + "name": "StoredRootMustBeDifferentThanNewRoot", + "type": "error" + }, + { + "inputs": [], + "name": "TrustedAggregatorTimeoutNotExpired", + "type": "error" + }, + { + "inputs": [], + "name": "UpdateNotCompatible", + "type": "error" + }, + { + "inputs": [], + "name": "UpdateToSameRollupTypeID", + "type": "error" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint32", + "name": "rollupID", + "type": "uint32" + }, + { + "indexed": false, + "internalType": "uint64", + "name": "forkID", + "type": "uint64" + }, + { + "indexed": false, + "internalType": "address", + "name": "rollupAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint64", + "name": "chainID", + "type": "uint64" + }, + { + "indexed": false, + "internalType": "uint8", + "name": "rollupCompatibilityID", + "type": "uint8" + }, + { + "indexed": false, + "internalType": "uint64", + "name": "lastVerifiedBatchBeforeUpgrade", + "type": "uint64" + } + ], + "name": "AddExistingRollup", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint32", + "name": "rollupTypeID", + "type": "uint32" + }, + { + "indexed": false, + "internalType": "address", + "name": "consensusImplementation", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "verifier", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint64", + "name": "forkID", + "type": "uint64" + }, + { + "indexed": false, + "internalType": "uint8", + "name": "rollupCompatibilityID", + "type": "uint8" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "genesis", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "string", + "name": "description", + "type": "string" + } + ], + "name": "AddNewRollupType", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint32", + "name": "rollupID", + "type": "uint32" + }, + { + "indexed": false, + "internalType": "uint64", + "name": "numBatch", + "type": "uint64" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "stateRoot", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "exitRoot", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "uint64", + "name": "pendingStateNum", + "type": "uint64" + } + ], + "name": "ConsolidatePendingState", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint32", + "name": "rollupID", + "type": "uint32" + }, + { + "indexed": false, + "internalType": "uint32", + "name": "rollupTypeID", + "type": "uint32" + }, + { + "indexed": false, + "internalType": "address", + "name": "rollupAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint64", + "name": "chainID", + "type": "uint64" + }, + { + "indexed": false, + "internalType": "address", + "name": "gasTokenAddress", + "type": "address" + } + ], + "name": "CreateNewRollup", + "type": "event" + }, + { + "anonymous": false, + "inputs": [], + "name": "EmergencyStateActivated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [], + "name": "EmergencyStateDeactivated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "uint8", + "name": "version", + "type": "uint8" + } + ], + "name": "Initialized", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint32", + "name": "rollupTypeID", + "type": "uint32" + } + ], + "name": "ObsoleteRollupType", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint32", + "name": "rollupID", + "type": "uint32" + }, + { + "indexed": false, + "internalType": "uint64", + "name": "lastBatchSequenced", + "type": "uint64" + } + ], + "name": "OnSequenceBatches", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint32", + "name": "rollupID", + "type": "uint32" + }, + { + "indexed": false, + "internalType": "uint64", + "name": "numBatch", + "type": "uint64" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "stateRoot", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "exitRoot", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "OverridePendingState", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bytes32", + "name": "storedStateRoot", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "provedStateRoot", + "type": "bytes32" + } + ], + "name": "ProveNonDeterministicPendingState", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "role", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "previousAdminRole", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "newAdminRole", + "type": "bytes32" + } + ], + "name": "RoleAdminChanged", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "role", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "account", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "RoleGranted", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "role", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "account", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "sender", + "type": "address" + } + ], + "name": "RoleRevoked", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "uint256", + "name": "newBatchFee", + "type": "uint256" + } + ], + "name": "SetBatchFee", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "uint16", + "name": "newMultiplierBatchFee", + "type": "uint16" + } + ], + "name": "SetMultiplierBatchFee", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "uint64", + "name": "newPendingStateTimeout", + "type": "uint64" + } + ], + "name": "SetPendingStateTimeout", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "newTrustedAggregator", + "type": "address" + } + ], + "name": "SetTrustedAggregator", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "uint64", + "name": "newTrustedAggregatorTimeout", + "type": "uint64" + } + ], + "name": "SetTrustedAggregatorTimeout", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "uint64", + "name": "newVerifyBatchTimeTarget", + "type": "uint64" + } + ], + "name": "SetVerifyBatchTimeTarget", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint32", + "name": "rollupID", + "type": "uint32" + }, + { + "indexed": false, + "internalType": "uint32", + "name": "newRollupTypeID", + "type": "uint32" + }, + { + "indexed": false, + "internalType": "uint64", + "name": "lastVerifiedBatchBeforeUpgrade", + "type": "uint64" + } + ], + "name": "UpdateRollup", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint32", + "name": "rollupID", + "type": "uint32" + }, + { + "indexed": false, + "internalType": "uint64", + "name": "numBatch", + "type": "uint64" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "stateRoot", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "exitRoot", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "VerifyBatches", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint32", + "name": "rollupID", + "type": "uint32" + }, + { + "indexed": false, + "internalType": "uint64", + "name": "numBatch", + "type": "uint64" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "stateRoot", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "exitRoot", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "VerifyBatchesTrustedAggregator", + "type": "event" + }, + { + "inputs": [], + "name": "DEFAULT_ADMIN_ROLE", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "activateEmergencyState", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract IPolygonRollupBase", + "name": "rollupAddress", + "type": "address" + }, + { + "internalType": "contract IVerifierRollup", + "name": "verifier", + "type": "address" + }, + { + "internalType": "uint64", + "name": "forkID", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "chainID", + "type": "uint64" + }, + { + "internalType": "bytes32", + "name": "genesis", + "type": "bytes32" + }, + { + "internalType": "uint8", + "name": "rollupCompatibilityID", + "type": "uint8" + } + ], + "name": "addExistingRollup", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "consensusImplementation", + "type": "address" + }, + { + "internalType": "contract IVerifierRollup", + "name": "verifier", + "type": "address" + }, + { + "internalType": "uint64", + "name": "forkID", + "type": "uint64" + }, + { + "internalType": "uint8", + "name": "rollupCompatibilityID", + "type": "uint8" + }, + { + "internalType": "bytes32", + "name": "genesis", + "type": "bytes32" + }, + { + "internalType": "string", + "name": "description", + "type": "string" + } + ], + "name": "addNewRollupType", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "bridgeAddress", + "outputs": [ + { + "internalType": "contract IPolygonZkEVMBridge", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "calculateRewardPerBatch", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint64", + "name": "chainID", + "type": "uint64" + } + ], + "name": "chainIDToRollupID", + "outputs": [ + { + "internalType": "uint32", + "name": "rollupID", + "type": "uint32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint32", + "name": "rollupID", + "type": "uint32" + }, + { + "internalType": "uint64", + "name": "pendingStateNum", + "type": "uint64" + } + ], + "name": "consolidatePendingState", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint32", + "name": "rollupTypeID", + "type": "uint32" + }, + { + "internalType": "uint64", + "name": "chainID", + "type": "uint64" + }, + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "internalType": "address", + "name": "sequencer", + "type": "address" + }, + { + "internalType": "address", + "name": "gasTokenAddress", + "type": "address" + }, + { + "internalType": "string", + "name": "sequencerURL", + "type": "string" + }, + { + "internalType": "string", + "name": "networkName", + "type": "string" + } + ], + "name": "createNewRollup", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "deactivateEmergencyState", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "getBatchFee", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "getForcedBatchFee", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint32", + "name": "rollupID", + "type": "uint32" + }, + { + "internalType": "uint64", + "name": "initNumBatch", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "finalNewBatch", + "type": "uint64" + }, + { + "internalType": "bytes32", + "name": "newLocalExitRoot", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "oldStateRoot", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "newStateRoot", + "type": "bytes32" + } + ], + "name": "getInputSnarkBytes", + "outputs": [ + { + "internalType": "bytes", + "name": "", + "type": "bytes" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint32", + "name": "rollupID", + "type": "uint32" + } + ], + "name": "getLastVerifiedBatch", + "outputs": [ + { + "internalType": "uint64", + "name": "", + "type": "uint64" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "role", + "type": "bytes32" + } + ], + "name": "getRoleAdmin", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint32", + "name": "rollupID", + "type": "uint32" + }, + { + "internalType": "uint64", + "name": "batchNum", + "type": "uint64" + } + ], + "name": "getRollupBatchNumToStateRoot", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "getRollupExitRoot", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint32", + "name": "rollupID", + "type": "uint32" + }, + { + "internalType": "uint64", + "name": "batchNum", + "type": "uint64" + } + ], + "name": "getRollupPendingStateTransitions", + "outputs": [ + { + "components": [ + { + "internalType": "uint64", + "name": "timestamp", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "lastVerifiedBatch", + "type": "uint64" + }, + { + "internalType": "bytes32", + "name": "exitRoot", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "stateRoot", + "type": "bytes32" + } + ], + "internalType": "struct LegacyZKEVMStateVariables.PendingState", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint32", + "name": "rollupID", + "type": "uint32" + }, + { + "internalType": "uint64", + "name": "batchNum", + "type": "uint64" + } + ], + "name": "getRollupSequencedBatches", + "outputs": [ + { + "components": [ + { + "internalType": "bytes32", + "name": "accInputHash", + "type": "bytes32" + }, + { + "internalType": "uint64", + "name": "sequencedTimestamp", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "previousLastBatchSequenced", + "type": "uint64" + } + ], + "internalType": "struct LegacyZKEVMStateVariables.SequencedBatchData", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "globalExitRootManager", + "outputs": [ + { + "internalType": "contract IPolygonZkEVMGlobalExitRoot", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "role", + "type": "bytes32" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "grantRole", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "role", + "type": "bytes32" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "hasRole", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "trustedAggregator", + "type": "address" + }, + { + "internalType": "uint64", + "name": "_pendingStateTimeout", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "_trustedAggregatorTimeout", + "type": "uint64" + }, + { + "internalType": "address", + "name": "admin", + "type": "address" + }, + { + "internalType": "address", + "name": "timelock", + "type": "address" + }, + { + "internalType": "address", + "name": "emergencyCouncil", + "type": "address" + }, + { + "internalType": "contract PolygonZkEVMV2Existent", + "name": "polygonZkEVM", + "type": "address" + }, + { + "internalType": "contract IVerifierRollup", + "name": "zkEVMVerifier", + "type": "address" + }, + { + "internalType": "uint64", + "name": "zkEVMForkID", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "zkEVMChainID", + "type": "uint64" + } + ], + "name": "initialize", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "isEmergencyState", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint32", + "name": "rollupID", + "type": "uint32" + }, + { + "internalType": "uint64", + "name": "pendingStateNum", + "type": "uint64" + } + ], + "name": "isPendingStateConsolidable", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "lastAggregationTimestamp", + "outputs": [ + { + "internalType": "uint64", + "name": "", + "type": "uint64" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "multiplierBatchFee", + "outputs": [ + { + "internalType": "uint16", + "name": "", + "type": "uint16" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint32", + "name": "rollupTypeID", + "type": "uint32" + } + ], + "name": "obsoleteRollupType", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint64", + "name": "newSequencedBatches", + "type": "uint64" + }, + { + "internalType": "bytes32", + "name": "newAccInputHash", + "type": "bytes32" + } + ], + "name": "onSequenceBatches", + "outputs": [ + { + "internalType": "uint64", + "name": "", + "type": "uint64" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint32", + "name": "rollupID", + "type": "uint32" + }, + { + "internalType": "uint64", + "name": "initPendingStateNum", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "finalPendingStateNum", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "initNumBatch", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "finalNewBatch", + "type": "uint64" + }, + { + "internalType": "bytes32", + "name": "newLocalExitRoot", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "newStateRoot", + "type": "bytes32" + }, + { + "internalType": "bytes32[24]", + "name": "proof", + "type": "bytes32[24]" + } + ], + "name": "overridePendingState", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "pendingStateTimeout", + "outputs": [ + { + "internalType": "uint64", + "name": "", + "type": "uint64" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "pol", + "outputs": [ + { + "internalType": "contract IERC20Upgradeable", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint32", + "name": "rollupID", + "type": "uint32" + }, + { + "internalType": "uint64", + "name": "initPendingStateNum", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "finalPendingStateNum", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "initNumBatch", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "finalNewBatch", + "type": "uint64" + }, + { + "internalType": "bytes32", + "name": "newLocalExitRoot", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "newStateRoot", + "type": "bytes32" + }, + { + "internalType": "bytes32[24]", + "name": "proof", + "type": "bytes32[24]" + } + ], + "name": "proveNonDeterministicPendingState", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "role", + "type": "bytes32" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "renounceRole", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "role", + "type": "bytes32" + }, + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "revokeRole", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "rollupAddress", + "type": "address" + } + ], + "name": "rollupAddressToID", + "outputs": [ + { + "internalType": "uint32", + "name": "rollupID", + "type": "uint32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "rollupCount", + "outputs": [ + { + "internalType": "uint32", + "name": "", + "type": "uint32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint32", + "name": "rollupID", + "type": "uint32" + } + ], + "name": "rollupIDToRollupData", + "outputs": [ + { + "internalType": "contract IPolygonRollupBase", + "name": "rollupContract", + "type": "address" + }, + { + "internalType": "uint64", + "name": "chainID", + "type": "uint64" + }, + { + "internalType": "contract IVerifierRollup", + "name": "verifier", + "type": "address" + }, + { + "internalType": "uint64", + "name": "forkID", + "type": "uint64" + }, + { + "internalType": "bytes32", + "name": "lastLocalExitRoot", + "type": "bytes32" + }, + { + "internalType": "uint64", + "name": "lastBatchSequenced", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "lastVerifiedBatch", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "lastPendingState", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "lastPendingStateConsolidated", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "lastVerifiedBatchBeforeUpgrade", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "rollupTypeID", + "type": "uint64" + }, + { + "internalType": "uint8", + "name": "rollupCompatibilityID", + "type": "uint8" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "rollupTypeCount", + "outputs": [ + { + "internalType": "uint32", + "name": "", + "type": "uint32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint32", + "name": "rollupTypeID", + "type": "uint32" + } + ], + "name": "rollupTypeMap", + "outputs": [ + { + "internalType": "address", + "name": "consensusImplementation", + "type": "address" + }, + { + "internalType": "contract IVerifierRollup", + "name": "verifier", + "type": "address" + }, + { + "internalType": "uint64", + "name": "forkID", + "type": "uint64" + }, + { + "internalType": "uint8", + "name": "rollupCompatibilityID", + "type": "uint8" + }, + { + "internalType": "bool", + "name": "obsolete", + "type": "bool" + }, + { + "internalType": "bytes32", + "name": "genesis", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "newBatchFee", + "type": "uint256" + } + ], + "name": "setBatchFee", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint16", + "name": "newMultiplierBatchFee", + "type": "uint16" + } + ], + "name": "setMultiplierBatchFee", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint64", + "name": "newPendingStateTimeout", + "type": "uint64" + } + ], + "name": "setPendingStateTimeout", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint64", + "name": "newTrustedAggregatorTimeout", + "type": "uint64" + } + ], + "name": "setTrustedAggregatorTimeout", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint64", + "name": "newVerifyBatchTimeTarget", + "type": "uint64" + } + ], + "name": "setVerifyBatchTimeTarget", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "totalSequencedBatches", + "outputs": [ + { + "internalType": "uint64", + "name": "", + "type": "uint64" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "totalVerifiedBatches", + "outputs": [ + { + "internalType": "uint64", + "name": "", + "type": "uint64" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "trustedAggregatorTimeout", + "outputs": [ + { + "internalType": "uint64", + "name": "", + "type": "uint64" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract ITransparentUpgradeableProxy", + "name": "rollupContract", + "type": "address" + }, + { + "internalType": "uint32", + "name": "newRollupTypeID", + "type": "uint32" + }, + { + "internalType": "bytes", + "name": "upgradeData", + "type": "bytes" + } + ], + "name": "updateRollup", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "verifyBatchTimeTarget", + "outputs": [ + { + "internalType": "uint64", + "name": "", + "type": "uint64" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint32", + "name": "rollupID", + "type": "uint32" + }, + { + "internalType": "uint64", + "name": "pendingStateNum", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "initNumBatch", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "finalNewBatch", + "type": "uint64" + }, + { + "internalType": "bytes32", + "name": "newLocalExitRoot", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "newStateRoot", + "type": "bytes32" + }, + { + "internalType": "address", + "name": "beneficiary", + "type": "address" + }, + { + "internalType": "bytes32[24]", + "name": "proof", + "type": "bytes32[24]" + } + ], + "name": "verifyBatches", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint32", + "name": "rollupID", + "type": "uint32" + }, + { + "internalType": "uint64", + "name": "pendingStateNum", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "initNumBatch", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "finalNewBatch", + "type": "uint64" + }, + { + "internalType": "bytes32", + "name": "newLocalExitRoot", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "newStateRoot", + "type": "bytes32" + }, + { + "internalType": "address", + "name": "beneficiary", + "type": "address" + }, + { + "internalType": "bytes32[24]", + "name": "proof", + "type": "bytes32[24]" + } + ], + "name": "verifyBatchesTrustedAggregator", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } +] \ No newline at end of file diff --git a/etherman/smartcontracts/abi/polygonzkevm.abi b/etherman/smartcontracts/abi/polygonzkevm.abi new file mode 100644 index 0000000..0b43f41 --- /dev/null +++ b/etherman/smartcontracts/abi/polygonzkevm.abi @@ -0,0 +1,1118 @@ +[ + { + "inputs": [ + { + "internalType": "contract IPolygonZkEVMGlobalExitRootV2", + "name": "_globalExitRootManager", + "type": "address" + }, + { + "internalType": "contract IERC20Upgradeable", + "name": "_pol", + "type": "address" + }, + { + "internalType": "contract IPolygonZkEVMBridgeV2", + "name": "_bridgeAddress", + "type": "address" + }, + { + "internalType": "contract PolygonRollupManager", + "name": "_rollupManager", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "constructor" + }, + { + "inputs": [], + "name": "BatchAlreadyVerified", + "type": "error" + }, + { + "inputs": [], + "name": "BatchNotSequencedOrNotSequenceEnd", + "type": "error" + }, + { + "inputs": [], + "name": "ExceedMaxVerifyBatches", + "type": "error" + }, + { + "inputs": [], + "name": "FinalNumBatchBelowLastVerifiedBatch", + "type": "error" + }, + { + "inputs": [], + "name": "FinalNumBatchDoesNotMatchPendingState", + "type": "error" + }, + { + "inputs": [], + "name": "FinalPendingStateNumInvalid", + "type": "error" + }, + { + "inputs": [], + "name": "ForceBatchNotAllowed", + "type": "error" + }, + { + "inputs": [], + "name": "ForceBatchTimeoutNotExpired", + "type": "error" + }, + { + "inputs": [], + "name": "ForceBatchesAlreadyActive", + "type": "error" + }, + { + "inputs": [], + "name": "ForceBatchesOverflow", + "type": "error" + }, + { + "inputs": [], + "name": "ForcedDataDoesNotMatch", + "type": "error" + }, + { + "inputs": [], + "name": "GasTokenNetworkMustBeZeroOnEther", + "type": "error" + }, + { + "inputs": [], + "name": "GlobalExitRootNotExist", + "type": "error" + }, + { + "inputs": [], + "name": "HaltTimeoutNotExpired", + "type": "error" + }, + { + "inputs": [], + "name": "HugeTokenMetadataNotSupported", + "type": "error" + }, + { + "inputs": [], + "name": "InitNumBatchAboveLastVerifiedBatch", + "type": "error" + }, + { + "inputs": [], + "name": "InitNumBatchDoesNotMatchPendingState", + "type": "error" + }, + { + "inputs": [], + "name": "InvalidInitializeTransaction", + "type": "error" + }, + { + "inputs": [], + "name": "InvalidProof", + "type": "error" + }, + { + "inputs": [], + "name": "InvalidRangeBatchTimeTarget", + "type": "error" + }, + { + "inputs": [], + "name": "InvalidRangeForceBatchTimeout", + "type": "error" + }, + { + "inputs": [], + "name": "InvalidRangeMultiplierBatchFee", + "type": "error" + }, + { + "inputs": [], + "name": "NewAccInputHashDoesNotExist", + "type": "error" + }, + { + "inputs": [], + "name": "NewPendingStateTimeoutMustBeLower", + "type": "error" + }, + { + "inputs": [], + "name": "NewStateRootNotInsidePrime", + "type": "error" + }, + { + "inputs": [], + "name": "NewTrustedAggregatorTimeoutMustBeLower", + "type": "error" + }, + { + "inputs": [], + "name": "NotEnoughMaticAmount", + "type": "error" + }, + { + "inputs": [], + "name": "NotEnoughPOLAmount", + "type": "error" + }, + { + "inputs": [], + "name": "OldAccInputHashDoesNotExist", + "type": "error" + }, + { + "inputs": [], + "name": "OldStateRootDoesNotExist", + "type": "error" + }, + { + "inputs": [], + "name": "OnlyAdmin", + "type": "error" + }, + { + "inputs": [], + "name": "OnlyPendingAdmin", + "type": "error" + }, + { + "inputs": [], + "name": "OnlyRollupManager", + "type": "error" + }, + { + "inputs": [], + "name": "OnlyTrustedAggregator", + "type": "error" + }, + { + "inputs": [], + "name": "OnlyTrustedSequencer", + "type": "error" + }, + { + "inputs": [], + "name": "PendingStateDoesNotExist", + "type": "error" + }, + { + "inputs": [], + "name": "PendingStateInvalid", + "type": "error" + }, + { + "inputs": [], + "name": "PendingStateNotConsolidable", + "type": "error" + }, + { + "inputs": [], + "name": "PendingStateTimeoutExceedHaltAggregationTimeout", + "type": "error" + }, + { + "inputs": [], + "name": "SequenceZeroBatches", + "type": "error" + }, + { + "inputs": [], + "name": "SequencedTimestampBelowForcedTimestamp", + "type": "error" + }, + { + "inputs": [], + "name": "SequencedTimestampInvalid", + "type": "error" + }, + { + "inputs": [], + "name": "StoredRootMustBeDifferentThanNewRoot", + "type": "error" + }, + { + "inputs": [], + "name": "TransactionsLengthAboveMax", + "type": "error" + }, + { + "inputs": [], + "name": "TrustedAggregatorTimeoutExceedHaltAggregationTimeout", + "type": "error" + }, + { + "inputs": [], + "name": "TrustedAggregatorTimeoutNotExpired", + "type": "error" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "newAdmin", + "type": "address" + } + ], + "name": "AcceptAdminRole", + "type": "event" + }, + { + "anonymous": false, + "inputs": [], + "name": "ActivateForceBatches", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint64", + "name": "forceBatchNum", + "type": "uint64" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "lastGlobalExitRoot", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sequencer", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "transactions", + "type": "bytes" + } + ], + "name": "ForceBatch", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bytes", + "name": "transactions", + "type": "bytes" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "lastGlobalExitRoot", + "type": "bytes32" + }, + { + "indexed": false, + "internalType": "address", + "name": "sequencer", + "type": "address" + } + ], + "name": "InitialSequenceBatches", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "uint8", + "name": "version", + "type": "uint8" + } + ], + "name": "Initialized", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint64", + "name": "numBatch", + "type": "uint64" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "l1InfoRoot", + "type": "bytes32" + } + ], + "name": "SequenceBatches", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint64", + "name": "numBatch", + "type": "uint64" + } + ], + "name": "SequenceForceBatches", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "uint64", + "name": "newforceBatchTimeout", + "type": "uint64" + } + ], + "name": "SetForceBatchTimeout", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "newTrustedSequencer", + "type": "address" + } + ], + "name": "SetTrustedSequencer", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "string", + "name": "newTrustedSequencerURL", + "type": "string" + } + ], + "name": "SetTrustedSequencerURL", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "newPendingAdmin", + "type": "address" + } + ], + "name": "TransferAdminRole", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "uint64", + "name": "numBatch", + "type": "uint64" + }, + { + "indexed": false, + "internalType": "bytes32", + "name": "stateRoot", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "VerifyBatches", + "type": "event" + }, + { + "inputs": [], + "name": "GLOBAL_EXIT_ROOT_MANAGER_L2", + "outputs": [ + { + "internalType": "contract IBasePolygonZkEVMGlobalExitRoot", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "INITIALIZE_TX_BRIDGE_LIST_LEN_LEN", + "outputs": [ + { + "internalType": "uint8", + "name": "", + "type": "uint8" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "INITIALIZE_TX_BRIDGE_PARAMS", + "outputs": [ + { + "internalType": "bytes", + "name": "", + "type": "bytes" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "INITIALIZE_TX_BRIDGE_PARAMS_AFTER_BRIDGE_ADDRESS", + "outputs": [ + { + "internalType": "bytes", + "name": "", + "type": "bytes" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "INITIALIZE_TX_BRIDGE_PARAMS_AFTER_BRIDGE_ADDRESS_EMPTY_METADATA", + "outputs": [ + { + "internalType": "bytes", + "name": "", + "type": "bytes" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "INITIALIZE_TX_CONSTANT_BYTES", + "outputs": [ + { + "internalType": "uint16", + "name": "", + "type": "uint16" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "INITIALIZE_TX_CONSTANT_BYTES_EMPTY_METADATA", + "outputs": [ + { + "internalType": "uint16", + "name": "", + "type": "uint16" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "INITIALIZE_TX_DATA_LEN_EMPTY_METADATA", + "outputs": [ + { + "internalType": "uint8", + "name": "", + "type": "uint8" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "INITIALIZE_TX_EFFECTIVE_PERCENTAGE", + "outputs": [ + { + "internalType": "bytes1", + "name": "", + "type": "bytes1" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "SIGNATURE_INITIALIZE_TX_R", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "SIGNATURE_INITIALIZE_TX_S", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "SIGNATURE_INITIALIZE_TX_V", + "outputs": [ + { + "internalType": "uint8", + "name": "", + "type": "uint8" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "acceptAdminRole", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "activateForceBatches", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "admin", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "bridgeAddress", + "outputs": [ + { + "internalType": "contract IPolygonZkEVMBridgeV2", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "calculatePolPerForceBatch", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes", + "name": "transactions", + "type": "bytes" + }, + { + "internalType": "uint256", + "name": "polAmount", + "type": "uint256" + } + ], + "name": "forceBatch", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "forceBatchTimeout", + "outputs": [ + { + "internalType": "uint64", + "name": "", + "type": "uint64" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint64", + "name": "", + "type": "uint64" + } + ], + "name": "forcedBatches", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "gapLastTimestamp", + "outputs": [ + { + "internalType": "uint64", + "name": "", + "type": "uint64" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "gasTokenAddress", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "gasTokenNetwork", + "outputs": [ + { + "internalType": "uint32", + "name": "", + "type": "uint32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint32", + "name": "networkID", + "type": "uint32" + }, + { + "internalType": "address", + "name": "_gasTokenAddress", + "type": "address" + }, + { + "internalType": "uint32", + "name": "_gasTokenNetwork", + "type": "uint32" + }, + { + "internalType": "bytes", + "name": "_gasTokenMetadata", + "type": "bytes" + } + ], + "name": "generateInitializeTransaction", + "outputs": [ + { + "internalType": "bytes", + "name": "", + "type": "bytes" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "globalExitRootManager", + "outputs": [ + { + "internalType": "contract IPolygonZkEVMGlobalExitRootV2", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_admin", + "type": "address" + }, + { + "internalType": "address", + "name": "sequencer", + "type": "address" + }, + { + "internalType": "uint32", + "name": "networkID", + "type": "uint32" + }, + { + "internalType": "address", + "name": "_gasTokenAddress", + "type": "address" + }, + { + "internalType": "string", + "name": "sequencerURL", + "type": "string" + }, + { + "internalType": "string", + "name": "_networkName", + "type": "string" + } + ], + "name": "initialize", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "isForcedBatchAllowed", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "lastAccInputHash", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "lastForceBatch", + "outputs": [ + { + "internalType": "uint64", + "name": "", + "type": "uint64" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "lastForceBatchSequenced", + "outputs": [ + { + "internalType": "uint64", + "name": "", + "type": "uint64" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "networkName", + "outputs": [ + { + "internalType": "string", + "name": "", + "type": "string" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint64", + "name": "lastVerifiedBatch", + "type": "uint64" + }, + { + "internalType": "bytes32", + "name": "newStateRoot", + "type": "bytes32" + }, + { + "internalType": "address", + "name": "aggregator", + "type": "address" + } + ], + "name": "onVerifyBatches", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "pendingAdmin", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "pol", + "outputs": [ + { + "internalType": "contract IERC20Upgradeable", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "rollupManager", + "outputs": [ + { + "internalType": "contract PolygonRollupManager", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "bytes", + "name": "transactions", + "type": "bytes" + }, + { + "internalType": "bytes32", + "name": "forcedGlobalExitRoot", + "type": "bytes32" + }, + { + "internalType": "uint64", + "name": "forcedTimestamp", + "type": "uint64" + }, + { + "internalType": "bytes32", + "name": "forcedBlockHashL1", + "type": "bytes32" + } + ], + "internalType": "struct PolygonRollupBaseEtrog.BatchData[]", + "name": "batches", + "type": "tuple[]" + }, + { + "internalType": "address", + "name": "l2Coinbase", + "type": "address" + } + ], + "name": "sequenceBatches", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "bytes", + "name": "transactions", + "type": "bytes" + }, + { + "internalType": "bytes32", + "name": "forcedGlobalExitRoot", + "type": "bytes32" + }, + { + "internalType": "uint64", + "name": "forcedTimestamp", + "type": "uint64" + }, + { + "internalType": "bytes32", + "name": "forcedBlockHashL1", + "type": "bytes32" + } + ], + "internalType": "struct PolygonRollupBaseEtrog.BatchData[]", + "name": "batches", + "type": "tuple[]" + } + ], + "name": "sequenceForceBatches", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint64", + "name": "newforceBatchTimeout", + "type": "uint64" + } + ], + "name": "setForceBatchTimeout", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newTrustedSequencer", + "type": "address" + } + ], + "name": "setTrustedSequencer", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "string", + "name": "newTrustedSequencerURL", + "type": "string" + } + ], + "name": "setTrustedSequencerURL", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newPendingAdmin", + "type": "address" + } + ], + "name": "transferAdminRole", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "trustedSequencer", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "trustedSequencerURL", + "outputs": [ + { + "internalType": "string", + "name": "", + "type": "string" + } + ], + "stateMutability": "view", + "type": "function" + } +] \ No newline at end of file diff --git a/etherman/smartcontracts/abi/polygonzkevmbridge.abi b/etherman/smartcontracts/abi/polygonzkevmbridge.abi new file mode 100644 index 0000000..4da94ee --- /dev/null +++ b/etherman/smartcontracts/abi/polygonzkevmbridge.abi @@ -0,0 +1,981 @@ +[ + { + "inputs": [], + "name": "AlreadyClaimed", + "type": "error" + }, + { + "inputs": [], + "name": "AmountDoesNotMatchMsgValue", + "type": "error" + }, + { + "inputs": [], + "name": "DestinationNetworkInvalid", + "type": "error" + }, + { + "inputs": [], + "name": "EtherTransferFailed", + "type": "error" + }, + { + "inputs": [], + "name": "GasTokenNetworkMustBeZeroOnEther", + "type": "error" + }, + { + "inputs": [], + "name": "GlobalExitRootInvalid", + "type": "error" + }, + { + "inputs": [], + "name": "InvalidSmtProof", + "type": "error" + }, + { + "inputs": [], + "name": "MerkleTreeFull", + "type": "error" + }, + { + "inputs": [], + "name": "MessageFailed", + "type": "error" + }, + { + "inputs": [], + "name": "MsgValueNotZero", + "type": "error" + }, + { + "inputs": [], + "name": "NativeTokenIsEther", + "type": "error" + }, + { + "inputs": [], + "name": "NoValueInMessagesOnGasTokenNetworks", + "type": "error" + }, + { + "inputs": [], + "name": "NotValidAmount", + "type": "error" + }, + { + "inputs": [], + "name": "NotValidOwner", + "type": "error" + }, + { + "inputs": [], + "name": "NotValidSignature", + "type": "error" + }, + { + "inputs": [], + "name": "NotValidSpender", + "type": "error" + }, + { + "inputs": [], + "name": "OnlyEmergencyState", + "type": "error" + }, + { + "inputs": [], + "name": "OnlyNotEmergencyState", + "type": "error" + }, + { + "inputs": [], + "name": "OnlyRollupManager", + "type": "error" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "uint8", + "name": "leafType", + "type": "uint8" + }, + { + "indexed": false, + "internalType": "uint32", + "name": "originNetwork", + "type": "uint32" + }, + { + "indexed": false, + "internalType": "address", + "name": "originAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint32", + "name": "destinationNetwork", + "type": "uint32" + }, + { + "indexed": false, + "internalType": "address", + "name": "destinationAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "metadata", + "type": "bytes" + }, + { + "indexed": false, + "internalType": "uint32", + "name": "depositCount", + "type": "uint32" + } + ], + "name": "BridgeEvent", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "uint256", + "name": "globalIndex", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint32", + "name": "originNetwork", + "type": "uint32" + }, + { + "indexed": false, + "internalType": "address", + "name": "originAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "destinationAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "ClaimEvent", + "type": "event" + }, + { + "anonymous": false, + "inputs": [], + "name": "EmergencyStateActivated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [], + "name": "EmergencyStateDeactivated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "uint8", + "name": "version", + "type": "uint8" + } + ], + "name": "Initialized", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "uint32", + "name": "originNetwork", + "type": "uint32" + }, + { + "indexed": false, + "internalType": "address", + "name": "originTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "wrappedTokenAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "bytes", + "name": "metadata", + "type": "bytes" + } + ], + "name": "NewWrappedToken", + "type": "event" + }, + { + "inputs": [], + "name": "WETHToken", + "outputs": [ + { + "internalType": "contract TokenWrapped", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "activateEmergencyState", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint32", + "name": "destinationNetwork", + "type": "uint32" + }, + { + "internalType": "address", + "name": "destinationAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "internalType": "bool", + "name": "forceUpdateGlobalExitRoot", + "type": "bool" + }, + { + "internalType": "bytes", + "name": "permitData", + "type": "bytes" + } + ], + "name": "bridgeAsset", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint32", + "name": "destinationNetwork", + "type": "uint32" + }, + { + "internalType": "address", + "name": "destinationAddress", + "type": "address" + }, + { + "internalType": "bool", + "name": "forceUpdateGlobalExitRoot", + "type": "bool" + }, + { + "internalType": "bytes", + "name": "metadata", + "type": "bytes" + } + ], + "name": "bridgeMessage", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint32", + "name": "destinationNetwork", + "type": "uint32" + }, + { + "internalType": "address", + "name": "destinationAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amountWETH", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "forceUpdateGlobalExitRoot", + "type": "bool" + }, + { + "internalType": "bytes", + "name": "metadata", + "type": "bytes" + } + ], + "name": "bridgeMessageWETH", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "leafHash", + "type": "bytes32" + }, + { + "internalType": "bytes32[32]", + "name": "smtProof", + "type": "bytes32[32]" + }, + { + "internalType": "uint32", + "name": "index", + "type": "uint32" + } + ], + "name": "calculateRoot", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "pure", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint32", + "name": "originNetwork", + "type": "uint32" + }, + { + "internalType": "address", + "name": "originTokenAddress", + "type": "address" + }, + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "calculateTokenWrapperAddress", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32[32]", + "name": "smtProofLocalExitRoot", + "type": "bytes32[32]" + }, + { + "internalType": "bytes32[32]", + "name": "smtProofRollupExitRoot", + "type": "bytes32[32]" + }, + { + "internalType": "uint256", + "name": "globalIndex", + "type": "uint256" + }, + { + "internalType": "bytes32", + "name": "mainnetExitRoot", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "rollupExitRoot", + "type": "bytes32" + }, + { + "internalType": "uint32", + "name": "originNetwork", + "type": "uint32" + }, + { + "internalType": "address", + "name": "originTokenAddress", + "type": "address" + }, + { + "internalType": "uint32", + "name": "destinationNetwork", + "type": "uint32" + }, + { + "internalType": "address", + "name": "destinationAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "bytes", + "name": "metadata", + "type": "bytes" + } + ], + "name": "claimAsset", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32[32]", + "name": "smtProofLocalExitRoot", + "type": "bytes32[32]" + }, + { + "internalType": "bytes32[32]", + "name": "smtProofRollupExitRoot", + "type": "bytes32[32]" + }, + { + "internalType": "uint256", + "name": "globalIndex", + "type": "uint256" + }, + { + "internalType": "bytes32", + "name": "mainnetExitRoot", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "rollupExitRoot", + "type": "bytes32" + }, + { + "internalType": "uint32", + "name": "originNetwork", + "type": "uint32" + }, + { + "internalType": "address", + "name": "originAddress", + "type": "address" + }, + { + "internalType": "uint32", + "name": "destinationNetwork", + "type": "uint32" + }, + { + "internalType": "address", + "name": "destinationAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "bytes", + "name": "metadata", + "type": "bytes" + } + ], + "name": "claimMessage", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "claimedBitMap", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "deactivateEmergencyState", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "depositCount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "gasTokenAddress", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "gasTokenMetadata", + "outputs": [ + { + "internalType": "bytes", + "name": "", + "type": "bytes" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "gasTokenNetwork", + "outputs": [ + { + "internalType": "uint32", + "name": "", + "type": "uint32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint8", + "name": "leafType", + "type": "uint8" + }, + { + "internalType": "uint32", + "name": "originNetwork", + "type": "uint32" + }, + { + "internalType": "address", + "name": "originAddress", + "type": "address" + }, + { + "internalType": "uint32", + "name": "destinationNetwork", + "type": "uint32" + }, + { + "internalType": "address", + "name": "destinationAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "bytes32", + "name": "metadataHash", + "type": "bytes32" + } + ], + "name": "getLeafValue", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "pure", + "type": "function" + }, + { + "inputs": [], + "name": "getRoot", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + } + ], + "name": "getTokenMetadata", + "outputs": [ + { + "internalType": "bytes", + "name": "", + "type": "bytes" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint32", + "name": "originNetwork", + "type": "uint32" + }, + { + "internalType": "address", + "name": "originTokenAddress", + "type": "address" + } + ], + "name": "getTokenWrappedAddress", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "globalExitRootManager", + "outputs": [ + { + "internalType": "contract IBasePolygonZkEVMGlobalExitRoot", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint32", + "name": "_networkID", + "type": "uint32" + }, + { + "internalType": "address", + "name": "_gasTokenAddress", + "type": "address" + }, + { + "internalType": "uint32", + "name": "_gasTokenNetwork", + "type": "uint32" + }, + { + "internalType": "contract IBasePolygonZkEVMGlobalExitRoot", + "name": "_globalExitRootManager", + "type": "address" + }, + { + "internalType": "address", + "name": "_polygonRollupManager", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_gasTokenMetadata", + "type": "bytes" + } + ], + "name": "initialize", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint32", + "name": "leafIndex", + "type": "uint32" + }, + { + "internalType": "uint32", + "name": "sourceBridgeNetwork", + "type": "uint32" + } + ], + "name": "isClaimed", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "isEmergencyState", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "lastUpdatedDepositCount", + "outputs": [ + { + "internalType": "uint32", + "name": "", + "type": "uint32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "networkID", + "outputs": [ + { + "internalType": "uint32", + "name": "", + "type": "uint32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "polygonRollupManager", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint32", + "name": "originNetwork", + "type": "uint32" + }, + { + "internalType": "address", + "name": "originTokenAddress", + "type": "address" + }, + { + "internalType": "string", + "name": "name", + "type": "string" + }, + { + "internalType": "string", + "name": "symbol", + "type": "string" + }, + { + "internalType": "uint8", + "name": "decimals", + "type": "uint8" + } + ], + "name": "precalculatedWrapperAddress", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "name": "tokenInfoToWrappedToken", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "updateGlobalExitRoot", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "leafHash", + "type": "bytes32" + }, + { + "internalType": "bytes32[32]", + "name": "smtProof", + "type": "bytes32[32]" + }, + { + "internalType": "uint32", + "name": "index", + "type": "uint32" + }, + { + "internalType": "bytes32", + "name": "root", + "type": "bytes32" + } + ], + "name": "verifyMerkleProof", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "pure", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "name": "wrappedTokenToTokenInfo", + "outputs": [ + { + "internalType": "uint32", + "name": "originNetwork", + "type": "uint32" + }, + { + "internalType": "address", + "name": "originTokenAddress", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + } +] \ No newline at end of file diff --git a/etherman/smartcontracts/abi/polygonzkevmglobalexitroot.abi b/etherman/smartcontracts/abi/polygonzkevmglobalexitroot.abi new file mode 100644 index 0000000..f048bd6 --- /dev/null +++ b/etherman/smartcontracts/abi/polygonzkevmglobalexitroot.abi @@ -0,0 +1,262 @@ +[ + { + "inputs": [ + { + "internalType": "address", + "name": "_rollupManager", + "type": "address" + }, + { + "internalType": "address", + "name": "_bridgeAddress", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "constructor" + }, + { + "inputs": [], + "name": "MerkleTreeFull", + "type": "error" + }, + { + "inputs": [], + "name": "OnlyAllowedContracts", + "type": "error" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "bytes32", + "name": "mainnetExitRoot", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "bytes32", + "name": "rollupExitRoot", + "type": "bytes32" + } + ], + "name": "UpdateL1InfoTree", + "type": "event" + }, + { + "inputs": [], + "name": "bridgeAddress", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "leafHash", + "type": "bytes32" + }, + { + "internalType": "bytes32[32]", + "name": "smtProof", + "type": "bytes32[32]" + }, + { + "internalType": "uint32", + "name": "index", + "type": "uint32" + } + ], + "name": "calculateRoot", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "pure", + "type": "function" + }, + { + "inputs": [], + "name": "depositCount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "getLastGlobalExitRoot", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "newGlobalExitRoot", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "lastBlockHash", + "type": "uint256" + }, + { + "internalType": "uint64", + "name": "timestamp", + "type": "uint64" + } + ], + "name": "getLeafValue", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "pure", + "type": "function" + }, + { + "inputs": [], + "name": "getRoot", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "name": "globalExitRootMap", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "lastMainnetExitRoot", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "lastRollupExitRoot", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "rollupManager", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "newRoot", + "type": "bytes32" + } + ], + "name": "updateExitRoot", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "leafHash", + "type": "bytes32" + }, + { + "internalType": "bytes32[32]", + "name": "smtProof", + "type": "bytes32[32]" + }, + { + "internalType": "uint32", + "name": "index", + "type": "uint32" + }, + { + "internalType": "bytes32", + "name": "root", + "type": "bytes32" + } + ], + "name": "verifyMerkleProof", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "pure", + "type": "function" + } +] \ No newline at end of file diff --git a/etherman/smartcontracts/bin/mockpolygonrollupmanager.bin b/etherman/smartcontracts/bin/mockpolygonrollupmanager.bin new file mode 100644 index 0000000..24aea67 --- /dev/null +++ b/etherman/smartcontracts/bin/mockpolygonrollupmanager.bin @@ -0,0 +1 @@ +60e06040523480156200001157600080fd5b50604051620060853803806200608583398101604081905262000034916200006b565b6001600160a01b0392831660805290821660c0521660a052620000bf565b6001600160a01b03811681146200006857600080fd5b50565b6000806000606084860312156200008157600080fd5b83516200008e8162000052565b6020850151909350620000a18162000052565b6040850151909250620000b48162000052565b809150509250925092565b60805160a05160c051615f5e6200012760003960008181610999015281816122230152613aa301526000818161075f01528181612d720152613d9d0152600081816108f3015281816112f0015281816114a001528181611f8a0152613c8c0152615f5e6000f3fe60806040523480156200001157600080fd5b50600436106200029e5760003560e01c80630645af0914620002a3578063066ec01214620002bc578063080b311114620002e85780630a0d9fbe14620003105780630e36f582146200032b57806311f6b287146200034257806312b86e1914620003595780631489ed10146200037057806315064c9614620003875780631608859c14620003955780631796a1ae14620003ac5780631816b7e514620003d35780632072f6c514620003ea578063248a9ca314620003f457806325280169146200041a5780632f2ff15d14620004cf57806336568abe14620004e6578063394218e914620004fd578063477fa270146200051457806355a71ee0146200051d57806360469169146200056157806365c0504d146200056b5780637222020f146200061a578063727885e914620006315780637975fcfe14620006485780637fb6e76a146200066e578063841b24d7146200069757806387c20c0114620006b25780638bd4f07114620006c957806391d1485414620006e057806399f5634e14620006f75780639a908e7314620007015780639c9f3dfe1462000718578063a066215c146200072f578063a217fddf1462000746578063a2967d99146200074f578063a3c573eb1462000759578063afd23cbe1462000790578063b99d0ad714620007ba578063c1acbc341462000892578063c4c928c214620008ad578063ceee281d14620008c4578063d02103ca14620008ed578063d5073f6f1462000915578063d547741f146200092c578063d939b3151462000943578063dbc169761462000957578063dde0ff771462000961578063e0bfd3d2146200097c578063e46761c41462000993578063f34eb8eb14620009bb578063f4e9267514620009d2578063f9c4c2ae14620009e3575b600080fd5b620002ba620002b436600462004754565b62000afa565b005b608454620002d0906001600160401b031681565b604051620002df91906200482f565b60405180910390f35b620002ff620002f936600462004858565b62000f4c565b6040519015158152602001620002df565b608554620002d090600160401b90046001600160401b031681565b620002ba6200033c36600462004890565b62000f76565b620002d0620003533660046200491b565b62001224565b620002ba6200036a3660046200494c565b62001244565b620002ba62000381366004620049e3565b620013f4565b606f54620002ff9060ff1681565b620002ba620003a636600462004858565b62001584565b607e54620003bd9063ffffffff1681565b60405163ffffffff9091168152602001620002df565b620002ba620003e436600462004a6d565b62001619565b620002ba620016c5565b6200040b6200040536600462004a9a565b6200175b565b604051908152602001620002df565b6200049b6200042b36600462004858565b60408051606080820183526000808352602080840182905292840181905263ffffffff959095168552608182528285206001600160401b03948516865260030182529382902082519485018352805485526001015480841691850191909152600160401b90049091169082015290565b60408051825181526020808401516001600160401b03908116918301919091529282015190921690820152606001620002df565b620002ba620004e036600462004ab4565b62001770565b620002ba620004f736600462004ab4565b62001792565b620002ba6200050e36600462004ae7565b620017cc565b6086546200040b565b6200040b6200052e36600462004858565b63ffffffff821660009081526081602090815260408083206001600160401b038516845260020190915290205492915050565b6200040b6200187b565b620005d06200057c3660046200491b565b607f602052600090815260409020805460018201546002909201546001600160a01b0391821692918216916001600160401b03600160a01b8204169160ff600160e01b8304811692600160e81b9004169086565b604080516001600160a01b0397881681529690951660208701526001600160401b039093169385019390935260ff166060840152901515608083015260a082015260c001620002df565b620002ba6200062b3660046200491b565b62001893565b620002ba6200064236600462004baf565b6200197e565b6200065f6200065936600462004c7c565b62001de6565b604051620002df919062004d36565b620003bd6200067f36600462004ae7565b60836020526000908152604090205463ffffffff1681565b608454620002d090600160c01b90046001600160401b031681565b620002ba620006c3366004620049e3565b62001e19565b620002ba620006da3660046200494c565b6200213d565b620002ff620006f136600462004ab4565b620021f3565b6200040b6200221e565b620002d06200071236600462004d4b565b6200230a565b620002ba6200072936600462004ae7565b620024d7565b620002ba6200074036600462004ae7565b6200257a565b6200040b600081565b6200040b62002619565b620007817f000000000000000000000000000000000000000000000000000000000000000081565b604051620002df919062004d78565b608554620007a690600160801b900461ffff1681565b60405161ffff9091168152602001620002df565b62000850620007cb36600462004858565b604080516080808201835260008083526020808401829052838501829052606093840182905263ffffffff969096168152608186528381206001600160401b03958616825260040186528390208351918201845280548086168352600160401b9004909416948101949094526001830154918401919091526002909101549082015290565b604051620002df919081516001600160401b03908116825260208084015190911690820152604082810151908201526060918201519181019190915260800190565b608454620002d090600160801b90046001600160401b031681565b620002ba620008be36600462004d8c565b620029db565b620003bd620008d536600462004e24565b60826020526000908152604090205463ffffffff1681565b620007817f000000000000000000000000000000000000000000000000000000000000000081565b620002ba6200092636600462004a9a565b62002ca8565b620002ba6200093d36600462004ab4565b62002d33565b608554620002d0906001600160401b031681565b620002ba62002d55565b608454620002d090600160401b90046001600160401b031681565b620002ba6200098d36600462004e56565b62002df2565b620007817f000000000000000000000000000000000000000000000000000000000000000081565b620002ba620009cc36600462004ed2565b62002e7c565b608054620003bd9063ffffffff1681565b62000a7a620009f43660046200491b565b608160205260009081526040902080546001820154600583015460068401546007909401546001600160a01b0380851695600160a01b958690046001600160401b039081169692861695929092048216939282821692600160401b808404821693600160801b808204841694600160c01b90920484169380831693830416910460ff168c565b604080516001600160a01b039d8e1681526001600160401b039c8d1660208201529c909a16998c019990995296891660608b015260808a019590955292871660a089015290861660c0880152851660e0870152841661010086015283166101208501529190911661014083015260ff1661016082015261018001620002df565b600054600290610100900460ff1615801562000b1d575060005460ff8083169116105b62000b455760405162461bcd60e51b815260040162000b3c9062004f69565b60405180910390fd5b6000805461010060ff841661ffff199092169190911717905560858054608480546001600160c01b0316600160c01b6001600160401b038e8116919091029190911790915567016345785d8a00006086558c166001600160801b03199091161760e160431b1761ffff60801b19166101f560811b17905562000bc662003067565b62000be160008051602062005f098339815191528c620030d4565b62000bee600088620030d4565b62000c0960008051602062005de983398151915288620030d4565b62000c2460008051602062005e6983398151915288620030d4565b62000c3f60008051602062005d8983398151915288620030d4565b62000c5a60008051602062005dc983398151915289620030d4565b62000c7560008051602062005ee983398151915289620030d4565b62000c9060008051602062005e0983398151915289620030d4565b62000cab60008051602062005e8983398151915289620030d4565b62000cd560008051602062005f0983398151915260008051602062005d69833981519152620030e0565b62000cf060008051602062005d6983398151915289620030d4565b62000d0b60008051602062005da983398151915289620030d4565b62000d3560008051602062005ec983398151915260008051602062005ea9833981519152620030e0565b62000d5060008051602062005ec983398151915287620030d4565b62000d6b60008051602062005ea983398151915287620030d4565b6073546074546001600160401b03600160401b9092048216911680821462000da657604051632e4cc54360e11b815260040160405180910390fd5b600062000dce888888886000607460009054906101000a90046001600160401b031662003135565b6001600160401b03838116600081815260756020908152604080832054600287018352818420558885168084526072808452828520600389018552948390208554815560018087018054919092018054918a166001600160401b03198084168217835593546001600160801b0319938416909117600160401b918290048c1682021790915560068b018054909216909417938802939093179092556007880180549092169095179055607a54606f54949092529154607354925163176b20e160e31b81529596506001600160a01b038e81169663bb5907089662000ed09694831695600160581b90950490921693607693607793909291169060040162005063565b600060405180830381600087803b15801562000eeb57600080fd5b505af115801562000f00573d6000803e3d6000fd5b50506000805461ff0019169055505060405160ff8516815260008051602062005e498339815191529350602001915062000f379050565b60405180910390a15050505050505050505050565b63ffffffff8216600090815260816020526040812062000f6d908362003363565b90505b92915050565b600054600290610100900460ff1615801562000f99575060005460ff8083169116105b62000fb85760405162461bcd60e51b815260040162000b3c9062004f69565b6000805461010060ff841661ffff199092169190911717905560858054608480546001600160c01b0316600160c01b6001600160401b038a8116919091029190911790915567016345785d8a000060865588166001600160801b03199091161760e160431b1761ffff60801b19166101f560811b1790556200103962003067565b6200105460008051602062005f0983398151915288620030d4565b62001061600084620030d4565b6200107c60008051602062005de983398151915284620030d4565b6200109760008051602062005e6983398151915284620030d4565b620010b260008051602062005d8983398151915284620030d4565b620010cd60008051602062005dc983398151915285620030d4565b620010e860008051602062005ee983398151915285620030d4565b6200110360008051602062005e0983398151915285620030d4565b6200111e60008051602062005e8983398151915285620030d4565b6200114860008051602062005f0983398151915260008051602062005d69833981519152620030e0565b6200116360008051602062005d6983398151915285620030d4565b6200117e60008051602062005da983398151915285620030d4565b620011a860008051602062005ec983398151915260008051602062005ea9833981519152620030e0565b620011c360008051602062005ec983398151915283620030d4565b620011de60008051602062005ea983398151915283620030d4565b620011eb600033620030d4565b6000805461ff001916905560405160ff8216815260008051602062005e498339815191529060200160405180910390a150505050505050565b63ffffffff8116600090815260816020526040812062000f7090620033a8565b60008051602062005f098339815191526200125f8162003419565b63ffffffff8916600090815260816020526040902062001286818a8a8a8a8a8a8a62003425565b600681018054600160401b600160801b031916600160401b6001600160401b0389811691820292909217835560009081526002840160205260409020869055600583018790559054600160801b90041615620012ee576006810180546001600160801b031690555b7f00000000000000000000000000000000000000000000000000000000000000006001600160a01b03166333d6247d6200132762002619565b6040518263ffffffff1660e01b81526004016200134691815260200190565b600060405180830381600087803b1580156200136157600080fd5b505af115801562001376573d6000803e3d6000fd5b5050608480546001600160c01b031661127560c71b1790555050604080516001600160401b03881681526020810186905290810186905233606082015263ffffffff8b16907f3182bd6e6f74fc1fdc88b60f3a4f4c7f79db6ae6f5b88a1b3f5a1e28ec210d5e9060800160405180910390a250505050505050505050565b60008051602062005f098339815191526200140f8162003419565b63ffffffff8916600090815260816020526040902062001436818a8a8a8a8a8a8a620037ad565b600681018054600160401b600160801b031916600160401b6001600160401b038a811691820292909217835560009081526002840160205260409020879055600583018890559054600160801b900416156200149e576006810180546001600160801b031690555b7f00000000000000000000000000000000000000000000000000000000000000006001600160a01b03166333d6247d620014d762002619565b6040518263ffffffff1660e01b8152600401620014f691815260200190565b600060405180830381600087803b1580156200151157600080fd5b505af115801562001526573d6000803e3d6000fd5b50505050336001600160a01b03168a63ffffffff167fd1ec3a1216f08b6eff72e169ceb548b782db18a6614852618d86bb19f3f9b0d389888a6040516200157093929190620050c9565b60405180910390a350505050505050505050565b63ffffffff82166000908152608160205260409020620015b460008051602062005f0983398151915233620021f3565b6200160857606f5460ff1615620015de57604051630bc011ff60e21b815260040160405180910390fd5b620015ea818362003363565b6200160857604051630674f25160e11b815260040160405180910390fd5b62001614818362003ba9565b505050565b60008051602062005e89833981519152620016348162003419565b6103e88261ffff1610806200164e57506103ff8261ffff16115b156200166d57604051630984a67960e31b815260040160405180910390fd5b6085805461ffff60801b1916600160801b61ffff8516908102919091179091556040519081527f7019933d795eba185c180209e8ae8bffbaa25bcef293364687702c31f4d302c5906020015b60405180910390a15050565b620016e060008051602062005ec983398151915233620021f3565b6200174f57608454600160801b90046001600160401b031615806200173057506084544290620017259062093a8090600160801b90046001600160401b031662005100565b6001600160401b0316115b156200174f5760405163692baaad60e11b815260040160405180910390fd5b6200175962003d9b565b565b60009081526034602052604090206001015490565b6200177b826200175b565b620017868162003419565b62001614838362003e1a565b6001600160a01b0381163314620017bc57604051630b4ad1cd60e31b815260040160405180910390fd5b620017c8828262003e86565b5050565b60008051602062005e89833981519152620017e78162003419565b606f5460ff1662001829576084546001600160401b03600160c01b909104811690831610620018295760405163401636df60e01b815260040160405180910390fd5b608480546001600160c01b0316600160c01b6001600160401b038516021790556040517f1f4fa24c2e4bad19a7f3ec5c5485f70d46c798461c2e684f55bbd0fc661373a190620016b99084906200482f565b600060865460646200188e91906200512a565b905090565b60008051602062005dc9833981519152620018ae8162003419565b63ffffffff82161580620018cd5750607e5463ffffffff908116908316115b15620018ec57604051637512e5cb60e01b815260040160405180910390fd5b63ffffffff82166000908152607f60205260409020600180820154600160e81b900460ff16151590036200193357604051633b8d3d9960e01b815260040160405180910390fd5b60018101805460ff60e81b1916600160e81b17905560405163ffffffff8416907f4710d2ee567ef1ed6eb2f651dde4589524bcf7cebc62147a99b281cc836e7e4490600090a2505050565b60008051602062005ee9833981519152620019998162003419565b63ffffffff88161580620019b85750607e5463ffffffff908116908916115b15620019d757604051637512e5cb60e01b815260040160405180910390fd5b63ffffffff88166000908152607f60205260409020600180820154600160e81b900460ff161515900362001a1e57604051633b8d3d9960e01b815260040160405180910390fd5b6001600160401b03881660009081526083602052604090205463ffffffff161562001a5c576040516337c8fe0960e11b815260040160405180910390fd5b6080805460009190829062001a779063ffffffff1662005144565b825463ffffffff8281166101009490940a9384029302191691909117909155825460408051600080825260208201928390529394506001600160a01b0390921691309162001ac59062004718565b62001ad3939291906200516a565b604051809103906000f08015801562001af0573d6000803e3d6000fd5b50905081608360008c6001600160401b03166001600160401b0316815260200190815260200160002060006101000a81548163ffffffff021916908363ffffffff1602179055508160826000836001600160a01b03166001600160a01b0316815260200190815260200160002060006101000a81548163ffffffff021916908363ffffffff1602179055506000608160008463ffffffff1663ffffffff1681526020019081526020016000209050818160000160006101000a8154816001600160a01b0302191690836001600160a01b031602179055508360010160149054906101000a90046001600160401b03168160010160146101000a8154816001600160401b0302191690836001600160401b031602179055508360010160009054906101000a90046001600160a01b03168160010160006101000a8154816001600160a01b0302191690836001600160a01b031602179055508a8160000160146101000a8154816001600160401b0302191690836001600160401b031602179055508360020154816002016000806001600160401b03168152602001908152602001600020819055508b63ffffffff168160070160086101000a8154816001600160401b0302191690836001600160401b0316021790555083600101601c9054906101000a900460ff168160070160106101000a81548160ff021916908360ff1602179055508263ffffffff167f194c983456df6701c6a50830b90fe80e72b823411d0d524970c9590dc277a6418d848e8c60405162001d64949392919063ffffffff9490941684526001600160a01b0392831660208501526001600160401b0391909116604084015216606082015260800190565b60405180910390a2604051633892b81160e11b81526001600160a01b0383169063712570229062001da4908d908d9088908e908e908e90600401620051a1565b600060405180830381600087803b15801562001dbf57600080fd5b505af115801562001dd4573d6000803e3d6000fd5b50505050505050505050505050505050565b63ffffffff8616600090815260816020526040902060609062001e0e90878787878762003ef0565b979650505050505050565b606f5460ff161562001e3e57604051630bc011ff60e21b815260040160405180910390fd5b63ffffffff881660009081526081602090815260408083206084546001600160401b038a81168652600383019094529190932060010154429262001e8d92600160c01b90048116911662005100565b6001600160401b0316111562001eb657604051638a0704d360e01b815260040160405180910390fd5b6103e862001ec5888862005204565b6001600160401b0316111562001eee57604051635acfba9d60e11b815260040160405180910390fd5b62001f008189898989898989620037ad565b62001f0c81876200402b565b6085546001600160401b03166000036200201a57600681018054600160401b600160801b031916600160401b6001600160401b0389811691820292909217835560009081526002840160205260409020869055600583018790559054600160801b9004161562001f88576006810180546001600160801b031690555b7f00000000000000000000000000000000000000000000000000000000000000006001600160a01b03166333d6247d62001fc162002619565b6040518263ffffffff1660e01b815260040162001fe091815260200190565b600060405180830381600087803b15801562001ffb57600080fd5b505af115801562002010573d6000803e3d6000fd5b50505050620020e4565b620020258162004228565b600681018054600160801b90046001600160401b0316906010620020498362005227565b82546001600160401b039182166101009390930a92830292820219169190911790915560408051608081018252428316815289831660208083019182528284018b8152606084018b81526006890154600160801b90048716600090815260048a01909352949091209251835492518616600160401b026001600160801b03199093169516949094171781559151600183015551600290910155505b336001600160a01b03168963ffffffff167faac1e7a157b259544ebacd6e8a82ae5d6c8f174e12aa48696277bcc9a661f0b48887896040516200212a93929190620050c9565b60405180910390a3505050505050505050565b606f5460ff16156200216257604051630bc011ff60e21b815260040160405180910390fd5b63ffffffff8816600090815260816020526040902062002189818989898989898962003425565b6001600160401b03851660009081526002820160209081526040918290205482519081529081018590527f1f44c21118c4603cfb4e1b621dbcfa2b73efcececee2b99b620b2953d33a7010910160405180910390a1620021e862003d9b565b505050505050505050565b60009182526034602090815260408084206001600160a01b0393909316845291905290205460ff1690565b6000807f00000000000000000000000000000000000000000000000000000000000000006001600160a01b03166370a08231306040518263ffffffff1660e01b81526004016200226f919062004d78565b602060405180830381865afa1580156200228d573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190620022b391906200524e565b608454909150600090620022da906001600160401b03600160401b82048116911662005204565b6001600160401b0316905080600003620022f75760009250505090565b6200230381836200527e565b9250505090565b606f5460009060ff16156200233257604051630bc011ff60e21b815260040160405180910390fd5b3360009081526082602052604081205463ffffffff16908190036200236a576040516371653c1560e01b815260040160405180910390fd5b836001600160401b03166000036200239557604051632590ccf960e01b815260040160405180910390fd5b63ffffffff811660009081526081602052604081206084805491928792620023c89084906001600160401b031662005100565b82546101009290920a6001600160401b0381810219909316918316021790915560068301541690506000620023fe878362005100565b6006840180546001600160401b038084166001600160401b03199092168217909255604080516060810182528a81524284166020808301918252888616838501908152600095865260038b0190915292909320905181559151600192909201805491518416600160401b026001600160801b0319909216929093169190911717905590506200248d8362004228565b8363ffffffff167f1d9f30260051d51d70339da239ea7b080021adcaabfa71c9b0ea339a20cf9a2582604051620024c591906200482f565b60405180910390a29695505050505050565b60008051602062005e89833981519152620024f28162003419565b606f5460ff166200252d576085546001600160401b03908116908316106200252d5760405163048a05a960e41b815260040160405180910390fd5b608580546001600160401b0319166001600160401b0384161790556040517fc4121f4e22c69632ebb7cf1f462be0511dc034f999b52013eddfb24aab765c7590620016b99084906200482f565b60008051602062005e89833981519152620025958162003419565b62015180826001600160401b03161115620025c357604051631c0cfbfd60e31b815260040160405180910390fd5b60858054600160401b600160801b031916600160401b6001600160401b038516021790556040517f1b023231a1ab6b5d93992f168fb44498e1a7e64cef58daff6f1c216de6a68c2890620016b99084906200482f565b60805460009063ffffffff168082036200263557506000919050565b6000816001600160401b0381111562002652576200265262004b05565b6040519080825280602002602001820160405280156200267c578160200160208202803683370190505b50905060005b82811015620026ef57608160006200269c83600162005295565b63ffffffff1663ffffffff16815260200190815260200160002060050154828281518110620026cf57620026cf620052ab565b602090810291909101015280620026e681620052c1565b91505062002682565b50600060205b83600114620029335760006200270d600286620052dd565b6200271a6002876200527e565b62002726919062005295565b90506000816001600160401b0381111562002745576200274562004b05565b6040519080825280602002602001820160405280156200276f578160200160208202803683370190505b50905060005b82811015620028e7576200278b600184620052f4565b81148015620027a65750620027a2600288620052dd565b6001145b15620028265785620027ba8260026200512a565b81518110620027cd57620027cd620052ab565b602002602001015185604051602001620027e99291906200530a565b60405160208183030381529060405280519060200120828281518110620028145762002814620052ab565b602002602001018181525050620028d2565b85620028348260026200512a565b81518110620028475762002847620052ab565b6020026020010151868260026200285f91906200512a565b6200286c90600162005295565b815181106200287f576200287f620052ab565b60200260200101516040516020016200289a9291906200530a565b60405160208183030381529060405280519060200120828281518110620028c557620028c5620052ab565b6020026020010181815250505b80620028de81620052c1565b91505062002775565b508094508195508384604051602001620029039291906200530a565b6040516020818303038152906040528051906020012093508280620029289062005318565b9350505050620026f5565b6000836000815181106200294b576200294b620052ab565b6020026020010151905060005b82811015620029d1578184604051602001620029769291906200530a565b6040516020818303038152906040528051906020012091508384604051602001620029a39291906200530a565b6040516020818303038152906040528051906020012093508080620029c890620052c1565b91505062002958565b5095945050505050565b60008051602062005d89833981519152620029f68162003419565b63ffffffff8416158062002a155750607e5463ffffffff908116908516115b1562002a3457604051637512e5cb60e01b815260040160405180910390fd5b6001600160a01b03851660009081526082602052604081205463ffffffff169081900362002a75576040516374a086a360e01b815260040160405180910390fd5b63ffffffff8181166000908152608160205260409020600781015490918716600160401b9091046001600160401b03160362002ac457604051634f61d51960e01b815260040160405180910390fd5b63ffffffff86166000908152607f60205260409020600180820154600160e81b900460ff161515900362002b0b57604051633b8d3d9960e01b815260040160405180910390fd5b60018101546007830154600160801b900460ff908116600160e01b909204161462002b4957604051635aa0d5f160e11b815260040160405180910390fd5b6001808201805491840180546001600160a01b031981166001600160a01b03909416938417825591546001600160401b03600160a01b9182900416026001600160e01b0319909216909217179055600782018054600160401b63ffffffff8a1602600160401b600160801b0319909116179055600062002bc98462001224565b6007840180546001600160401b0319166001600160401b038316179055825460405163278f794360e11b81529192506001600160a01b038b811692634f1ef2869262002c1e9216908b908b9060040162005332565b600060405180830381600087803b15801562002c3957600080fd5b505af115801562002c4e573d6000803e3d6000fd5b50506040805163ffffffff8c811682526001600160401b0386166020830152881693507ff585e04c05d396901170247783d3e5f0ee9c1df23072985b50af089f5e48b19d92500160405180910390a2505050505050505050565b60008051602062005da983398151915262002cc38162003419565b683635c9adc5dea0000082118062002cde5750633b9aca0082105b1562002cfd57604051638586952560e01b815260040160405180910390fd5b60868290556040518281527ffb383653f53ee079978d0c9aff7aeff04a10166ce244cca9c9f9d8d96bed45b290602001620016b9565b62002d3e826200175b565b62002d498162003419565b62001614838362003e86565b60008051602062005e0983398151915262002d708162003419565b7f00000000000000000000000000000000000000000000000000000000000000006001600160a01b031663dbc169766040518163ffffffff1660e01b8152600401600060405180830381600087803b15801562002dcc57600080fd5b505af115801562002de1573d6000803e3d6000fd5b5050505062002def620042f3565b50565b60008051602062005e6983398151915262002e0d8162003419565b6001600160401b03841660009081526083602052604090205463ffffffff161562002e4b576040516337c8fe0960e11b815260040160405180910390fd5b600062002e5e8888888887600062003135565b60008080526002909101602052604090209390935550505050505050565b60008051602062005de983398151915262002e978162003419565b607e805460009190829062002eb29063ffffffff1662005144565b91906101000a81548163ffffffff021916908363ffffffff160217905590506040518060c00160405280896001600160a01b03168152602001886001600160a01b03168152602001876001600160401b031681526020018660ff16815260200160001515815260200185815250607f60008363ffffffff1663ffffffff16815260200190815260200160002060008201518160000160006101000a8154816001600160a01b0302191690836001600160a01b0316021790555060208201518160010160006101000a8154816001600160a01b0302191690836001600160a01b0316021790555060408201518160010160146101000a8154816001600160401b0302191690836001600160401b03160217905550606082015181600101601c6101000a81548160ff021916908360ff160217905550608082015181600101601d6101000a81548160ff02191690831515021790555060a082015181600201559050508063ffffffff167fa2970448b3bd66ba7e524e7b2a5b9cf94fa29e32488fb942afdfe70dd4b77b52898989898989604051620030559695949392919062005372565b60405180910390a25050505050505050565b600054610100900460ff16620017595760405162461bcd60e51b815260206004820152602b60248201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960448201526a6e697469616c697a696e6760a81b606482015260840162000b3c565b620017c8828262003e1a565b6000620030ed836200175b565b600084815260346020526040808220600101859055519192508391839186917fbd79b86ffe0ab8e8776151514217cd7cacd52c909f66475c3af44e129f0b00ff9190a4505050565b6080805460009182918290620031519063ffffffff1662005144565b91906101000a81548163ffffffff021916908363ffffffff160217905590508060836000876001600160401b03166001600160401b0316815260200190815260200160002060006101000a81548163ffffffff021916908363ffffffff16021790555080608260008a6001600160a01b03166001600160a01b0316815260200190815260200160002060006101000a81548163ffffffff021916908363ffffffff160217905550608160008263ffffffff1663ffffffff1681526020019081526020016000209150878260000160006101000a8154816001600160a01b0302191690836001600160a01b03160217905550858260010160146101000a8154816001600160401b0302191690836001600160401b03160217905550868260010160006101000a8154816001600160a01b0302191690836001600160a01b03160217905550848260000160146101000a8154816001600160401b0302191690836001600160401b03160217905550838260070160106101000a81548160ff021916908360ff1602179055508063ffffffff167fadfc7d56f7e39b08b321534f14bfb135ad27698f7d2f5ad0edc2356ea9a3f850878a888888604051620033509594939291906001600160401b0395861681526001600160a01b03949094166020850152918416604084015260ff166060830152909116608082015260a00190565b60405180910390a2509695505050505050565b6085546001600160401b038281166000908152600485016020526040812054909242926200339692918116911662005100565b6001600160401b031611159392505050565b6006810154600090600160801b90046001600160401b031615620033fc575060068101546001600160401b03600160801b909104811660009081526004909201602052604090912054600160401b90041690565b5060060154600160401b90046001600160401b031690565b919050565b62002def81336200434c565b60078801546000906001600160401b0390811690871610156200345b5760405163ead1340b60e01b815260040160405180910390fd5b6001600160401b03881615620034fc5760068901546001600160401b03600160801b90910481169089161115620034a55760405163bb14c20560e01b815260040160405180910390fd5b506001600160401b03808816600090815260048a0160205260409020600281015481549092888116600160401b9092041614620034f557604051632bd2e3e760e01b815260040160405180910390fd5b5062003571565b506001600160401b03851660009081526002890160205260409020548062003537576040516324cbdcc360e11b815260040160405180910390fd5b60068901546001600160401b03600160401b909104811690871611156200357157604051630f2b74f160e11b815260040160405180910390fd5b60068901546001600160401b03600160801b90910481169088161180620035aa5750876001600160401b0316876001600160401b031611155b80620035ce575060068901546001600160401b03600160c01b909104811690881611155b15620035ed5760405163bfa7079f60e01b815260040160405180910390fd5b6001600160401b03878116600090815260048b016020526040902054600160401b900481169086161462003634576040516332a2a77f60e01b815260040160405180910390fd5b6000620036468a888888868962003ef0565b9050600060008051602062005e298339815191526002836040516200366c9190620053cb565b602060405180830381855afa1580156200368a573d6000803e3d6000fd5b5050506040513d601f19601f82011682018060405250810190620036af91906200524e565b620036bb9190620052dd565b60018c0154604080516020810182528381529051634890ed4560e11b81529293506001600160a01b0390911691639121da8a91620036ff91889190600401620053e9565b602060405180830381865afa1580156200371d573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019062003743919062005426565b62003761576040516309bde33960e01b815260040160405180910390fd5b6001600160401b038916600090815260048c016020526040902060020154859003620037a05760405163a47276bd60e01b815260040160405180910390fd5b5050505050505050505050565b600080620037bb8a620033a8565b60078b01549091506001600160401b039081169089161015620037f15760405163ead1340b60e01b815260040160405180910390fd5b6001600160401b03891615620038945760068a01546001600160401b03600160801b9091048116908a1611156200383b5760405163bb14c20560e01b815260040160405180910390fd5b6001600160401b03808a16600090815260048c01602052604090206002810154815490945090918a8116600160401b90920416146200388d57604051632bd2e3e760e01b815260040160405180910390fd5b5062003904565b6001600160401b038816600090815260028b016020526040902054915081620038d0576040516324cbdcc360e11b815260040160405180910390fd5b806001600160401b0316886001600160401b031611156200390457604051630f2b74f160e11b815260040160405180910390fd5b806001600160401b0316876001600160401b031611620039375760405163b9b18f5760e01b815260040160405180910390fd5b6000620039498b8a8a8a878b62003ef0565b9050600060008051602062005e298339815191526002836040516200396f9190620053cb565b602060405180830381855afa1580156200398d573d6000803e3d6000fd5b5050506040513d601f19601f82011682018060405250810190620039b291906200524e565b620039be9190620052dd565b60018d0154604080516020810182528381529051634890ed4560e11b81529293506001600160a01b0390911691639121da8a9162003a0291899190600401620053e9565b602060405180830381865afa15801562003a20573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019062003a46919062005426565b62003a64576040516309bde33960e01b815260040160405180910390fd5b600062003a72848b62005204565b905062003acb87826001600160401b031662003a8d6200221e565b62003a9991906200512a565b6001600160a01b037f000000000000000000000000000000000000000000000000000000000000000016919062004376565b80608460088282829054906101000a90046001600160401b031662003af1919062005100565b82546101009290920a6001600160401b0381810219909316918316021790915560848054600160801b600160c01b031916600160801b428416021790558e546040516332c2d15360e01b8152918d166004830152602482018b90523360448301526001600160a01b031691506332c2d15390606401600060405180830381600087803b15801562003b8157600080fd5b505af115801562003b96573d6000803e3d6000fd5b5050505050505050505050505050505050565b60068201546001600160401b03600160c01b909104811690821611158062003be8575060068201546001600160401b03600160801b9091048116908216115b1562003c075760405163d086b70b60e01b815260040160405180910390fd5b6001600160401b03818116600081815260048501602090815260408083208054600689018054600160401b600160801b031916600160401b92839004909816918202979097178755600280830154828752908a0190945291909320919091556001820154600587015583546001600160c01b0316600160c01b909302929092179092557f00000000000000000000000000000000000000000000000000000000000000006001600160a01b03166333d6247d62003cc362002619565b6040518263ffffffff1660e01b815260040162003ce291815260200190565b600060405180830381600087803b15801562003cfd57600080fd5b505af115801562003d12573d6000803e3d6000fd5b505085546001600160a01b0316600090815260826020908152604091829020546002870154600188015484516001600160401b03898116825294810192909252818501529188166060830152915163ffffffff90921693507f581910eb7a27738945c2f00a91f2284b2d6de9d4e472b12f901c2b0df045e21b925081900360800190a250505050565b7f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316632072f6c56040518163ffffffff1660e01b8152600401600060405180830381600087803b15801562003df757600080fd5b505af115801562003e0c573d6000803e3d6000fd5b5050505062001759620043ca565b62003e268282620021f3565b620017c85760008281526034602090815260408083206001600160a01b0385168085529252808320805460ff1916600117905551339285917f2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d9190a45050565b62003e928282620021f3565b15620017c85760008281526034602090815260408083206001600160a01b0385168085529252808320805460ff1916905551339285917ff6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b9190a45050565b6001600160401b038086166000818152600389016020526040808220549388168252902054606092911580159062003f26575081155b1562003f455760405163340c614f60e11b815260040160405180910390fd5b8062003f64576040516366385b5160e01b815260040160405180910390fd5b62003f6f8462004427565b62003f8d576040516305dae44f60e21b815260040160405180910390fd5b885460018a01546040516001600160601b03193360601b16602082015260348101889052605481018590526001600160c01b031960c08c811b82166074840152600160a01b94859004811b8216607c84015293909204831b82166084820152608c810187905260ac810184905260cc81018990529189901b1660ec82015260f401604051602081830303815290604052925050509695505050505050565b60006200403883620033a8565b9050816000806200404a848462005204565b6085546001600160401b0391821692506000916200407191600160401b90041642620052f4565b90505b846001600160401b0316846001600160401b031614620040fb576001600160401b03808516600090815260038901602052604090206001810154909116821015620040d6576001810154600160401b90046001600160401b03169450620040f4565b620040e2868662005204565b6001600160401b0316935050620040fb565b5062004074565b6000620041098484620052f4565b9050838110156200416757808403600c81116200412757806200412a565b600c5b9050806103e80a81608560109054906101000a900461ffff1661ffff160a60865402816200415c576200415c62005268565b0460865550620041df565b838103600c81116200417a57806200417d565b600c5b90506000816103e80a82608560109054906101000a900461ffff1661ffff160a670de0b6b3a76400000281620041b757620041b762005268565b04905080608654670de0b6b3a76400000281620041d857620041d862005268565b0460865550505b683635c9adc5dea0000060865411156200420657683635c9adc5dea000006086556200421e565b633b9aca0060865410156200421e57633b9aca006086555b5050505050505050565b60068101546001600160401b03600160c01b82048116600160801b90920416111562002def5760068101546000906200427390600160c01b90046001600160401b0316600162005100565b905062004281828262003363565b15620017c8576006820154600090600290620042af908490600160801b90046001600160401b031662005204565b620042bb91906200544a565b620042c7908362005100565b9050620042d5838262003363565b15620042e75762001614838262003ba9565b62001614838362003ba9565b606f5460ff166200431757604051635386698160e01b815260040160405180910390fd5b606f805460ff191690556040517f1e5e34eea33501aecf2ebec9fe0e884a40804275ea7fe10b2ba084c8374308b390600090a1565b620043588282620021f3565b620017c857604051637615be1f60e11b815260040160405180910390fd5b604080516001600160a01b038416602482015260448082018490528251808303909101815260649091019091526020810180516001600160e01b031663a9059cbb60e01b17905262001614908490620044ad565b606f5460ff1615620043ef57604051630bc011ff60e21b815260040160405180910390fd5b606f805460ff191660011790556040517f2261efe5aef6fedc1fd1550b25facc9181745623049c7901287030b9ad1a549790600090a1565b600067ffffffff000000016001600160401b0383161080156200445e575067ffffffff00000001604083901c6001600160401b0316105b80156200447f575067ffffffff00000001608083901c6001600160401b0316105b801562004497575067ffffffff0000000160c083901c105b15620044a557506001919050565b506000919050565b600062004504826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c6564815250856001600160a01b0316620045869092919063ffffffff16565b80519091501562001614578080602001905181019062004525919062005426565b620016145760405162461bcd60e51b815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e6044820152691bdd081cdd58d8d9595960b21b606482015260840162000b3c565b60606200459784846000856200459f565b949350505050565b606082471015620046025760405162461bcd60e51b815260206004820152602660248201527f416464726573733a20696e73756666696369656e742062616c616e636520666f6044820152651c8818d85b1b60d21b606482015260840162000b3c565b600080866001600160a01b03168587604051620046209190620053cb565b60006040518083038185875af1925050503d80600081146200465f576040519150601f19603f3d011682016040523d82523d6000602084013e62004664565b606091505b509150915062001e0e8783838760608315620046e5578251600003620046dd576001600160a01b0385163b620046dd5760405162461bcd60e51b815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000604482015260640162000b3c565b508162004597565b620045978383815115620046fc5781518083602001fd5b8060405162461bcd60e51b815260040162000b3c919062004d36565b6108f5806200547483390190565b6001600160a01b038116811462002def57600080fd5b80356001600160401b03811681146200341457600080fd5b6000806000806000806000806000806101408b8d0312156200477557600080fd5b8a35620047828162004726565b99506200479260208c016200473c565b9850620047a260408c016200473c565b975060608b0135620047b48162004726565b965060808b0135620047c68162004726565b955060a08b0135620047d88162004726565b945060c08b0135620047ea8162004726565b935060e08b0135620047fc8162004726565b92506200480d6101008c016200473c565b91506200481e6101208c016200473c565b90509295989b9194979a5092959850565b6001600160401b0391909116815260200190565b803563ffffffff811681146200341457600080fd5b600080604083850312156200486c57600080fd5b620048778362004843565b915062004887602084016200473c565b90509250929050565b60008060008060008060c08789031215620048aa57600080fd5b8635620048b78162004726565b9550620048c7602088016200473c565b9450620048d7604088016200473c565b93506060870135620048e98162004726565b92506080870135620048fb8162004726565b915060a08701356200490d8162004726565b809150509295509295509295565b6000602082840312156200492e57600080fd5b62000f6d8262004843565b80610300810183101562000f7057600080fd5b6000806000806000806000806103e0898b0312156200496a57600080fd5b620049758962004843565b97506200498560208a016200473c565b96506200499560408a016200473c565b9550620049a560608a016200473c565b9450620049b560808a016200473c565b935060a0890135925060c08901359150620049d48a60e08b0162004939565b90509295985092959890939650565b6000806000806000806000806103e0898b03121562004a0157600080fd5b62004a0c8962004843565b975062004a1c60208a016200473c565b965062004a2c60408a016200473c565b955062004a3c60608a016200473c565b94506080890135935060a0890135925060c089013562004a5c8162004726565b9150620049d48a60e08b0162004939565b60006020828403121562004a8057600080fd5b813561ffff8116811462004a9357600080fd5b9392505050565b60006020828403121562004aad57600080fd5b5035919050565b6000806040838503121562004ac857600080fd5b82359150602083013562004adc8162004726565b809150509250929050565b60006020828403121562004afa57600080fd5b62000f6d826200473c565b634e487b7160e01b600052604160045260246000fd5b600082601f83011262004b2d57600080fd5b81356001600160401b038082111562004b4a5762004b4a62004b05565b604051601f8301601f19908116603f0116810190828211818310171562004b755762004b7562004b05565b8160405283815286602085880101111562004b8f57600080fd5b836020870160208301376000602085830101528094505050505092915050565b600080600080600080600060e0888a03121562004bcb57600080fd5b62004bd68862004843565b965062004be6602089016200473c565b9550604088013562004bf88162004726565b9450606088013562004c0a8162004726565b9350608088013562004c1c8162004726565b925060a08801356001600160401b038082111562004c3957600080fd5b62004c478b838c0162004b1b565b935060c08a013591508082111562004c5e57600080fd5b5062004c6d8a828b0162004b1b565b91505092959891949750929550565b60008060008060008060c0878903121562004c9657600080fd5b62004ca18762004843565b955062004cb1602088016200473c565b945062004cc1604088016200473c565b9350606087013592506080870135915060a087013590509295509295509295565b60005b8381101562004cff57818101518382015260200162004ce5565b50506000910152565b6000815180845262004d2281602086016020860162004ce2565b601f01601f19169290920160200192915050565b60208152600062000f6d602083018462004d08565b6000806040838503121562004d5f57600080fd5b62004d6a836200473c565b946020939093013593505050565b6001600160a01b0391909116815260200190565b6000806000806060858703121562004da357600080fd5b843562004db08162004726565b935062004dc06020860162004843565b925060408501356001600160401b038082111562004ddd57600080fd5b818701915087601f83011262004df257600080fd5b81358181111562004e0257600080fd5b88602082850101111562004e1557600080fd5b95989497505060200194505050565b60006020828403121562004e3757600080fd5b813562004a938162004726565b803560ff811681146200341457600080fd5b60008060008060008060c0878903121562004e7057600080fd5b863562004e7d8162004726565b9550602087013562004e8f8162004726565b945062004e9f604088016200473c565b935062004eaf606088016200473c565b92506080870135915062004ec660a0880162004e44565b90509295509295509295565b60008060008060008060c0878903121562004eec57600080fd5b863562004ef98162004726565b9550602087013562004f0b8162004726565b945062004f1b604088016200473c565b935062004f2b6060880162004e44565b92506080870135915060a08701356001600160401b0381111562004f4e57600080fd5b62004f5c89828a0162004b1b565b9150509295509295509295565b6020808252602e908201527f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160408201526d191e481a5b9a5d1a585b1a5e995960921b606082015260800190565b8054600090600181811c908083168062004fd257607f831692505b6020808410820362004ff457634e487b7160e01b600052602260045260246000fd5b83885260208801828015620050125760018114620050295762005056565b60ff198716825285151560051b8201975062005056565b60008981526020902060005b87811015620050505781548482015290860190840162005035565b83019850505b5050505050505092915050565b6001600160a01b0387811682528616602082015260c060408201819052600090620050919083018762004fb7565b8281036060840152620050a5818762004fb7565b608084019590955250506001600160401b039190911660a090910152949350505050565b6001600160401b039390931683526020830191909152604082015260600190565b634e487b7160e01b600052601160045260246000fd5b6001600160401b03818116838216019080821115620051235762005123620050ea565b5092915050565b808202811582820484141762000f705762000f70620050ea565b600063ffffffff808316818103620051605762005160620050ea565b6001019392505050565b6001600160a01b03848116825283166020820152606060408201819052600090620051989083018462004d08565b95945050505050565b6001600160a01b038781168252868116602083015263ffffffff861660408301528416606082015260c060808201819052600090620051e39083018562004d08565b82810360a0840152620051f7818562004d08565b9998505050505050505050565b6001600160401b03828116828216039080821115620051235762005123620050ea565b60006001600160401b038281166002600160401b03198101620051605762005160620050ea565b6000602082840312156200526157600080fd5b5051919050565b634e487b7160e01b600052601260045260246000fd5b60008262005290576200529062005268565b500490565b8082018082111562000f705762000f70620050ea565b634e487b7160e01b600052603260045260246000fd5b600060018201620052d657620052d6620050ea565b5060010190565b600082620052ef57620052ef62005268565b500690565b8181038181111562000f705762000f70620050ea565b918252602082015260400190565b6000816200532a576200532a620050ea565b506000190190565b6001600160a01b03841681526040602082018190528101829052818360608301376000818301606090810191909152601f909201601f1916010192915050565b6001600160a01b038781168252861660208201526001600160401b038516604082015260ff841660608201526080810183905260c060a08201819052600090620053bf9083018462004d08565b98975050505050505050565b60008251620053df81846020870162004ce2565b9190910192915050565b61032081016103008085843782018360005b60018110156200541c578151835260209283019290910190600101620053fb565b5050509392505050565b6000602082840312156200543957600080fd5b8151801515811462004a9357600080fd5b60006001600160401b038381168062005467576200546762005268565b9216919091049291505056fe60a0604052604051620008f5380380620008f58339810160408190526100249161035b565b82816100308282610058565b50506001600160a01b03821660805261005061004b60805190565b6100b7565b505050610447565b61006182610126565b6040516001600160a01b038316907fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b90600090a28051156100ab576100a682826101a5565b505050565b6100b361021c565b5050565b7f7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f6100f8600080516020620008d5833981519152546001600160a01b031690565b604080516001600160a01b03928316815291841660208301520160405180910390a16101238161023d565b50565b806001600160a01b03163b60000361016157604051634c9c8ce360e01b81526001600160a01b03821660048201526024015b60405180910390fd5b807f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc5b80546001600160a01b0319166001600160a01b039290921691909117905550565b6060600080846001600160a01b0316846040516101c2919061042b565b600060405180830381855af49150503d80600081146101fd576040519150601f19603f3d011682016040523d82523d6000602084013e610202565b606091505b50909250905061021385838361027d565b95945050505050565b341561023b5760405163b398979f60e01b815260040160405180910390fd5b565b6001600160a01b03811661026757604051633173bdd160e11b815260006004820152602401610158565b80600080516020620008d5833981519152610184565b6060826102925761028d826102dc565b6102d5565b81511580156102a957506001600160a01b0384163b155b156102d257604051639996b31560e01b81526001600160a01b0385166004820152602401610158565b50805b9392505050565b8051156102ec5780518082602001fd5b604051630a12f52160e11b815260040160405180910390fd5b80516001600160a01b038116811461031c57600080fd5b919050565b634e487b7160e01b600052604160045260246000fd5b60005b8381101561035257818101518382015260200161033a565b50506000910152565b60008060006060848603121561037057600080fd5b61037984610305565b925061038760208501610305565b60408501519092506001600160401b03808211156103a457600080fd5b818601915086601f8301126103b857600080fd5b8151818111156103ca576103ca610321565b604051601f8201601f19908116603f011681019083821181831017156103f2576103f2610321565b8160405282815289602084870101111561040b57600080fd5b61041c836020830160208801610337565b80955050505050509250925092565b6000825161043d818460208701610337565b9190910192915050565b608051610473620004626000396000601001526104736000f3fe608060405261000c61000e565b005b7f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316330361006a576000356001600160e01b03191663278f794360e11b146100625761006061006e565b565b61006061007e565b6100605b6100606100796100ad565b6100d3565b60008061008e36600481846102cb565b81019061009b919061030b565b915091506100a982826100f7565b5050565b60006100ce60008051602061041e833981519152546001600160a01b031690565b905090565b3660008037600080366000845af43d6000803e8080156100f2573d6000f35b3d6000fd5b61010082610152565b6040516001600160a01b038316907fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b90600090a280511561014a5761014582826101b7565b505050565b6100a961022d565b806001600160a01b03163b6000036101885780604051634c9c8ce360e01b815260040161017f91906103da565b60405180910390fd5b60008051602061041e83398151915280546001600160a01b0319166001600160a01b0392909216919091179055565b6060600080846001600160a01b0316846040516101d491906103ee565b600060405180830381855af49150503d806000811461020f576040519150601f19603f3d011682016040523d82523d6000602084013e610214565b606091505b509150915061022485838361024c565b95945050505050565b34156100605760405163b398979f60e01b815260040160405180910390fd5b6060826102615761025c826102a2565b61029b565b815115801561027857506001600160a01b0384163b155b156102985783604051639996b31560e01b815260040161017f91906103da565b50805b9392505050565b8051156102b25780518082602001fd5b604051630a12f52160e11b815260040160405180910390fd5b600080858511156102db57600080fd5b838611156102e857600080fd5b5050820193919092039150565b634e487b7160e01b600052604160045260246000fd5b6000806040838503121561031e57600080fd5b82356001600160a01b038116811461033557600080fd5b915060208301356001600160401b038082111561035157600080fd5b818501915085601f83011261036557600080fd5b813581811115610377576103776102f5565b604051601f8201601f19908116603f0116810190838211818310171561039f5761039f6102f5565b816040528281528860208487010111156103b857600080fd5b8260208601602083013760006020848301015280955050505050509250929050565b6001600160a01b0391909116815260200190565b6000825160005b8181101561040f57602081860181015185830152016103f5565b50600092019182525091905056fe360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbca2646970667358221220a19e7a72432195d9a35c7ce8fa5f1284415aac66bb1ad08a4c2e1c252fd8690864736f6c63430008140033b53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d610373cb0569fdbea2544dae03fdb2fe10eda92a72a2e8cd2bd496e85b762505a3f066156603fe29d13f97c6f3e3dff4ef71919f9aa61c555be0182d954e94221aac8cf807f6970720f8e2c208c7c5037595982c7bd9ed93c380d09df743d0dcc3fbab66e11c4f712cd06ab11bf9339b48bef39e12d4a22eeef71d2860a0c90482bdac75d24dbb35ea80e25fab167da4dea46c1915260426570db84f184891f5f59062ba6ba2ffed8cfe316b583325ea41ac6e7ba9e5864d2bc6fabba7ac26d2f0f430644e72e131a029b85045b68181585d2833e84879b9709143e1f593f00000017f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb38474024983dfe277d2a2c04b75fb2eb3743fa00005ae3678a20c299e65fdf4df76517f68ea5c5790f581d443ed43873ab47cfb8c5d66a6db268e58b5971bb33fc66e07db19b6f082d8d3644ae2f24a3c32e356d6f2d9b2844d9b26164fbc82663ff285951141f8f32ce6198eee741f695cec728bfd32d289f1acf73621fb303581000545ea0fab074aba36a6fa69f1a83ee86e5abfb8433966eb57efb13dc2fc2f24ddd08084e94f375e9d647f87f5b2ceffba1e062c70f6009fdbcf80291e803b5c9edd4a26469706673582212203f12260f62b0d87f840f477a6be35cf07e8ec905f8d0f0ce1838a89a9200b2cd64736f6c63430008140033 \ No newline at end of file diff --git a/etherman/smartcontracts/bin/mockverifier.bin b/etherman/smartcontracts/bin/mockverifier.bin new file mode 100644 index 0000000..7242a08 --- /dev/null +++ b/etherman/smartcontracts/bin/mockverifier.bin @@ -0,0 +1 @@ +608060405234801561001057600080fd5b50610158806100206000396000f3fe608060405234801561001057600080fd5b506004361061002b5760003560e01c80639121da8a14610030575b600080fd5b61004661003e366004610089565b600192915050565b604051901515815260200160405180910390f35b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b60008061032080848603121561009e57600080fd5b6103008401858111156100b057600080fd5b8493508561031f8601126100c357600080fd5b604051602080820182811067ffffffffffffffff821117156100e7576100e761005a565b6040529286019281888511156100fc57600080fd5b5b8484101561011457833581529281019281016100fd565b50949790965094505050505056fea264697066735822122061fd8311ce6da82f24c0874a992ea14a8aaf711e353693cae56066e3223abc5a64736f6c63430008140033 \ No newline at end of file diff --git a/etherman/smartcontracts/bin/oldpolygonzkevm.bin b/etherman/smartcontracts/bin/oldpolygonzkevm.bin new file mode 100644 index 0000000..ab66043 --- /dev/null +++ b/etherman/smartcontracts/bin/oldpolygonzkevm.bin @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/etherman/smartcontracts/bin/oldpolygonzkevmbridge.bin b/etherman/smartcontracts/bin/oldpolygonzkevmbridge.bin new file mode 100644 index 0000000..37426f4 --- /dev/null +++ b/etherman/smartcontracts/bin/oldpolygonzkevmbridge.bin @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/etherman/smartcontracts/bin/oldpolygonzkevmglobalexitroot.bin b/etherman/smartcontracts/bin/oldpolygonzkevmglobalexitroot.bin new file mode 100644 index 0000000..36c75df --- /dev/null +++ b/etherman/smartcontracts/bin/oldpolygonzkevmglobalexitroot.bin @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/etherman/smartcontracts/bin/pol.bin b/etherman/smartcontracts/bin/pol.bin new file mode 100644 index 0000000..dcb0318 --- /dev/null +++ b/etherman/smartcontracts/bin/pol.bin @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/etherman/smartcontracts/bin/polygonrollupmanager.bin b/etherman/smartcontracts/bin/polygonrollupmanager.bin new file mode 100644 index 0000000..99314f5 --- /dev/null +++ b/etherman/smartcontracts/bin/polygonrollupmanager.bin @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/etherman/smartcontracts/bin/polygonzkevm.bin b/etherman/smartcontracts/bin/polygonzkevm.bin new file mode 100644 index 0000000..163a466 --- /dev/null +++ b/etherman/smartcontracts/bin/polygonzkevm.bin @@ -0,0 +1 @@ +6101006040523480156200001257600080fd5b506040516200464138038062004641833981016040819052620000359162000071565b6001600160a01b0393841660a052918316608052821660c0521660e052620000d9565b6001600160a01b03811681146200006e57600080fd5b50565b600080600080608085870312156200008857600080fd5b8451620000958162000058565b6020860151909450620000a88162000058565b6040860151909350620000bb8162000058565b6060860151909250620000ce8162000058565b939692955090935050565b60805160a05160c05160e051614494620001ad6000396000818161051a015281816109a501528181610b1201528181610e4f015281816113ea01528181611a8d01528181611b8b015281816121dc01528181612b4901528181612bca01528181612bec0152612d04015260008181610669015281816110a901528181611d5b01528181611e63015261266f01526000818161072d0152818161125e0152818161232701526126f101526000818161075f0152818161083d01528181611ad6015281816122fb0152612c9a01526144946000f3fe608060405234801561001057600080fd5b50600436106102e85760003560e01c80636ff512cc11610191578063c7fffd4b116100e3578063e46761c411610097578063ecef3f9911610071578063ecef3f99146107b4578063f35dda47146107c7578063f851a440146107cf57600080fd5b8063e46761c41461075a578063e7a7ed0214610781578063eaeb077b146107a157600080fd5b8063cfa8ed47116100c8578063cfa8ed4714610708578063d02103ca14610728578063d7bc90ff1461074f57600080fd5b8063c7fffd4b146106ed578063c89e42df146106f557600080fd5b80639f26f84011610145578063ada8f9191161011f578063ada8f9191461069e578063b0afe154146106b1578063c754c7ed146106bd57600080fd5b80639f26f84014610651578063a3c573eb14610664578063a652f26c1461068b57600080fd5b80637a5460c5116101765780637a5460c5146105f25780638c3d73011461062e5780639e0018771461063657600080fd5b80636ff512cc146105cc57806371257022146105df57600080fd5b80633cbc795b1161024a57806352bdeb6d116101fe578063676870d2116101d8578063676870d21461059b5780636b8616ce146105a35780636e05d2cd146105c357600080fd5b806352bdeb6d1461054f578063542028d51461058b5780635ec919581461059357600080fd5b8063456052671161022f57806345605267146104ed57806349b7b802146105155780634e4877061461053c57600080fd5b80633cbc795b1461045757806340b5de6c1461049557600080fd5b806326782247116102a15780632b35b3ac116102865780632b35b3ac1461040057806332c2d1531461041d5780633c351e101461043257600080fd5b8063267822471461038e5780632a9f208f146103d357600080fd5b806305835f37116102d257806305835f3714610323578063107bf28c1461036c57806311e892d41461037457600080fd5b8062d0295d146102ed5780630350896314610308575b600080fd5b6102f56107f5565b6040519081526020015b60405180910390f35b610310602081565b60405161ffff90911681526020016102ff565b61035f6040518060400160405280600881526020017f80808401c9c3809400000000000000000000000000000000000000000000000081525081565b6040516102ff91906136e1565b61035f610915565b61037c60f981565b60405160ff90911681526020016102ff565b6001546103ae9073ffffffffffffffffffffffffffffffffffffffff1681565b60405173ffffffffffffffffffffffffffffffffffffffff90911681526020016102ff565b6007546103e79067ffffffffffffffff1681565b60405167ffffffffffffffff90911681526020016102ff565b60085461040d9060ff1681565b60405190151581526020016102ff565b61043061042b366004613736565b6109a3565b005b6008546103ae90610100900473ffffffffffffffffffffffffffffffffffffffff1681565b600854610480907501000000000000000000000000000000000000000000900463ffffffff1681565b60405163ffffffff90911681526020016102ff565b6104bc7fff0000000000000000000000000000000000000000000000000000000000000081565b6040517fff0000000000000000000000000000000000000000000000000000000000000090911681526020016102ff565b6007546103e790700100000000000000000000000000000000900467ffffffffffffffff1681565b6103ae7f000000000000000000000000000000000000000000000000000000000000000081565b61043061054a366004613778565b610a72565b61035f6040518060400160405280600281526020017f80b800000000000000000000000000000000000000000000000000000000000081525081565b61035f610c8c565b610430610c99565b610310601f81565b6102f56105b1366004613778565b60066020526000908152604090205481565b6102f560055481565b6104306105da366004613795565b610d83565b6104306105ed3660046138de565b610e4d565b61035f6040518060400160405280600281526020017f80b900000000000000000000000000000000000000000000000000000000000081525081565b6104306115e5565b6103ae73a40d5f56745a118d0906a34e69aec8c0db1cb8fa81565b61043061065f3660046139d7565b6116b8565b6103ae7f000000000000000000000000000000000000000000000000000000000000000081565b61035f610699366004613a19565b611c5a565b6104306106ac366004613795565b61203f565b6102f56405ca1ab1e081565b6007546103e7907801000000000000000000000000000000000000000000000000900467ffffffffffffffff1681565b61037c60e481565b610430610703366004613a8e565b612109565b6002546103ae9073ffffffffffffffffffffffffffffffffffffffff1681565b6103ae7f000000000000000000000000000000000000000000000000000000000000000081565b6102f5635ca1ab1e81565b6103ae7f000000000000000000000000000000000000000000000000000000000000000081565b6007546103e79068010000000000000000900467ffffffffffffffff1681565b6104306107af366004613ac3565b61219c565b6104306107c2366004613b3b565b6125a4565b61037c601b81565b6000546103ae9062010000900473ffffffffffffffffffffffffffffffffffffffff1681565b6040517f70a08231000000000000000000000000000000000000000000000000000000008152306004820152600090819073ffffffffffffffffffffffffffffffffffffffff7f000000000000000000000000000000000000000000000000000000000000000016906370a0823190602401602060405180830381865afa158015610884573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906108a89190613b87565b6007549091506000906108e79067ffffffffffffffff700100000000000000000000000000000000820481169168010000000000000000900416613bcf565b67ffffffffffffffff169050806000036109045760009250505090565b61090e8183613bf7565b9250505090565b6004805461092290613c32565b80601f016020809104026020016040519081016040528092919081815260200182805461094e90613c32565b801561099b5780601f106109705761010080835404028352916020019161099b565b820191906000526020600020905b81548152906001019060200180831161097e57829003601f168201915b505050505081565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163314610a12576040517fb9b3a2c800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8073ffffffffffffffffffffffffffffffffffffffff168367ffffffffffffffff167f9c72852172521097ba7e1482e6b44b351323df0155f97f4ea18fcec28e1f596684604051610a6591815260200190565b60405180910390a3505050565b60005462010000900473ffffffffffffffffffffffffffffffffffffffff163314610ac9576040517f4755657900000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b62093a8067ffffffffffffffff82161115610b10576040517ff5e37f2f00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff166315064c966040518163ffffffff1660e01b8152600401602060405180830381865afa158015610b7b573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610b9f9190613c85565b610c085760075467ffffffffffffffff7801000000000000000000000000000000000000000000000000909104811690821610610c08576040517ff5e37f2f00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6007805477ffffffffffffffffffffffffffffffffffffffffffffffff16780100000000000000000000000000000000000000000000000067ffffffffffffffff8416908102919091179091556040519081527fa7eb6cb8a613eb4e8bddc1ac3d61ec6cf10898760f0b187bcca794c6ca6fa40b906020015b60405180910390a150565b6003805461092290613c32565b60005462010000900473ffffffffffffffffffffffffffffffffffffffff163314610cf0576040517f4755657900000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60085460ff1615610d2d576040517ff6ba91a100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600880547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff001660011790556040517f854dd6ce5a1445c4c54388b21cffd11cf5bba1b9e763aec48ce3da75d617412f90600090a1565b60005462010000900473ffffffffffffffffffffffffffffffffffffffff163314610dda576040517f4755657900000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600280547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff83169081179091556040519081527ff54144f9611984021529f814a1cb6a41e22c58351510a0d9f7e822618abb9cc090602001610c81565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163314610ebc576040517fb9b3a2c800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600054610100900460ff1615808015610edc5750600054600160ff909116105b80610ef65750303b158015610ef6575060005460ff166001145b610f87576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602e60248201527f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160448201527f647920696e697469616c697a656400000000000000000000000000000000000060648201526084015b60405180910390fd5b600080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff001660011790558015610fe557600080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff166101001790555b606073ffffffffffffffffffffffffffffffffffffffff8516156111fa5761100c85612dd9565b61101586612ee9565b61101e87612ff0565b60405160200161103093929190613ca7565b604080517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0818403018152908290527f318aee3d00000000000000000000000000000000000000000000000000000000825273ffffffffffffffffffffffffffffffffffffffff878116600484015290925060009182917f0000000000000000000000000000000000000000000000000000000000000000169063318aee3d9060240160408051808303816000875af11580156110f1573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906111159190613ce0565b915091508163ffffffff166000146111b257600880547fffffffffffffff000000000000000000000000000000000000000000000000ff1661010073ffffffffffffffffffffffffffffffffffffffff8416027fffffffffffffff00000000ffffffffffffffffffffffffffffffffffffffffff1617750100000000000000000000000000000000000000000063ffffffff8516021790556111f7565b600880547fffffffffffffffffffffff0000000000000000000000000000000000000000ff1661010073ffffffffffffffffffffffffffffffffffffffff8a16021790555b50505b600854600090611247908890610100810473ffffffffffffffffffffffffffffffffffffffff16907501000000000000000000000000000000000000000000900463ffffffff1685611c5a565b9050600081805190602001209050600042905060007f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff16633ed691ef6040518163ffffffff1660e01b8152600401602060405180830381865afa1580156112c7573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906112eb9190613b87565b90506000808483858f6112ff600143613d1a565b60408051602081019790975286019490945260608086019390935260c09190911b7fffffffffffffffff000000000000000000000000000000000000000000000000166080850152901b7fffffffffffffffffffffffffffffffffffffffff00000000000000000000000016608883015240609c82015260bc01604080518083037fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe001815290829052805160209091012060058190557f9a908e73000000000000000000000000000000000000000000000000000000008252600160048301526024820181905291507f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1690639a908e73906044016020604051808303816000875af1158015611448573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061146c9190613d2d565b508c600060026101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508b600260006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555088600390816114fe9190613d98565b50600461150b8982613d98565b5062069780600760186101000a81548167ffffffffffffffff021916908367ffffffffffffffff1602179055507f060116213bcbf54ca19fd649dc84b59ab2bbd200ab199770e4d923e222a28e7f85838e60405161156b93929190613eb2565b60405180910390a150505050505080156115dc57600080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff169055604051600181527f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb38474024989060200160405180910390a15b50505050505050565b60015473ffffffffffffffffffffffffffffffffffffffff163314611636576040517fd1ec4b2300000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600154600080547fffffffffffffffffffff0000000000000000000000000000000000000000ffff1673ffffffffffffffffffffffffffffffffffffffff9092166201000081029290921790556040519081527f056dc487bbf0795d0bbb1b4f0af523a855503cff740bfb4d5475f7a90c091e8e9060200160405180910390a1565b60085460ff166116f4576040517f24eff8c300000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b806000819003611730576040517fcb591a5f00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6103e881111561176c576040517fb59f753a00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60075467ffffffffffffffff6801000000000000000082048116916117a7918491700100000000000000000000000000000000900416613ef1565b11156117df576040517fc630a00d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60075460055470010000000000000000000000000000000090910467ffffffffffffffff169060005b83811015611a8757600086868381811061182457611824613f04565b90506020028101906118369190613f33565b61183f90613f71565b90508361184b81613ffa565b825180516020918201208185015160408087015160608801519151959a509295506000946118b8948794929101938452602084019290925260c01b7fffffffffffffffff000000000000000000000000000000000000000000000000166040830152604882015260680190565b604080517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0818403018152918152815160209283012067ffffffffffffffff8916600090815260069093529120549091508114611941576040517fce3d755e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b67ffffffffffffffff8616600090815260066020526040812055611966600188613d1a565b84036119d55742600760189054906101000a900467ffffffffffffffff1684604001516119939190614021565b67ffffffffffffffff1611156119d5576040517fc44a082100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60208381015160408086015160608088015183519586018b90529285018790528481019390935260c01b7fffffffffffffffff0000000000000000000000000000000000000000000000001660808401523390911b7fffffffffffffffffffffffffffffffffffffffff000000000000000000000000166088830152609c82015260bc016040516020818303038152906040528051906020012094505050508080611a7f90614042565b915050611808565b50611afd7f000000000000000000000000000000000000000000000000000000000000000084611ab56107f5565b611abf919061407a565b73ffffffffffffffffffffffffffffffffffffffff7f00000000000000000000000000000000000000000000000000000000000000001691906130e3565b60058190556007805467ffffffffffffffff8416700100000000000000000000000000000000027fffffffffffffffff0000000000000000ffffffffffffffffffffffffffffffff9091161790556040517f9a908e7300000000000000000000000000000000000000000000000000000000815260009073ffffffffffffffffffffffffffffffffffffffff7f00000000000000000000000000000000000000000000000000000000000000001690639a908e7390611bd7908790869060040167ffffffffffffffff929092168252602082015260400190565b6020604051808303816000875af1158015611bf6573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611c1a9190613d2d565b60405190915067ffffffffffffffff8216907f648a61dd2438f072f5a1960939abd30f37aea80d2e94c9792ad142d3e0a490a490600090a2505050505050565b6060600085858573a40d5f56745a118d0906a34e69aec8c0db1cb8fa600087604051602401611c8e96959493929190614091565b604080517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe08184030181529190526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167ff811bff7000000000000000000000000000000000000000000000000000000001790528351909150606090600003611ddf5760f9601f8351611d2391906140f4565b6040518060400160405280600881526020017f80808401c9c380940000000000000000000000000000000000000000000000008152507f00000000000000000000000000000000000000000000000000000000000000006040518060400160405280600281526020017f80b800000000000000000000000000000000000000000000000000000000000081525060e487604051602001611dc9979695949392919061410f565b6040516020818303038152906040529050611ee3565b815161ffff1015611e1c576040517f248b8f8200000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b815160f9611e2b6020836140f4565b6040518060400160405280600881526020017f80808401c9c380940000000000000000000000000000000000000000000000008152507f00000000000000000000000000000000000000000000000000000000000000006040518060400160405280600281526020017f80b90000000000000000000000000000000000000000000000000000000000008152508588604051602001611ed097969594939291906141f2565b6040516020818303038152906040529150505b805160208083019190912060408051600080825293810180835292909252601b908201526405ca1ab1e06060820152635ca1ab1e608082015260019060a0016020604051602081039080840390855afa158015611f44573d6000803e3d6000fd5b50506040517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0015191505073ffffffffffffffffffffffffffffffffffffffff8116611fbc576040517fcd16196600000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6040516000906120029084906405ca1ab1e090635ca1ab1e90601b907fff00000000000000000000000000000000000000000000000000000000000000906020016142d5565b604080517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe08184030181529190529450505050505b949350505050565b60005462010000900473ffffffffffffffffffffffffffffffffffffffff163314612096576040517f4755657900000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600180547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff83169081179091556040519081527fa5b56b7906fd0a20e3f35120dd8343db1e12e037a6c90111c7e42885e82a1ce690602001610c81565b60005462010000900473ffffffffffffffffffffffffffffffffffffffff163314612160576040517f4755657900000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600361216c8282613d98565b507f6b8f723a4c7a5335cafae8a598a0aa0301be1387c037dccc085b62add6448b2081604051610c8191906136e1565b60085460ff166121d8576040517f24eff8c300000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60007f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1663604691696040518163ffffffff1660e01b8152600401602060405180830381865afa158015612245573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906122699190613b87565b9050818111156122a5576040517f2354600f00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6113888311156122e1576040517fa29a6c7c00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b61232373ffffffffffffffffffffffffffffffffffffffff7f0000000000000000000000000000000000000000000000000000000000000000163330846131bc565b60007f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff16633ed691ef6040518163ffffffff1660e01b8152600401602060405180830381865afa158015612390573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906123b49190613b87565b600780549192506801000000000000000090910467ffffffffffffffff169060086123de83613ffa565b91906101000a81548167ffffffffffffffff021916908367ffffffffffffffff160217905550508484604051612415929190614331565b604051908190039020814261242b600143613d1a565b60408051602081019590955284019290925260c01b7fffffffffffffffff000000000000000000000000000000000000000000000000166060830152406068820152608801604080518083037fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0018152918152815160209283012060075468010000000000000000900467ffffffffffffffff166000908152600690935291205532330361253e576007546040805183815233602082015260609181018290526000918101919091526801000000000000000090910467ffffffffffffffff16907ff94bb37db835f1ab585ee00041849a09b12cd081d77fa15ca070757619cbc9319060800160405180910390a261259d565b600760089054906101000a900467ffffffffffffffff1667ffffffffffffffff167ff94bb37db835f1ab585ee00041849a09b12cd081d77fa15ca070757619cbc931823388886040516125949493929190614341565b60405180910390a25b5050505050565b60025473ffffffffffffffffffffffffffffffffffffffff1633146125f5576040517f11e7be1500000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b816000819003612631576040517fcb591a5f00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6103e881111561266d576040517fb59f753a00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff166379e2cf976040518163ffffffff1660e01b8152600401600060405180830381600087803b1580156126d557600080fd5b505af11580156126e9573d6000803e3d6000fd5b5050505060007f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff16635ca1e1656040518163ffffffff1660e01b8152600401602060405180830381865afa15801561275a573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061277e9190613b87565b600754600554919250429170010000000000000000000000000000000090910467ffffffffffffffff16908160005b86811015612aaf5760008a8a838181106127c9576127c9613f04565b90506020028101906127db9190613f33565b6127e490613f71565b8051805160209091012060408201519192509067ffffffffffffffff16156129c9578561281081613ffa565b9650506000818360200151846040015185606001516040516020016128739493929190938452602084019290925260c01b7fffffffffffffffff000000000000000000000000000000000000000000000000166040830152604882015260680190565b604080517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0818403018152918152815160209283012067ffffffffffffffff8a166000908152600690935291205490915081146128fc576040517fce3d755e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60208381015160408086015160608088015183519586018c90529285018790528481019390935260c01b7fffffffffffffffff000000000000000000000000000000000000000000000000166080840152908d901b7fffffffffffffffffffffffffffffffffffffffff000000000000000000000000166088830152609c82015260bc01604051602081830303815290604052805190602001209550600660008867ffffffffffffffff1667ffffffffffffffff1681526020019081526020016000206000905550612a9a565b8151516201d4c01015612a08576040517fa29a6c7c00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b604080516020810187905290810182905260608082018a905260c089901b7fffffffffffffffff0000000000000000000000000000000000000000000000001660808301528b901b7fffffffffffffffffffffffffffffffffffffffff0000000000000000000000001660888201526000609c82015260bc016040516020818303038152906040528051906020012094505b50508080612aa790614042565b9150506127ad565b5060075467ffffffffffffffff6801000000000000000090910481169084161115612b06576040517fc630a00d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60058290558567ffffffffffffffff84811690831614612bc4576000612b2c8386613bcf565b9050612b4267ffffffffffffffff821683613d1a565b9150612b7b7f00000000000000000000000000000000000000000000000000000000000000008267ffffffffffffffff16611ab56107f5565b50600780547fffffffffffffffff0000000000000000ffffffffffffffffffffffffffffffff1670010000000000000000000000000000000067ffffffffffffffff8716021790555b612cc2337f0000000000000000000000000000000000000000000000000000000000000000837f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1663477fa2706040518163ffffffff1660e01b8152600401602060405180830381865afa158015612c55573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190612c799190613b87565b612c83919061407a565b73ffffffffffffffffffffffffffffffffffffffff7f0000000000000000000000000000000000000000000000000000000000000000169291906131bc565b6040517f9a908e7300000000000000000000000000000000000000000000000000000000815267ffffffffffffffff88166004820152602481018490526000907f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1690639a908e73906044016020604051808303816000875af1158015612d62573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190612d869190613d2d565b90508067ffffffffffffffff167f3e54d0825ed78523037d00a81759237eb436ce774bd546993ee67a1b67b6e76688604051612dc491815260200190565b60405180910390a25050505050505050505050565b60408051600481526024810182526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167f06fdde03000000000000000000000000000000000000000000000000000000001790529051606091600091829173ffffffffffffffffffffffffffffffffffffffff861691612e5b91906143b2565b600060405180830381855afa9150503d8060008114612e96576040519150601f19603f3d011682016040523d82523d6000602084013e612e9b565b606091505b509150915081612ee0576040518060400160405280600781526020017f4e4f5f4e414d4500000000000000000000000000000000000000000000000000815250612037565b61203781613220565b60408051600481526024810182526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167f95d89b41000000000000000000000000000000000000000000000000000000001790529051606091600091829173ffffffffffffffffffffffffffffffffffffffff861691612f6b91906143b2565b600060405180830381855afa9150503d8060008114612fa6576040519150601f19603f3d011682016040523d82523d6000602084013e612fab565b606091505b509150915081612ee0576040518060400160405280600981526020017f4e4f5f53594d424f4c0000000000000000000000000000000000000000000000815250612037565b60408051600481526024810182526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167f313ce5670000000000000000000000000000000000000000000000000000000017905290516000918291829173ffffffffffffffffffffffffffffffffffffffff86169161307191906143b2565b600060405180830381855afa9150503d80600081146130ac576040519150601f19603f3d011682016040523d82523d6000602084013e6130b1565b606091505b50915091508180156130c4575080516020145b6130cf576012612037565b8080602001905181019061203791906143c4565b60405173ffffffffffffffffffffffffffffffffffffffff83166024820152604481018290526131b79084907fa9059cbb00000000000000000000000000000000000000000000000000000000906064015b604080517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe08184030181529190526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fffffffff00000000000000000000000000000000000000000000000000000000909316929092179091526133f6565b505050565b60405173ffffffffffffffffffffffffffffffffffffffff8085166024830152831660448201526064810182905261321a9085907f23b872dd0000000000000000000000000000000000000000000000000000000090608401613135565b50505050565b60606040825110613245578180602001905181019061323f91906143e7565b92915050565b81516020036133bd5760005b602081108015613298575082818151811061326e5761326e613f04565b01602001517fff000000000000000000000000000000000000000000000000000000000000001615155b156132af57806132a781614042565b915050613251565b806000036132f257505060408051808201909152601281527f4e4f545f56414c49445f454e434f44494e4700000000000000000000000000006020820152919050565b60008167ffffffffffffffff81111561330d5761330d6137c4565b6040519080825280601f01601f191660200182016040528015613337576020820181803683370190505b50905060005b828110156133b55784818151811061335757613357613f04565b602001015160f81c60f81b82828151811061337457613374613f04565b60200101907effffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916908160001a905350806133ad81614042565b91505061333d565b509392505050565b505060408051808201909152601281527f4e4f545f56414c49445f454e434f44494e470000000000000000000000000000602082015290565b6000613458826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff166135029092919063ffffffff16565b8051909150156131b757808060200190518101906134769190613c85565b6131b7576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e60448201527f6f742073756363656564000000000000000000000000000000000000000000006064820152608401610f7e565b60606120378484600085856000808673ffffffffffffffffffffffffffffffffffffffff16858760405161353691906143b2565b60006040518083038185875af1925050503d8060008114613573576040519150601f19603f3d011682016040523d82523d6000602084013e613578565b606091505b509150915061358987838387613594565b979650505050505050565b6060831561362a5782516000036136235773ffffffffffffffffffffffffffffffffffffffff85163b613623576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e74726163740000006044820152606401610f7e565b5081612037565b612037838381511561363f5781518083602001fd5b806040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610f7e91906136e1565b60005b8381101561368e578181015183820152602001613676565b50506000910152565b600081518084526136af816020860160208601613673565b601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0169290920160200192915050565b6020815260006136f46020830184613697565b9392505050565b67ffffffffffffffff8116811461371157600080fd5b50565b73ffffffffffffffffffffffffffffffffffffffff8116811461371157600080fd5b60008060006060848603121561374b57600080fd5b8335613756816136fb565b925060208401359150604084013561376d81613714565b809150509250925092565b60006020828403121561378a57600080fd5b81356136f4816136fb565b6000602082840312156137a757600080fd5b81356136f481613714565b63ffffffff8116811461371157600080fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b604051601f82017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe016810167ffffffffffffffff8111828210171561383a5761383a6137c4565b604052919050565b600067ffffffffffffffff82111561385c5761385c6137c4565b50601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe01660200190565b600082601f83011261389957600080fd5b81356138ac6138a782613842565b6137f3565b8181528460208386010111156138c157600080fd5b816020850160208301376000918101602001919091529392505050565b60008060008060008060c087890312156138f757600080fd5b863561390281613714565b9550602087013561391281613714565b94506040870135613922816137b2565b9350606087013561393281613714565b9250608087013567ffffffffffffffff8082111561394f57600080fd5b61395b8a838b01613888565b935060a089013591508082111561397157600080fd5b5061397e89828a01613888565b9150509295509295509295565b60008083601f84011261399d57600080fd5b50813567ffffffffffffffff8111156139b557600080fd5b6020830191508360208260051b85010111156139d057600080fd5b9250929050565b600080602083850312156139ea57600080fd5b823567ffffffffffffffff811115613a0157600080fd5b613a0d8582860161398b565b90969095509350505050565b60008060008060808587031215613a2f57600080fd5b8435613a3a816137b2565b93506020850135613a4a81613714565b92506040850135613a5a816137b2565b9150606085013567ffffffffffffffff811115613a7657600080fd5b613a8287828801613888565b91505092959194509250565b600060208284031215613aa057600080fd5b813567ffffffffffffffff811115613ab757600080fd5b61203784828501613888565b600080600060408486031215613ad857600080fd5b833567ffffffffffffffff80821115613af057600080fd5b818601915086601f830112613b0457600080fd5b813581811115613b1357600080fd5b876020828501011115613b2557600080fd5b6020928301989097509590910135949350505050565b600080600060408486031215613b5057600080fd5b833567ffffffffffffffff811115613b6757600080fd5b613b738682870161398b565b909450925050602084013561376d81613714565b600060208284031215613b9957600080fd5b5051919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b67ffffffffffffffff828116828216039080821115613bf057613bf0613ba0565b5092915050565b600082613c2d577f4e487b7100000000000000000000000000000000000000000000000000000000600052601260045260246000fd5b500490565b600181811c90821680613c4657607f821691505b602082108103613c7f577f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b50919050565b600060208284031215613c9757600080fd5b815180151581146136f457600080fd5b606081526000613cba6060830186613697565b8281036020840152613ccc8186613697565b91505060ff83166040830152949350505050565b60008060408385031215613cf357600080fd5b8251613cfe816137b2565b6020840151909250613d0f81613714565b809150509250929050565b8181038181111561323f5761323f613ba0565b600060208284031215613d3f57600080fd5b81516136f4816136fb565b601f8211156131b757600081815260208120601f850160051c81016020861015613d715750805b601f850160051c820191505b81811015613d9057828155600101613d7d565b505050505050565b815167ffffffffffffffff811115613db257613db26137c4565b613dc681613dc08454613c32565b84613d4a565b602080601f831160018114613e195760008415613de35750858301515b7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600386901b1c1916600185901b178555613d90565b6000858152602081207fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe08616915b82811015613e6657888601518255948401946001909101908401613e47565b5085821015613ea257878501517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600388901b60f8161c191681555b5050505050600190811b01905550565b606081526000613ec56060830186613697565b905083602083015273ffffffffffffffffffffffffffffffffffffffff83166040830152949350505050565b8082018082111561323f5761323f613ba0565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b600082357fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff81833603018112613f6757600080fd5b9190910192915050565b600060808236031215613f8357600080fd5b6040516080810167ffffffffffffffff8282108183111715613fa757613fa76137c4565b816040528435915080821115613fbc57600080fd5b50613fc936828601613888565b825250602083013560208201526040830135613fe4816136fb565b6040820152606092830135928101929092525090565b600067ffffffffffffffff80831681810361401757614017613ba0565b6001019392505050565b67ffffffffffffffff818116838216019080821115613bf057613bf0613ba0565b60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff820361407357614073613ba0565b5060010190565b808202811582820484141761323f5761323f613ba0565b600063ffffffff808916835273ffffffffffffffffffffffffffffffffffffffff8089166020850152818816604085015280871660608501528086166080850152505060c060a08301526140e860c0830184613697565b98975050505050505050565b61ffff818116838216019080821115613bf057613bf0613ba0565b60007fff00000000000000000000000000000000000000000000000000000000000000808a60f81b1683527fffff0000000000000000000000000000000000000000000000000000000000008960f01b1660018401528751614178816003860160208c01613673565b80840190507fffffffffffffffffffffffffffffffffffffffff0000000000000000000000008860601b16600382015286516141bb816017840160208b01613673565b808201915050818660f81b166017820152845191506141e1826018830160208801613673565b016018019998505050505050505050565b7fff000000000000000000000000000000000000000000000000000000000000008860f81b16815260007fffff000000000000000000000000000000000000000000000000000000000000808960f01b166001840152875161425b816003860160208c01613673565b80840190507fffffffffffffffffffffffffffffffffffffffff0000000000000000000000008860601b166003820152865161429e816017840160208b01613673565b808201915050818660f01b166017820152845191506142c4826019830160208801613673565b016019019998505050505050505050565b600086516142e7818460208b01613673565b9190910194855250602084019290925260f81b7fff000000000000000000000000000000000000000000000000000000000000009081166040840152166041820152604201919050565b8183823760009101908152919050565b84815273ffffffffffffffffffffffffffffffffffffffff8416602082015260606040820152816060820152818360808301376000818301608090810191909152601f9092017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe01601019392505050565b60008251613f67818460208701613673565b6000602082840312156143d657600080fd5b815160ff811681146136f457600080fd5b6000602082840312156143f957600080fd5b815167ffffffffffffffff81111561441057600080fd5b8201601f8101841361442157600080fd5b805161442f6138a782613842565b81815285602083850101111561444457600080fd5b614455826020830160208601613673565b9594505050505056fea2646970667358221220c9b142edbaf63c56761aad22240658b45bae78a2ed1e483abe43944f9fae087664736f6c63430008140033 \ No newline at end of file diff --git a/etherman/smartcontracts/bin/polygonzkevmbridge.bin b/etherman/smartcontracts/bin/polygonzkevmbridge.bin new file mode 100644 index 0000000..f640f91 --- /dev/null +++ b/etherman/smartcontracts/bin/polygonzkevmbridge.bin @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/etherman/smartcontracts/bin/polygonzkevmglobalexitroot.bin b/etherman/smartcontracts/bin/polygonzkevmglobalexitroot.bin new file mode 100644 index 0000000..c8e9af7 --- /dev/null +++ b/etherman/smartcontracts/bin/polygonzkevmglobalexitroot.bin @@ -0,0 +1 @@ +60c060405234801561001057600080fd5b50604051610b37380380610b3783398101604081905261002f91610062565b6001600160a01b0391821660a05216608052610095565b80516001600160a01b038116811461005d57600080fd5b919050565b6000806040838503121561007557600080fd5b61007e83610046565b915061008c60208401610046565b90509250929050565b60805160a051610a6f6100c86000396000818161014901526102c3015260008181610218015261027a0152610a6f6000f3fe608060405234801561001057600080fd5b50600436106100d45760003560e01c806349b7b8021161008157806383f244031161005b57806383f2440314610200578063a3c573eb14610213578063fb5708341461023a57600080fd5b806349b7b802146101445780635ca1e165146101905780635d8105011461019857600080fd5b8063319cf735116100b2578063319cf7351461011e57806333d6247d146101275780633ed691ef1461013c57600080fd5b806301fd9044146100d9578063257b3632146100f55780632dfdf0b514610115575b600080fd5b6100e260005481565b6040519081526020015b60405180910390f35b6100e261010336600461071d565b60026020526000908152604090205481565b6100e260235481565b6100e260015481565b61013a61013536600461071d565b61025d565b005b6100e2610401565b61016b7f000000000000000000000000000000000000000000000000000000000000000081565b60405173ffffffffffffffffffffffffffffffffffffffff90911681526020016100ec565b6100e2610416565b6100e26101a6366004610736565b604080516020808201959095528082019390935260c09190911b7fffffffffffffffff0000000000000000000000000000000000000000000000001660608301528051604881840301815260689092019052805191012090565b6100e261020e3660046107a7565b610420565b61016b7f000000000000000000000000000000000000000000000000000000000000000081565b61024d6102483660046107e6565b6104f6565b60405190151581526020016100ec565b60005460015473ffffffffffffffffffffffffffffffffffffffff7f00000000000000000000000000000000000000000000000000000000000000001633036102ac5750600182905581610328565b73ffffffffffffffffffffffffffffffffffffffff7f00000000000000000000000000000000000000000000000000000000000000001633036102f6576000839055829150610328565b6040517fb49365dd00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6000610334828461050e565b600081815260026020526040812054919250036103fb57600061035860014361085d565b60008381526002602090815260409182902092409283905581518082018690528083018490527fffffffffffffffff0000000000000000000000000000000000000000000000004260c01b16606082015282518082036048018152606890910190925281519101209091506103cc9061053d565b604051849084907fda61aa7823fcd807e37b95aabcbe17f03a6f3efd514176444dae191d27fd66b390600090a3505b50505050565b600061041160015460005461050e565b905090565b6000610411610640565b600083815b60208110156104ed57600163ffffffff8516821c811690036104905784816020811061045357610453610870565b602002013582604051602001610473929190918252602082015260400190565b6040516020818303038152906040528051906020012091506104db565b818582602081106104a3576104a3610870565b60200201356040516020016104c2929190918252602082015260400190565b6040516020818303038152906040528051906020012091505b806104e58161089f565b915050610425565b50949350505050565b600081610504868686610420565b1495945050505050565b604080516020808201859052818301849052825180830384018152606090920190925280519101205b92915050565b80600161054c602060026109f7565b610556919061085d565b60235410610590576040517fef5ccf6600000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60006023600081546105a19061089f565b9182905550905060005b6020811015610632578082901c6001166001036105de5782600382602081106105d6576105d6610870565b015550505050565b600381602081106105f1576105f1610870565b01546040805160208101929092528101849052606001604051602081830303815290604052805190602001209250808061062a9061089f565b9150506105ab565b5061063b610a0a565b505050565b602354600090819081805b6020811015610714578083901c6001166001036106a8576003816020811061067557610675610870565b015460408051602081019290925281018590526060016040516020818303038152906040528051906020012093506106d5565b60408051602081018690529081018390526060016040516020818303038152906040528051906020012093505b6040805160208101849052908101839052606001604051602081830303815290604052805190602001209150808061070c9061089f565b91505061064b565b50919392505050565b60006020828403121561072f57600080fd5b5035919050565b60008060006060848603121561074b57600080fd5b8335925060208401359150604084013567ffffffffffffffff8116811461077157600080fd5b809150509250925092565b80610400810183101561053757600080fd5b803563ffffffff811681146107a257600080fd5b919050565b600080600061044084860312156107bd57600080fd5b833592506107ce856020860161077c565b91506107dd610420850161078e565b90509250925092565b60008060008061046085870312156107fd57600080fd5b8435935061080e866020870161077c565b925061081d610420860161078e565b939692955092936104400135925050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b818103818111156105375761053761082e565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff82036108d0576108d061082e565b5060010190565b600181815b8085111561093057817fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff048211156109165761091661082e565b8085161561092357918102915b93841c93908002906108dc565b509250929050565b60008261094757506001610537565b8161095457506000610537565b816001811461096a576002811461097457610990565b6001915050610537565b60ff8411156109855761098561082e565b50506001821b610537565b5060208310610133831016604e8410600b84101617156109b3575081810a610537565b6109bd83836108d7565b807fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff048211156109ef576109ef61082e565b029392505050565b6000610a038383610938565b9392505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052600160045260246000fdfea2646970667358221220085253bac61681748496caf7cd5c09a387c4551b2b1cabbc8ff512cdeb63bfcc64736f6c63430008140033 \ No newline at end of file diff --git a/etherman/smartcontracts/mockpolygonrollupmanager/mockpolygonrollupmanager.go b/etherman/smartcontracts/mockpolygonrollupmanager/mockpolygonrollupmanager.go new file mode 100644 index 0000000..b3511bc --- /dev/null +++ b/etherman/smartcontracts/mockpolygonrollupmanager/mockpolygonrollupmanager.go @@ -0,0 +1,5048 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package mockpolygonrollupmanager + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// LegacyZKEVMStateVariablesPendingState is an auto generated low-level Go binding around an user-defined struct. +type LegacyZKEVMStateVariablesPendingState struct { + Timestamp uint64 + LastVerifiedBatch uint64 + ExitRoot [32]byte + StateRoot [32]byte +} + +// LegacyZKEVMStateVariablesSequencedBatchData is an auto generated low-level Go binding around an user-defined struct. +type LegacyZKEVMStateVariablesSequencedBatchData struct { + AccInputHash [32]byte + SequencedTimestamp uint64 + PreviousLastBatchSequenced uint64 +} + +// MockpolygonrollupmanagerMetaData contains all meta data concerning the Mockpolygonrollupmanager contract. +var MockpolygonrollupmanagerMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[{\"internalType\":\"contractIPolygonZkEVMGlobalExitRoot\",\"name\":\"_globalExitRootManager\",\"type\":\"address\"},{\"internalType\":\"contractIERC20Upgradeable\",\"name\":\"_pol\",\"type\":\"address\"},{\"internalType\":\"contractIPolygonZkEVMBridge\",\"name\":\"_bridgeAddress\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"AccessControlOnlyCanRenounceRolesForSelf\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"AddressDoNotHaveRequiredRole\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"AllzkEVMSequencedBatchesMustBeVerified\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"BatchFeeOutOfRange\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ChainIDAlreadyExist\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ExceedMaxVerifyBatches\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FinalNumBatchBelowLastVerifiedBatch\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FinalNumBatchDoesNotMatchPendingState\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FinalPendingStateNumInvalid\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"HaltTimeoutNotExpired\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InitBatchMustMatchCurrentForkID\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InitNumBatchAboveLastVerifiedBatch\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InitNumBatchDoesNotMatchPendingState\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidProof\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidRangeBatchTimeTarget\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidRangeMultiplierBatchFee\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"MustSequenceSomeBatch\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NewAccInputHashDoesNotExist\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NewPendingStateTimeoutMustBeLower\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NewStateRootNotInsidePrime\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NewTrustedAggregatorTimeoutMustBeLower\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OldAccInputHashDoesNotExist\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OldStateRootDoesNotExist\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OnlyEmergencyState\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OnlyNotEmergencyState\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"PendingStateDoesNotExist\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"PendingStateInvalid\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"PendingStateNotConsolidable\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"RollupMustExist\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"RollupTypeDoesNotExist\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"RollupTypeObsolete\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SenderMustBeRollup\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"StoredRootMustBeDifferentThanNewRoot\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TrustedAggregatorTimeoutNotExpired\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"UpdateNotCompatible\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"UpdateToSameRollupTypeID\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint32\",\"name\":\"rollupID\",\"type\":\"uint32\"},{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"forkID\",\"type\":\"uint64\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"rollupAddress\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"chainID\",\"type\":\"uint64\"},{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"rollupCompatibilityID\",\"type\":\"uint8\"},{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"lastVerifiedBatchBeforeUpgrade\",\"type\":\"uint64\"}],\"name\":\"AddExistingRollup\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint32\",\"name\":\"rollupTypeID\",\"type\":\"uint32\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"consensusImplementation\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"verifier\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"forkID\",\"type\":\"uint64\"},{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"rollupCompatibilityID\",\"type\":\"uint8\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"genesis\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"description\",\"type\":\"string\"}],\"name\":\"AddNewRollupType\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint32\",\"name\":\"rollupID\",\"type\":\"uint32\"},{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"numBatch\",\"type\":\"uint64\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"stateRoot\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"exitRoot\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"pendingStateNum\",\"type\":\"uint64\"}],\"name\":\"ConsolidatePendingState\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint32\",\"name\":\"rollupID\",\"type\":\"uint32\"},{\"indexed\":false,\"internalType\":\"uint32\",\"name\":\"rollupTypeID\",\"type\":\"uint32\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"rollupAddress\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"chainID\",\"type\":\"uint64\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"gasTokenAddress\",\"type\":\"address\"}],\"name\":\"CreateNewRollup\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[],\"name\":\"EmergencyStateActivated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[],\"name\":\"EmergencyStateDeactivated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint32\",\"name\":\"rollupTypeID\",\"type\":\"uint32\"}],\"name\":\"ObsoleteRollupType\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint32\",\"name\":\"rollupID\",\"type\":\"uint32\"},{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"lastBatchSequenced\",\"type\":\"uint64\"}],\"name\":\"OnSequenceBatches\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint32\",\"name\":\"rollupID\",\"type\":\"uint32\"},{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"numBatch\",\"type\":\"uint64\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"stateRoot\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"exitRoot\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"aggregator\",\"type\":\"address\"}],\"name\":\"OverridePendingState\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"storedStateRoot\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"provedStateRoot\",\"type\":\"bytes32\"}],\"name\":\"ProveNonDeterministicPendingState\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"previousAdminRole\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"newAdminRole\",\"type\":\"bytes32\"}],\"name\":\"RoleAdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"RoleGranted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"RoleRevoked\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"newBatchFee\",\"type\":\"uint256\"}],\"name\":\"SetBatchFee\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint16\",\"name\":\"newMultiplierBatchFee\",\"type\":\"uint16\"}],\"name\":\"SetMultiplierBatchFee\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"newPendingStateTimeout\",\"type\":\"uint64\"}],\"name\":\"SetPendingStateTimeout\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newTrustedAggregator\",\"type\":\"address\"}],\"name\":\"SetTrustedAggregator\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"newTrustedAggregatorTimeout\",\"type\":\"uint64\"}],\"name\":\"SetTrustedAggregatorTimeout\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"newVerifyBatchTimeTarget\",\"type\":\"uint64\"}],\"name\":\"SetVerifyBatchTimeTarget\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint32\",\"name\":\"rollupID\",\"type\":\"uint32\"},{\"indexed\":false,\"internalType\":\"uint32\",\"name\":\"newRollupTypeID\",\"type\":\"uint32\"},{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"lastVerifiedBatchBeforeUpgrade\",\"type\":\"uint64\"}],\"name\":\"UpdateRollup\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint32\",\"name\":\"rollupID\",\"type\":\"uint32\"},{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"numBatch\",\"type\":\"uint64\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"stateRoot\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"exitRoot\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"aggregator\",\"type\":\"address\"}],\"name\":\"VerifyBatches\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint32\",\"name\":\"rollupID\",\"type\":\"uint32\"},{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"numBatch\",\"type\":\"uint64\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"stateRoot\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"exitRoot\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"aggregator\",\"type\":\"address\"}],\"name\":\"VerifyBatchesTrustedAggregator\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"DEFAULT_ADMIN_ROLE\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"activateEmergencyState\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractIPolygonRollupBase\",\"name\":\"rollupAddress\",\"type\":\"address\"},{\"internalType\":\"contractIVerifierRollup\",\"name\":\"verifier\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"forkID\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"chainID\",\"type\":\"uint64\"},{\"internalType\":\"bytes32\",\"name\":\"genesis\",\"type\":\"bytes32\"},{\"internalType\":\"uint8\",\"name\":\"rollupCompatibilityID\",\"type\":\"uint8\"}],\"name\":\"addExistingRollup\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"consensusImplementation\",\"type\":\"address\"},{\"internalType\":\"contractIVerifierRollup\",\"name\":\"verifier\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"forkID\",\"type\":\"uint64\"},{\"internalType\":\"uint8\",\"name\":\"rollupCompatibilityID\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"genesis\",\"type\":\"bytes32\"},{\"internalType\":\"string\",\"name\":\"description\",\"type\":\"string\"}],\"name\":\"addNewRollupType\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"bridgeAddress\",\"outputs\":[{\"internalType\":\"contractIPolygonZkEVMBridge\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"calculateRewardPerBatch\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint64\",\"name\":\"chainID\",\"type\":\"uint64\"}],\"name\":\"chainIDToRollupID\",\"outputs\":[{\"internalType\":\"uint32\",\"name\":\"rollupID\",\"type\":\"uint32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"rollupID\",\"type\":\"uint32\"},{\"internalType\":\"uint64\",\"name\":\"pendingStateNum\",\"type\":\"uint64\"}],\"name\":\"consolidatePendingState\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"rollupTypeID\",\"type\":\"uint32\"},{\"internalType\":\"uint64\",\"name\":\"chainID\",\"type\":\"uint64\"},{\"internalType\":\"address\",\"name\":\"admin\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"sequencer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"gasTokenAddress\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"sequencerURL\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"networkName\",\"type\":\"string\"}],\"name\":\"createNewRollup\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"deactivateEmergencyState\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getBatchFee\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getForcedBatchFee\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"rollupID\",\"type\":\"uint32\"},{\"internalType\":\"uint64\",\"name\":\"initNumBatch\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"finalNewBatch\",\"type\":\"uint64\"},{\"internalType\":\"bytes32\",\"name\":\"newLocalExitRoot\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"oldStateRoot\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"newStateRoot\",\"type\":\"bytes32\"}],\"name\":\"getInputSnarkBytes\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"rollupID\",\"type\":\"uint32\"}],\"name\":\"getLastVerifiedBatch\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"}],\"name\":\"getRoleAdmin\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"rollupID\",\"type\":\"uint32\"},{\"internalType\":\"uint64\",\"name\":\"batchNum\",\"type\":\"uint64\"}],\"name\":\"getRollupBatchNumToStateRoot\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getRollupExitRoot\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"rollupID\",\"type\":\"uint32\"},{\"internalType\":\"uint64\",\"name\":\"batchNum\",\"type\":\"uint64\"}],\"name\":\"getRollupPendingStateTransitions\",\"outputs\":[{\"components\":[{\"internalType\":\"uint64\",\"name\":\"timestamp\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"lastVerifiedBatch\",\"type\":\"uint64\"},{\"internalType\":\"bytes32\",\"name\":\"exitRoot\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"stateRoot\",\"type\":\"bytes32\"}],\"internalType\":\"structLegacyZKEVMStateVariables.PendingState\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"rollupID\",\"type\":\"uint32\"},{\"internalType\":\"uint64\",\"name\":\"batchNum\",\"type\":\"uint64\"}],\"name\":\"getRollupSequencedBatches\",\"outputs\":[{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"accInputHash\",\"type\":\"bytes32\"},{\"internalType\":\"uint64\",\"name\":\"sequencedTimestamp\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"previousLastBatchSequenced\",\"type\":\"uint64\"}],\"internalType\":\"structLegacyZKEVMStateVariables.SequencedBatchData\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"globalExitRootManager\",\"outputs\":[{\"internalType\":\"contractIPolygonZkEVMGlobalExitRoot\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"grantRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"hasRole\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"trustedAggregator\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"_pendingStateTimeout\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"_trustedAggregatorTimeout\",\"type\":\"uint64\"},{\"internalType\":\"address\",\"name\":\"admin\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"timelock\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"emergencyCouncil\",\"type\":\"address\"},{\"internalType\":\"contractPolygonZkEVMV2Existent\",\"name\":\"polygonZkEVM\",\"type\":\"address\"},{\"internalType\":\"contractIVerifierRollup\",\"name\":\"zkEVMVerifier\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"zkEVMForkID\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"zkEVMChainID\",\"type\":\"uint64\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"trustedAggregator\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"_pendingStateTimeout\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"_trustedAggregatorTimeout\",\"type\":\"uint64\"},{\"internalType\":\"address\",\"name\":\"admin\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"timelock\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"emergencyCouncil\",\"type\":\"address\"}],\"name\":\"initializeMock\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"isEmergencyState\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"rollupID\",\"type\":\"uint32\"},{\"internalType\":\"uint64\",\"name\":\"pendingStateNum\",\"type\":\"uint64\"}],\"name\":\"isPendingStateConsolidable\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"lastAggregationTimestamp\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"multiplierBatchFee\",\"outputs\":[{\"internalType\":\"uint16\",\"name\":\"\",\"type\":\"uint16\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"rollupTypeID\",\"type\":\"uint32\"}],\"name\":\"obsoleteRollupType\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint64\",\"name\":\"newSequencedBatches\",\"type\":\"uint64\"},{\"internalType\":\"bytes32\",\"name\":\"newAccInputHash\",\"type\":\"bytes32\"}],\"name\":\"onSequenceBatches\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"rollupID\",\"type\":\"uint32\"},{\"internalType\":\"uint64\",\"name\":\"initPendingStateNum\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"finalPendingStateNum\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"initNumBatch\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"finalNewBatch\",\"type\":\"uint64\"},{\"internalType\":\"bytes32\",\"name\":\"newLocalExitRoot\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"newStateRoot\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32[24]\",\"name\":\"proof\",\"type\":\"bytes32[24]\"}],\"name\":\"overridePendingState\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pendingStateTimeout\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pol\",\"outputs\":[{\"internalType\":\"contractIERC20Upgradeable\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"rollupID\",\"type\":\"uint32\"},{\"internalType\":\"uint64\",\"name\":\"initPendingStateNum\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"finalPendingStateNum\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"initNumBatch\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"finalNewBatch\",\"type\":\"uint64\"},{\"internalType\":\"bytes32\",\"name\":\"newLocalExitRoot\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"newStateRoot\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32[24]\",\"name\":\"proof\",\"type\":\"bytes32[24]\"}],\"name\":\"proveNonDeterministicPendingState\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"renounceRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"revokeRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"rollupAddress\",\"type\":\"address\"}],\"name\":\"rollupAddressToID\",\"outputs\":[{\"internalType\":\"uint32\",\"name\":\"rollupID\",\"type\":\"uint32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"rollupCount\",\"outputs\":[{\"internalType\":\"uint32\",\"name\":\"\",\"type\":\"uint32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"rollupID\",\"type\":\"uint32\"}],\"name\":\"rollupIDToRollupData\",\"outputs\":[{\"internalType\":\"contractIPolygonRollupBase\",\"name\":\"rollupContract\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"chainID\",\"type\":\"uint64\"},{\"internalType\":\"contractIVerifierRollup\",\"name\":\"verifier\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"forkID\",\"type\":\"uint64\"},{\"internalType\":\"bytes32\",\"name\":\"lastLocalExitRoot\",\"type\":\"bytes32\"},{\"internalType\":\"uint64\",\"name\":\"lastBatchSequenced\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"lastVerifiedBatch\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"lastPendingState\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"lastPendingStateConsolidated\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"lastVerifiedBatchBeforeUpgrade\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"rollupTypeID\",\"type\":\"uint64\"},{\"internalType\":\"uint8\",\"name\":\"rollupCompatibilityID\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"rollupTypeCount\",\"outputs\":[{\"internalType\":\"uint32\",\"name\":\"\",\"type\":\"uint32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"rollupTypeID\",\"type\":\"uint32\"}],\"name\":\"rollupTypeMap\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"consensusImplementation\",\"type\":\"address\"},{\"internalType\":\"contractIVerifierRollup\",\"name\":\"verifier\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"forkID\",\"type\":\"uint64\"},{\"internalType\":\"uint8\",\"name\":\"rollupCompatibilityID\",\"type\":\"uint8\"},{\"internalType\":\"bool\",\"name\":\"obsolete\",\"type\":\"bool\"},{\"internalType\":\"bytes32\",\"name\":\"genesis\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"newBatchFee\",\"type\":\"uint256\"}],\"name\":\"setBatchFee\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint16\",\"name\":\"newMultiplierBatchFee\",\"type\":\"uint16\"}],\"name\":\"setMultiplierBatchFee\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint64\",\"name\":\"newPendingStateTimeout\",\"type\":\"uint64\"}],\"name\":\"setPendingStateTimeout\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint64\",\"name\":\"newTrustedAggregatorTimeout\",\"type\":\"uint64\"}],\"name\":\"setTrustedAggregatorTimeout\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint64\",\"name\":\"newVerifyBatchTimeTarget\",\"type\":\"uint64\"}],\"name\":\"setVerifyBatchTimeTarget\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalSequencedBatches\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalVerifiedBatches\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"trustedAggregatorTimeout\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractITransparentUpgradeableProxy\",\"name\":\"rollupContract\",\"type\":\"address\"},{\"internalType\":\"uint32\",\"name\":\"newRollupTypeID\",\"type\":\"uint32\"},{\"internalType\":\"bytes\",\"name\":\"upgradeData\",\"type\":\"bytes\"}],\"name\":\"updateRollup\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"verifyBatchTimeTarget\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"rollupID\",\"type\":\"uint32\"},{\"internalType\":\"uint64\",\"name\":\"pendingStateNum\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"initNumBatch\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"finalNewBatch\",\"type\":\"uint64\"},{\"internalType\":\"bytes32\",\"name\":\"newLocalExitRoot\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"newStateRoot\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"beneficiary\",\"type\":\"address\"},{\"internalType\":\"bytes32[24]\",\"name\":\"proof\",\"type\":\"bytes32[24]\"}],\"name\":\"verifyBatches\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"rollupID\",\"type\":\"uint32\"},{\"internalType\":\"uint64\",\"name\":\"pendingStateNum\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"initNumBatch\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"finalNewBatch\",\"type\":\"uint64\"},{\"internalType\":\"bytes32\",\"name\":\"newLocalExitRoot\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"newStateRoot\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"beneficiary\",\"type\":\"address\"},{\"internalType\":\"bytes32[24]\",\"name\":\"proof\",\"type\":\"bytes32[24]\"}],\"name\":\"verifyBatchesTrustedAggregator\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", + Bin: "0x60e06040523480156200001157600080fd5b50604051620060853803806200608583398101604081905262000034916200006b565b6001600160a01b0392831660805290821660c0521660a052620000bf565b6001600160a01b03811681146200006857600080fd5b50565b6000806000606084860312156200008157600080fd5b83516200008e8162000052565b6020850151909350620000a18162000052565b6040850151909250620000b48162000052565b809150509250925092565b60805160a05160c051615f5e6200012760003960008181610999015281816122230152613aa301526000818161075f01528181612d720152613d9d0152600081816108f3015281816112f0015281816114a001528181611f8a0152613c8c0152615f5e6000f3fe60806040523480156200001157600080fd5b50600436106200029e5760003560e01c80630645af0914620002a3578063066ec01214620002bc578063080b311114620002e85780630a0d9fbe14620003105780630e36f582146200032b57806311f6b287146200034257806312b86e1914620003595780631489ed10146200037057806315064c9614620003875780631608859c14620003955780631796a1ae14620003ac5780631816b7e514620003d35780632072f6c514620003ea578063248a9ca314620003f457806325280169146200041a5780632f2ff15d14620004cf57806336568abe14620004e6578063394218e914620004fd578063477fa270146200051457806355a71ee0146200051d57806360469169146200056157806365c0504d146200056b5780637222020f146200061a578063727885e914620006315780637975fcfe14620006485780637fb6e76a146200066e578063841b24d7146200069757806387c20c0114620006b25780638bd4f07114620006c957806391d1485414620006e057806399f5634e14620006f75780639a908e7314620007015780639c9f3dfe1462000718578063a066215c146200072f578063a217fddf1462000746578063a2967d99146200074f578063a3c573eb1462000759578063afd23cbe1462000790578063b99d0ad714620007ba578063c1acbc341462000892578063c4c928c214620008ad578063ceee281d14620008c4578063d02103ca14620008ed578063d5073f6f1462000915578063d547741f146200092c578063d939b3151462000943578063dbc169761462000957578063dde0ff771462000961578063e0bfd3d2146200097c578063e46761c41462000993578063f34eb8eb14620009bb578063f4e9267514620009d2578063f9c4c2ae14620009e3575b600080fd5b620002ba620002b436600462004754565b62000afa565b005b608454620002d0906001600160401b031681565b604051620002df91906200482f565b60405180910390f35b620002ff620002f936600462004858565b62000f4c565b6040519015158152602001620002df565b608554620002d090600160401b90046001600160401b031681565b620002ba6200033c36600462004890565b62000f76565b620002d0620003533660046200491b565b62001224565b620002ba6200036a3660046200494c565b62001244565b620002ba62000381366004620049e3565b620013f4565b606f54620002ff9060ff1681565b620002ba620003a636600462004858565b62001584565b607e54620003bd9063ffffffff1681565b60405163ffffffff9091168152602001620002df565b620002ba620003e436600462004a6d565b62001619565b620002ba620016c5565b6200040b6200040536600462004a9a565b6200175b565b604051908152602001620002df565b6200049b6200042b36600462004858565b60408051606080820183526000808352602080840182905292840181905263ffffffff959095168552608182528285206001600160401b03948516865260030182529382902082519485018352805485526001015480841691850191909152600160401b90049091169082015290565b60408051825181526020808401516001600160401b03908116918301919091529282015190921690820152606001620002df565b620002ba620004e036600462004ab4565b62001770565b620002ba620004f736600462004ab4565b62001792565b620002ba6200050e36600462004ae7565b620017cc565b6086546200040b565b6200040b6200052e36600462004858565b63ffffffff821660009081526081602090815260408083206001600160401b038516845260020190915290205492915050565b6200040b6200187b565b620005d06200057c3660046200491b565b607f602052600090815260409020805460018201546002909201546001600160a01b0391821692918216916001600160401b03600160a01b8204169160ff600160e01b8304811692600160e81b9004169086565b604080516001600160a01b0397881681529690951660208701526001600160401b039093169385019390935260ff166060840152901515608083015260a082015260c001620002df565b620002ba6200062b3660046200491b565b62001893565b620002ba6200064236600462004baf565b6200197e565b6200065f6200065936600462004c7c565b62001de6565b604051620002df919062004d36565b620003bd6200067f36600462004ae7565b60836020526000908152604090205463ffffffff1681565b608454620002d090600160c01b90046001600160401b031681565b620002ba620006c3366004620049e3565b62001e19565b620002ba620006da3660046200494c565b6200213d565b620002ff620006f136600462004ab4565b620021f3565b6200040b6200221e565b620002d06200071236600462004d4b565b6200230a565b620002ba6200072936600462004ae7565b620024d7565b620002ba6200074036600462004ae7565b6200257a565b6200040b600081565b6200040b62002619565b620007817f000000000000000000000000000000000000000000000000000000000000000081565b604051620002df919062004d78565b608554620007a690600160801b900461ffff1681565b60405161ffff9091168152602001620002df565b62000850620007cb36600462004858565b604080516080808201835260008083526020808401829052838501829052606093840182905263ffffffff969096168152608186528381206001600160401b03958616825260040186528390208351918201845280548086168352600160401b9004909416948101949094526001830154918401919091526002909101549082015290565b604051620002df919081516001600160401b03908116825260208084015190911690820152604082810151908201526060918201519181019190915260800190565b608454620002d090600160801b90046001600160401b031681565b620002ba620008be36600462004d8c565b620029db565b620003bd620008d536600462004e24565b60826020526000908152604090205463ffffffff1681565b620007817f000000000000000000000000000000000000000000000000000000000000000081565b620002ba6200092636600462004a9a565b62002ca8565b620002ba6200093d36600462004ab4565b62002d33565b608554620002d0906001600160401b031681565b620002ba62002d55565b608454620002d090600160401b90046001600160401b031681565b620002ba6200098d36600462004e56565b62002df2565b620007817f000000000000000000000000000000000000000000000000000000000000000081565b620002ba620009cc36600462004ed2565b62002e7c565b608054620003bd9063ffffffff1681565b62000a7a620009f43660046200491b565b608160205260009081526040902080546001820154600583015460068401546007909401546001600160a01b0380851695600160a01b958690046001600160401b039081169692861695929092048216939282821692600160401b808404821693600160801b808204841694600160c01b90920484169380831693830416910460ff168c565b604080516001600160a01b039d8e1681526001600160401b039c8d1660208201529c909a16998c019990995296891660608b015260808a019590955292871660a089015290861660c0880152851660e0870152841661010086015283166101208501529190911661014083015260ff1661016082015261018001620002df565b600054600290610100900460ff1615801562000b1d575060005460ff8083169116105b62000b455760405162461bcd60e51b815260040162000b3c9062004f69565b60405180910390fd5b6000805461010060ff841661ffff199092169190911717905560858054608480546001600160c01b0316600160c01b6001600160401b038e8116919091029190911790915567016345785d8a00006086558c166001600160801b03199091161760e160431b1761ffff60801b19166101f560811b17905562000bc662003067565b62000be160008051602062005f098339815191528c620030d4565b62000bee600088620030d4565b62000c0960008051602062005de983398151915288620030d4565b62000c2460008051602062005e6983398151915288620030d4565b62000c3f60008051602062005d8983398151915288620030d4565b62000c5a60008051602062005dc983398151915289620030d4565b62000c7560008051602062005ee983398151915289620030d4565b62000c9060008051602062005e0983398151915289620030d4565b62000cab60008051602062005e8983398151915289620030d4565b62000cd560008051602062005f0983398151915260008051602062005d69833981519152620030e0565b62000cf060008051602062005d6983398151915289620030d4565b62000d0b60008051602062005da983398151915289620030d4565b62000d3560008051602062005ec983398151915260008051602062005ea9833981519152620030e0565b62000d5060008051602062005ec983398151915287620030d4565b62000d6b60008051602062005ea983398151915287620030d4565b6073546074546001600160401b03600160401b9092048216911680821462000da657604051632e4cc54360e11b815260040160405180910390fd5b600062000dce888888886000607460009054906101000a90046001600160401b031662003135565b6001600160401b03838116600081815260756020908152604080832054600287018352818420558885168084526072808452828520600389018552948390208554815560018087018054919092018054918a166001600160401b03198084168217835593546001600160801b0319938416909117600160401b918290048c1682021790915560068b018054909216909417938802939093179092556007880180549092169095179055607a54606f54949092529154607354925163176b20e160e31b81529596506001600160a01b038e81169663bb5907089662000ed09694831695600160581b90950490921693607693607793909291169060040162005063565b600060405180830381600087803b15801562000eeb57600080fd5b505af115801562000f00573d6000803e3d6000fd5b50506000805461ff0019169055505060405160ff8516815260008051602062005e498339815191529350602001915062000f379050565b60405180910390a15050505050505050505050565b63ffffffff8216600090815260816020526040812062000f6d908362003363565b90505b92915050565b600054600290610100900460ff1615801562000f99575060005460ff8083169116105b62000fb85760405162461bcd60e51b815260040162000b3c9062004f69565b6000805461010060ff841661ffff199092169190911717905560858054608480546001600160c01b0316600160c01b6001600160401b038a8116919091029190911790915567016345785d8a000060865588166001600160801b03199091161760e160431b1761ffff60801b19166101f560811b1790556200103962003067565b6200105460008051602062005f0983398151915288620030d4565b62001061600084620030d4565b6200107c60008051602062005de983398151915284620030d4565b6200109760008051602062005e6983398151915284620030d4565b620010b260008051602062005d8983398151915284620030d4565b620010cd60008051602062005dc983398151915285620030d4565b620010e860008051602062005ee983398151915285620030d4565b6200110360008051602062005e0983398151915285620030d4565b6200111e60008051602062005e8983398151915285620030d4565b6200114860008051602062005f0983398151915260008051602062005d69833981519152620030e0565b6200116360008051602062005d6983398151915285620030d4565b6200117e60008051602062005da983398151915285620030d4565b620011a860008051602062005ec983398151915260008051602062005ea9833981519152620030e0565b620011c360008051602062005ec983398151915283620030d4565b620011de60008051602062005ea983398151915283620030d4565b620011eb600033620030d4565b6000805461ff001916905560405160ff8216815260008051602062005e498339815191529060200160405180910390a150505050505050565b63ffffffff8116600090815260816020526040812062000f7090620033a8565b60008051602062005f098339815191526200125f8162003419565b63ffffffff8916600090815260816020526040902062001286818a8a8a8a8a8a8a62003425565b600681018054600160401b600160801b031916600160401b6001600160401b0389811691820292909217835560009081526002840160205260409020869055600583018790559054600160801b90041615620012ee576006810180546001600160801b031690555b7f00000000000000000000000000000000000000000000000000000000000000006001600160a01b03166333d6247d6200132762002619565b6040518263ffffffff1660e01b81526004016200134691815260200190565b600060405180830381600087803b1580156200136157600080fd5b505af115801562001376573d6000803e3d6000fd5b5050608480546001600160c01b031661127560c71b1790555050604080516001600160401b03881681526020810186905290810186905233606082015263ffffffff8b16907f3182bd6e6f74fc1fdc88b60f3a4f4c7f79db6ae6f5b88a1b3f5a1e28ec210d5e9060800160405180910390a250505050505050505050565b60008051602062005f098339815191526200140f8162003419565b63ffffffff8916600090815260816020526040902062001436818a8a8a8a8a8a8a620037ad565b600681018054600160401b600160801b031916600160401b6001600160401b038a811691820292909217835560009081526002840160205260409020879055600583018890559054600160801b900416156200149e576006810180546001600160801b031690555b7f00000000000000000000000000000000000000000000000000000000000000006001600160a01b03166333d6247d620014d762002619565b6040518263ffffffff1660e01b8152600401620014f691815260200190565b600060405180830381600087803b1580156200151157600080fd5b505af115801562001526573d6000803e3d6000fd5b50505050336001600160a01b03168a63ffffffff167fd1ec3a1216f08b6eff72e169ceb548b782db18a6614852618d86bb19f3f9b0d389888a6040516200157093929190620050c9565b60405180910390a350505050505050505050565b63ffffffff82166000908152608160205260409020620015b460008051602062005f0983398151915233620021f3565b6200160857606f5460ff1615620015de57604051630bc011ff60e21b815260040160405180910390fd5b620015ea818362003363565b6200160857604051630674f25160e11b815260040160405180910390fd5b62001614818362003ba9565b505050565b60008051602062005e89833981519152620016348162003419565b6103e88261ffff1610806200164e57506103ff8261ffff16115b156200166d57604051630984a67960e31b815260040160405180910390fd5b6085805461ffff60801b1916600160801b61ffff8516908102919091179091556040519081527f7019933d795eba185c180209e8ae8bffbaa25bcef293364687702c31f4d302c5906020015b60405180910390a15050565b620016e060008051602062005ec983398151915233620021f3565b6200174f57608454600160801b90046001600160401b031615806200173057506084544290620017259062093a8090600160801b90046001600160401b031662005100565b6001600160401b0316115b156200174f5760405163692baaad60e11b815260040160405180910390fd5b6200175962003d9b565b565b60009081526034602052604090206001015490565b6200177b826200175b565b620017868162003419565b62001614838362003e1a565b6001600160a01b0381163314620017bc57604051630b4ad1cd60e31b815260040160405180910390fd5b620017c8828262003e86565b5050565b60008051602062005e89833981519152620017e78162003419565b606f5460ff1662001829576084546001600160401b03600160c01b909104811690831610620018295760405163401636df60e01b815260040160405180910390fd5b608480546001600160c01b0316600160c01b6001600160401b038516021790556040517f1f4fa24c2e4bad19a7f3ec5c5485f70d46c798461c2e684f55bbd0fc661373a190620016b99084906200482f565b600060865460646200188e91906200512a565b905090565b60008051602062005dc9833981519152620018ae8162003419565b63ffffffff82161580620018cd5750607e5463ffffffff908116908316115b15620018ec57604051637512e5cb60e01b815260040160405180910390fd5b63ffffffff82166000908152607f60205260409020600180820154600160e81b900460ff16151590036200193357604051633b8d3d9960e01b815260040160405180910390fd5b60018101805460ff60e81b1916600160e81b17905560405163ffffffff8416907f4710d2ee567ef1ed6eb2f651dde4589524bcf7cebc62147a99b281cc836e7e4490600090a2505050565b60008051602062005ee9833981519152620019998162003419565b63ffffffff88161580620019b85750607e5463ffffffff908116908916115b15620019d757604051637512e5cb60e01b815260040160405180910390fd5b63ffffffff88166000908152607f60205260409020600180820154600160e81b900460ff161515900362001a1e57604051633b8d3d9960e01b815260040160405180910390fd5b6001600160401b03881660009081526083602052604090205463ffffffff161562001a5c576040516337c8fe0960e11b815260040160405180910390fd5b6080805460009190829062001a779063ffffffff1662005144565b825463ffffffff8281166101009490940a9384029302191691909117909155825460408051600080825260208201928390529394506001600160a01b0390921691309162001ac59062004718565b62001ad3939291906200516a565b604051809103906000f08015801562001af0573d6000803e3d6000fd5b50905081608360008c6001600160401b03166001600160401b0316815260200190815260200160002060006101000a81548163ffffffff021916908363ffffffff1602179055508160826000836001600160a01b03166001600160a01b0316815260200190815260200160002060006101000a81548163ffffffff021916908363ffffffff1602179055506000608160008463ffffffff1663ffffffff1681526020019081526020016000209050818160000160006101000a8154816001600160a01b0302191690836001600160a01b031602179055508360010160149054906101000a90046001600160401b03168160010160146101000a8154816001600160401b0302191690836001600160401b031602179055508360010160009054906101000a90046001600160a01b03168160010160006101000a8154816001600160a01b0302191690836001600160a01b031602179055508a8160000160146101000a8154816001600160401b0302191690836001600160401b031602179055508360020154816002016000806001600160401b03168152602001908152602001600020819055508b63ffffffff168160070160086101000a8154816001600160401b0302191690836001600160401b0316021790555083600101601c9054906101000a900460ff168160070160106101000a81548160ff021916908360ff1602179055508263ffffffff167f194c983456df6701c6a50830b90fe80e72b823411d0d524970c9590dc277a6418d848e8c60405162001d64949392919063ffffffff9490941684526001600160a01b0392831660208501526001600160401b0391909116604084015216606082015260800190565b60405180910390a2604051633892b81160e11b81526001600160a01b0383169063712570229062001da4908d908d9088908e908e908e90600401620051a1565b600060405180830381600087803b15801562001dbf57600080fd5b505af115801562001dd4573d6000803e3d6000fd5b50505050505050505050505050505050565b63ffffffff8616600090815260816020526040902060609062001e0e90878787878762003ef0565b979650505050505050565b606f5460ff161562001e3e57604051630bc011ff60e21b815260040160405180910390fd5b63ffffffff881660009081526081602090815260408083206084546001600160401b038a81168652600383019094529190932060010154429262001e8d92600160c01b90048116911662005100565b6001600160401b0316111562001eb657604051638a0704d360e01b815260040160405180910390fd5b6103e862001ec5888862005204565b6001600160401b0316111562001eee57604051635acfba9d60e11b815260040160405180910390fd5b62001f008189898989898989620037ad565b62001f0c81876200402b565b6085546001600160401b03166000036200201a57600681018054600160401b600160801b031916600160401b6001600160401b0389811691820292909217835560009081526002840160205260409020869055600583018790559054600160801b9004161562001f88576006810180546001600160801b031690555b7f00000000000000000000000000000000000000000000000000000000000000006001600160a01b03166333d6247d62001fc162002619565b6040518263ffffffff1660e01b815260040162001fe091815260200190565b600060405180830381600087803b15801562001ffb57600080fd5b505af115801562002010573d6000803e3d6000fd5b50505050620020e4565b620020258162004228565b600681018054600160801b90046001600160401b0316906010620020498362005227565b82546001600160401b039182166101009390930a92830292820219169190911790915560408051608081018252428316815289831660208083019182528284018b8152606084018b81526006890154600160801b90048716600090815260048a01909352949091209251835492518616600160401b026001600160801b03199093169516949094171781559151600183015551600290910155505b336001600160a01b03168963ffffffff167faac1e7a157b259544ebacd6e8a82ae5d6c8f174e12aa48696277bcc9a661f0b48887896040516200212a93929190620050c9565b60405180910390a3505050505050505050565b606f5460ff16156200216257604051630bc011ff60e21b815260040160405180910390fd5b63ffffffff8816600090815260816020526040902062002189818989898989898962003425565b6001600160401b03851660009081526002820160209081526040918290205482519081529081018590527f1f44c21118c4603cfb4e1b621dbcfa2b73efcececee2b99b620b2953d33a7010910160405180910390a1620021e862003d9b565b505050505050505050565b60009182526034602090815260408084206001600160a01b0393909316845291905290205460ff1690565b6000807f00000000000000000000000000000000000000000000000000000000000000006001600160a01b03166370a08231306040518263ffffffff1660e01b81526004016200226f919062004d78565b602060405180830381865afa1580156200228d573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190620022b391906200524e565b608454909150600090620022da906001600160401b03600160401b82048116911662005204565b6001600160401b0316905080600003620022f75760009250505090565b6200230381836200527e565b9250505090565b606f5460009060ff16156200233257604051630bc011ff60e21b815260040160405180910390fd5b3360009081526082602052604081205463ffffffff16908190036200236a576040516371653c1560e01b815260040160405180910390fd5b836001600160401b03166000036200239557604051632590ccf960e01b815260040160405180910390fd5b63ffffffff811660009081526081602052604081206084805491928792620023c89084906001600160401b031662005100565b82546101009290920a6001600160401b0381810219909316918316021790915560068301541690506000620023fe878362005100565b6006840180546001600160401b038084166001600160401b03199092168217909255604080516060810182528a81524284166020808301918252888616838501908152600095865260038b0190915292909320905181559151600192909201805491518416600160401b026001600160801b0319909216929093169190911717905590506200248d8362004228565b8363ffffffff167f1d9f30260051d51d70339da239ea7b080021adcaabfa71c9b0ea339a20cf9a2582604051620024c591906200482f565b60405180910390a29695505050505050565b60008051602062005e89833981519152620024f28162003419565b606f5460ff166200252d576085546001600160401b03908116908316106200252d5760405163048a05a960e41b815260040160405180910390fd5b608580546001600160401b0319166001600160401b0384161790556040517fc4121f4e22c69632ebb7cf1f462be0511dc034f999b52013eddfb24aab765c7590620016b99084906200482f565b60008051602062005e89833981519152620025958162003419565b62015180826001600160401b03161115620025c357604051631c0cfbfd60e31b815260040160405180910390fd5b60858054600160401b600160801b031916600160401b6001600160401b038516021790556040517f1b023231a1ab6b5d93992f168fb44498e1a7e64cef58daff6f1c216de6a68c2890620016b99084906200482f565b60805460009063ffffffff168082036200263557506000919050565b6000816001600160401b0381111562002652576200265262004b05565b6040519080825280602002602001820160405280156200267c578160200160208202803683370190505b50905060005b82811015620026ef57608160006200269c83600162005295565b63ffffffff1663ffffffff16815260200190815260200160002060050154828281518110620026cf57620026cf620052ab565b602090810291909101015280620026e681620052c1565b91505062002682565b50600060205b83600114620029335760006200270d600286620052dd565b6200271a6002876200527e565b62002726919062005295565b90506000816001600160401b0381111562002745576200274562004b05565b6040519080825280602002602001820160405280156200276f578160200160208202803683370190505b50905060005b82811015620028e7576200278b600184620052f4565b81148015620027a65750620027a2600288620052dd565b6001145b15620028265785620027ba8260026200512a565b81518110620027cd57620027cd620052ab565b602002602001015185604051602001620027e99291906200530a565b60405160208183030381529060405280519060200120828281518110620028145762002814620052ab565b602002602001018181525050620028d2565b85620028348260026200512a565b81518110620028475762002847620052ab565b6020026020010151868260026200285f91906200512a565b6200286c90600162005295565b815181106200287f576200287f620052ab565b60200260200101516040516020016200289a9291906200530a565b60405160208183030381529060405280519060200120828281518110620028c557620028c5620052ab565b6020026020010181815250505b80620028de81620052c1565b91505062002775565b508094508195508384604051602001620029039291906200530a565b6040516020818303038152906040528051906020012093508280620029289062005318565b9350505050620026f5565b6000836000815181106200294b576200294b620052ab565b6020026020010151905060005b82811015620029d1578184604051602001620029769291906200530a565b6040516020818303038152906040528051906020012091508384604051602001620029a39291906200530a565b6040516020818303038152906040528051906020012093508080620029c890620052c1565b91505062002958565b5095945050505050565b60008051602062005d89833981519152620029f68162003419565b63ffffffff8416158062002a155750607e5463ffffffff908116908516115b1562002a3457604051637512e5cb60e01b815260040160405180910390fd5b6001600160a01b03851660009081526082602052604081205463ffffffff169081900362002a75576040516374a086a360e01b815260040160405180910390fd5b63ffffffff8181166000908152608160205260409020600781015490918716600160401b9091046001600160401b03160362002ac457604051634f61d51960e01b815260040160405180910390fd5b63ffffffff86166000908152607f60205260409020600180820154600160e81b900460ff161515900362002b0b57604051633b8d3d9960e01b815260040160405180910390fd5b60018101546007830154600160801b900460ff908116600160e01b909204161462002b4957604051635aa0d5f160e11b815260040160405180910390fd5b6001808201805491840180546001600160a01b031981166001600160a01b03909416938417825591546001600160401b03600160a01b9182900416026001600160e01b0319909216909217179055600782018054600160401b63ffffffff8a1602600160401b600160801b0319909116179055600062002bc98462001224565b6007840180546001600160401b0319166001600160401b038316179055825460405163278f794360e11b81529192506001600160a01b038b811692634f1ef2869262002c1e9216908b908b9060040162005332565b600060405180830381600087803b15801562002c3957600080fd5b505af115801562002c4e573d6000803e3d6000fd5b50506040805163ffffffff8c811682526001600160401b0386166020830152881693507ff585e04c05d396901170247783d3e5f0ee9c1df23072985b50af089f5e48b19d92500160405180910390a2505050505050505050565b60008051602062005da983398151915262002cc38162003419565b683635c9adc5dea0000082118062002cde5750633b9aca0082105b1562002cfd57604051638586952560e01b815260040160405180910390fd5b60868290556040518281527ffb383653f53ee079978d0c9aff7aeff04a10166ce244cca9c9f9d8d96bed45b290602001620016b9565b62002d3e826200175b565b62002d498162003419565b62001614838362003e86565b60008051602062005e0983398151915262002d708162003419565b7f00000000000000000000000000000000000000000000000000000000000000006001600160a01b031663dbc169766040518163ffffffff1660e01b8152600401600060405180830381600087803b15801562002dcc57600080fd5b505af115801562002de1573d6000803e3d6000fd5b5050505062002def620042f3565b50565b60008051602062005e6983398151915262002e0d8162003419565b6001600160401b03841660009081526083602052604090205463ffffffff161562002e4b576040516337c8fe0960e11b815260040160405180910390fd5b600062002e5e8888888887600062003135565b60008080526002909101602052604090209390935550505050505050565b60008051602062005de983398151915262002e978162003419565b607e805460009190829062002eb29063ffffffff1662005144565b91906101000a81548163ffffffff021916908363ffffffff160217905590506040518060c00160405280896001600160a01b03168152602001886001600160a01b03168152602001876001600160401b031681526020018660ff16815260200160001515815260200185815250607f60008363ffffffff1663ffffffff16815260200190815260200160002060008201518160000160006101000a8154816001600160a01b0302191690836001600160a01b0316021790555060208201518160010160006101000a8154816001600160a01b0302191690836001600160a01b0316021790555060408201518160010160146101000a8154816001600160401b0302191690836001600160401b03160217905550606082015181600101601c6101000a81548160ff021916908360ff160217905550608082015181600101601d6101000a81548160ff02191690831515021790555060a082015181600201559050508063ffffffff167fa2970448b3bd66ba7e524e7b2a5b9cf94fa29e32488fb942afdfe70dd4b77b52898989898989604051620030559695949392919062005372565b60405180910390a25050505050505050565b600054610100900460ff16620017595760405162461bcd60e51b815260206004820152602b60248201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960448201526a6e697469616c697a696e6760a81b606482015260840162000b3c565b620017c8828262003e1a565b6000620030ed836200175b565b600084815260346020526040808220600101859055519192508391839186917fbd79b86ffe0ab8e8776151514217cd7cacd52c909f66475c3af44e129f0b00ff9190a4505050565b6080805460009182918290620031519063ffffffff1662005144565b91906101000a81548163ffffffff021916908363ffffffff160217905590508060836000876001600160401b03166001600160401b0316815260200190815260200160002060006101000a81548163ffffffff021916908363ffffffff16021790555080608260008a6001600160a01b03166001600160a01b0316815260200190815260200160002060006101000a81548163ffffffff021916908363ffffffff160217905550608160008263ffffffff1663ffffffff1681526020019081526020016000209150878260000160006101000a8154816001600160a01b0302191690836001600160a01b03160217905550858260010160146101000a8154816001600160401b0302191690836001600160401b03160217905550868260010160006101000a8154816001600160a01b0302191690836001600160a01b03160217905550848260000160146101000a8154816001600160401b0302191690836001600160401b03160217905550838260070160106101000a81548160ff021916908360ff1602179055508063ffffffff167fadfc7d56f7e39b08b321534f14bfb135ad27698f7d2f5ad0edc2356ea9a3f850878a888888604051620033509594939291906001600160401b0395861681526001600160a01b03949094166020850152918416604084015260ff166060830152909116608082015260a00190565b60405180910390a2509695505050505050565b6085546001600160401b038281166000908152600485016020526040812054909242926200339692918116911662005100565b6001600160401b031611159392505050565b6006810154600090600160801b90046001600160401b031615620033fc575060068101546001600160401b03600160801b909104811660009081526004909201602052604090912054600160401b90041690565b5060060154600160401b90046001600160401b031690565b919050565b62002def81336200434c565b60078801546000906001600160401b0390811690871610156200345b5760405163ead1340b60e01b815260040160405180910390fd5b6001600160401b03881615620034fc5760068901546001600160401b03600160801b90910481169089161115620034a55760405163bb14c20560e01b815260040160405180910390fd5b506001600160401b03808816600090815260048a0160205260409020600281015481549092888116600160401b9092041614620034f557604051632bd2e3e760e01b815260040160405180910390fd5b5062003571565b506001600160401b03851660009081526002890160205260409020548062003537576040516324cbdcc360e11b815260040160405180910390fd5b60068901546001600160401b03600160401b909104811690871611156200357157604051630f2b74f160e11b815260040160405180910390fd5b60068901546001600160401b03600160801b90910481169088161180620035aa5750876001600160401b0316876001600160401b031611155b80620035ce575060068901546001600160401b03600160c01b909104811690881611155b15620035ed5760405163bfa7079f60e01b815260040160405180910390fd5b6001600160401b03878116600090815260048b016020526040902054600160401b900481169086161462003634576040516332a2a77f60e01b815260040160405180910390fd5b6000620036468a888888868962003ef0565b9050600060008051602062005e298339815191526002836040516200366c9190620053cb565b602060405180830381855afa1580156200368a573d6000803e3d6000fd5b5050506040513d601f19601f82011682018060405250810190620036af91906200524e565b620036bb9190620052dd565b60018c0154604080516020810182528381529051634890ed4560e11b81529293506001600160a01b0390911691639121da8a91620036ff91889190600401620053e9565b602060405180830381865afa1580156200371d573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019062003743919062005426565b62003761576040516309bde33960e01b815260040160405180910390fd5b6001600160401b038916600090815260048c016020526040902060020154859003620037a05760405163a47276bd60e01b815260040160405180910390fd5b5050505050505050505050565b600080620037bb8a620033a8565b60078b01549091506001600160401b039081169089161015620037f15760405163ead1340b60e01b815260040160405180910390fd5b6001600160401b03891615620038945760068a01546001600160401b03600160801b9091048116908a1611156200383b5760405163bb14c20560e01b815260040160405180910390fd5b6001600160401b03808a16600090815260048c01602052604090206002810154815490945090918a8116600160401b90920416146200388d57604051632bd2e3e760e01b815260040160405180910390fd5b5062003904565b6001600160401b038816600090815260028b016020526040902054915081620038d0576040516324cbdcc360e11b815260040160405180910390fd5b806001600160401b0316886001600160401b031611156200390457604051630f2b74f160e11b815260040160405180910390fd5b806001600160401b0316876001600160401b031611620039375760405163b9b18f5760e01b815260040160405180910390fd5b6000620039498b8a8a8a878b62003ef0565b9050600060008051602062005e298339815191526002836040516200396f9190620053cb565b602060405180830381855afa1580156200398d573d6000803e3d6000fd5b5050506040513d601f19601f82011682018060405250810190620039b291906200524e565b620039be9190620052dd565b60018d0154604080516020810182528381529051634890ed4560e11b81529293506001600160a01b0390911691639121da8a9162003a0291899190600401620053e9565b602060405180830381865afa15801562003a20573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019062003a46919062005426565b62003a64576040516309bde33960e01b815260040160405180910390fd5b600062003a72848b62005204565b905062003acb87826001600160401b031662003a8d6200221e565b62003a9991906200512a565b6001600160a01b037f000000000000000000000000000000000000000000000000000000000000000016919062004376565b80608460088282829054906101000a90046001600160401b031662003af1919062005100565b82546101009290920a6001600160401b0381810219909316918316021790915560848054600160801b600160c01b031916600160801b428416021790558e546040516332c2d15360e01b8152918d166004830152602482018b90523360448301526001600160a01b031691506332c2d15390606401600060405180830381600087803b15801562003b8157600080fd5b505af115801562003b96573d6000803e3d6000fd5b5050505050505050505050505050505050565b60068201546001600160401b03600160c01b909104811690821611158062003be8575060068201546001600160401b03600160801b9091048116908216115b1562003c075760405163d086b70b60e01b815260040160405180910390fd5b6001600160401b03818116600081815260048501602090815260408083208054600689018054600160401b600160801b031916600160401b92839004909816918202979097178755600280830154828752908a0190945291909320919091556001820154600587015583546001600160c01b0316600160c01b909302929092179092557f00000000000000000000000000000000000000000000000000000000000000006001600160a01b03166333d6247d62003cc362002619565b6040518263ffffffff1660e01b815260040162003ce291815260200190565b600060405180830381600087803b15801562003cfd57600080fd5b505af115801562003d12573d6000803e3d6000fd5b505085546001600160a01b0316600090815260826020908152604091829020546002870154600188015484516001600160401b03898116825294810192909252818501529188166060830152915163ffffffff90921693507f581910eb7a27738945c2f00a91f2284b2d6de9d4e472b12f901c2b0df045e21b925081900360800190a250505050565b7f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316632072f6c56040518163ffffffff1660e01b8152600401600060405180830381600087803b15801562003df757600080fd5b505af115801562003e0c573d6000803e3d6000fd5b5050505062001759620043ca565b62003e268282620021f3565b620017c85760008281526034602090815260408083206001600160a01b0385168085529252808320805460ff1916600117905551339285917f2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d9190a45050565b62003e928282620021f3565b15620017c85760008281526034602090815260408083206001600160a01b0385168085529252808320805460ff1916905551339285917ff6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b9190a45050565b6001600160401b038086166000818152600389016020526040808220549388168252902054606092911580159062003f26575081155b1562003f455760405163340c614f60e11b815260040160405180910390fd5b8062003f64576040516366385b5160e01b815260040160405180910390fd5b62003f6f8462004427565b62003f8d576040516305dae44f60e21b815260040160405180910390fd5b885460018a01546040516001600160601b03193360601b16602082015260348101889052605481018590526001600160c01b031960c08c811b82166074840152600160a01b94859004811b8216607c84015293909204831b82166084820152608c810187905260ac810184905260cc81018990529189901b1660ec82015260f401604051602081830303815290604052925050509695505050505050565b60006200403883620033a8565b9050816000806200404a848462005204565b6085546001600160401b0391821692506000916200407191600160401b90041642620052f4565b90505b846001600160401b0316846001600160401b031614620040fb576001600160401b03808516600090815260038901602052604090206001810154909116821015620040d6576001810154600160401b90046001600160401b03169450620040f4565b620040e2868662005204565b6001600160401b0316935050620040fb565b5062004074565b6000620041098484620052f4565b9050838110156200416757808403600c81116200412757806200412a565b600c5b9050806103e80a81608560109054906101000a900461ffff1661ffff160a60865402816200415c576200415c62005268565b0460865550620041df565b838103600c81116200417a57806200417d565b600c5b90506000816103e80a82608560109054906101000a900461ffff1661ffff160a670de0b6b3a76400000281620041b757620041b762005268565b04905080608654670de0b6b3a76400000281620041d857620041d862005268565b0460865550505b683635c9adc5dea0000060865411156200420657683635c9adc5dea000006086556200421e565b633b9aca0060865410156200421e57633b9aca006086555b5050505050505050565b60068101546001600160401b03600160c01b82048116600160801b90920416111562002def5760068101546000906200427390600160c01b90046001600160401b0316600162005100565b905062004281828262003363565b15620017c8576006820154600090600290620042af908490600160801b90046001600160401b031662005204565b620042bb91906200544a565b620042c7908362005100565b9050620042d5838262003363565b15620042e75762001614838262003ba9565b62001614838362003ba9565b606f5460ff166200431757604051635386698160e01b815260040160405180910390fd5b606f805460ff191690556040517f1e5e34eea33501aecf2ebec9fe0e884a40804275ea7fe10b2ba084c8374308b390600090a1565b620043588282620021f3565b620017c857604051637615be1f60e11b815260040160405180910390fd5b604080516001600160a01b038416602482015260448082018490528251808303909101815260649091019091526020810180516001600160e01b031663a9059cbb60e01b17905262001614908490620044ad565b606f5460ff1615620043ef57604051630bc011ff60e21b815260040160405180910390fd5b606f805460ff191660011790556040517f2261efe5aef6fedc1fd1550b25facc9181745623049c7901287030b9ad1a549790600090a1565b600067ffffffff000000016001600160401b0383161080156200445e575067ffffffff00000001604083901c6001600160401b0316105b80156200447f575067ffffffff00000001608083901c6001600160401b0316105b801562004497575067ffffffff0000000160c083901c105b15620044a557506001919050565b506000919050565b600062004504826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c6564815250856001600160a01b0316620045869092919063ffffffff16565b80519091501562001614578080602001905181019062004525919062005426565b620016145760405162461bcd60e51b815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e6044820152691bdd081cdd58d8d9595960b21b606482015260840162000b3c565b60606200459784846000856200459f565b949350505050565b606082471015620046025760405162461bcd60e51b815260206004820152602660248201527f416464726573733a20696e73756666696369656e742062616c616e636520666f6044820152651c8818d85b1b60d21b606482015260840162000b3c565b600080866001600160a01b03168587604051620046209190620053cb565b60006040518083038185875af1925050503d80600081146200465f576040519150601f19603f3d011682016040523d82523d6000602084013e62004664565b606091505b509150915062001e0e8783838760608315620046e5578251600003620046dd576001600160a01b0385163b620046dd5760405162461bcd60e51b815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000604482015260640162000b3c565b508162004597565b620045978383815115620046fc5781518083602001fd5b8060405162461bcd60e51b815260040162000b3c919062004d36565b6108f5806200547483390190565b6001600160a01b038116811462002def57600080fd5b80356001600160401b03811681146200341457600080fd5b6000806000806000806000806000806101408b8d0312156200477557600080fd5b8a35620047828162004726565b99506200479260208c016200473c565b9850620047a260408c016200473c565b975060608b0135620047b48162004726565b965060808b0135620047c68162004726565b955060a08b0135620047d88162004726565b945060c08b0135620047ea8162004726565b935060e08b0135620047fc8162004726565b92506200480d6101008c016200473c565b91506200481e6101208c016200473c565b90509295989b9194979a5092959850565b6001600160401b0391909116815260200190565b803563ffffffff811681146200341457600080fd5b600080604083850312156200486c57600080fd5b620048778362004843565b915062004887602084016200473c565b90509250929050565b60008060008060008060c08789031215620048aa57600080fd5b8635620048b78162004726565b9550620048c7602088016200473c565b9450620048d7604088016200473c565b93506060870135620048e98162004726565b92506080870135620048fb8162004726565b915060a08701356200490d8162004726565b809150509295509295509295565b6000602082840312156200492e57600080fd5b62000f6d8262004843565b80610300810183101562000f7057600080fd5b6000806000806000806000806103e0898b0312156200496a57600080fd5b620049758962004843565b97506200498560208a016200473c565b96506200499560408a016200473c565b9550620049a560608a016200473c565b9450620049b560808a016200473c565b935060a0890135925060c08901359150620049d48a60e08b0162004939565b90509295985092959890939650565b6000806000806000806000806103e0898b03121562004a0157600080fd5b62004a0c8962004843565b975062004a1c60208a016200473c565b965062004a2c60408a016200473c565b955062004a3c60608a016200473c565b94506080890135935060a0890135925060c089013562004a5c8162004726565b9150620049d48a60e08b0162004939565b60006020828403121562004a8057600080fd5b813561ffff8116811462004a9357600080fd5b9392505050565b60006020828403121562004aad57600080fd5b5035919050565b6000806040838503121562004ac857600080fd5b82359150602083013562004adc8162004726565b809150509250929050565b60006020828403121562004afa57600080fd5b62000f6d826200473c565b634e487b7160e01b600052604160045260246000fd5b600082601f83011262004b2d57600080fd5b81356001600160401b038082111562004b4a5762004b4a62004b05565b604051601f8301601f19908116603f0116810190828211818310171562004b755762004b7562004b05565b8160405283815286602085880101111562004b8f57600080fd5b836020870160208301376000602085830101528094505050505092915050565b600080600080600080600060e0888a03121562004bcb57600080fd5b62004bd68862004843565b965062004be6602089016200473c565b9550604088013562004bf88162004726565b9450606088013562004c0a8162004726565b9350608088013562004c1c8162004726565b925060a08801356001600160401b038082111562004c3957600080fd5b62004c478b838c0162004b1b565b935060c08a013591508082111562004c5e57600080fd5b5062004c6d8a828b0162004b1b565b91505092959891949750929550565b60008060008060008060c0878903121562004c9657600080fd5b62004ca18762004843565b955062004cb1602088016200473c565b945062004cc1604088016200473c565b9350606087013592506080870135915060a087013590509295509295509295565b60005b8381101562004cff57818101518382015260200162004ce5565b50506000910152565b6000815180845262004d2281602086016020860162004ce2565b601f01601f19169290920160200192915050565b60208152600062000f6d602083018462004d08565b6000806040838503121562004d5f57600080fd5b62004d6a836200473c565b946020939093013593505050565b6001600160a01b0391909116815260200190565b6000806000806060858703121562004da357600080fd5b843562004db08162004726565b935062004dc06020860162004843565b925060408501356001600160401b038082111562004ddd57600080fd5b818701915087601f83011262004df257600080fd5b81358181111562004e0257600080fd5b88602082850101111562004e1557600080fd5b95989497505060200194505050565b60006020828403121562004e3757600080fd5b813562004a938162004726565b803560ff811681146200341457600080fd5b60008060008060008060c0878903121562004e7057600080fd5b863562004e7d8162004726565b9550602087013562004e8f8162004726565b945062004e9f604088016200473c565b935062004eaf606088016200473c565b92506080870135915062004ec660a0880162004e44565b90509295509295509295565b60008060008060008060c0878903121562004eec57600080fd5b863562004ef98162004726565b9550602087013562004f0b8162004726565b945062004f1b604088016200473c565b935062004f2b6060880162004e44565b92506080870135915060a08701356001600160401b0381111562004f4e57600080fd5b62004f5c89828a0162004b1b565b9150509295509295509295565b6020808252602e908201527f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160408201526d191e481a5b9a5d1a585b1a5e995960921b606082015260800190565b8054600090600181811c908083168062004fd257607f831692505b6020808410820362004ff457634e487b7160e01b600052602260045260246000fd5b83885260208801828015620050125760018114620050295762005056565b60ff198716825285151560051b8201975062005056565b60008981526020902060005b87811015620050505781548482015290860190840162005035565b83019850505b5050505050505092915050565b6001600160a01b0387811682528616602082015260c060408201819052600090620050919083018762004fb7565b8281036060840152620050a5818762004fb7565b608084019590955250506001600160401b039190911660a090910152949350505050565b6001600160401b039390931683526020830191909152604082015260600190565b634e487b7160e01b600052601160045260246000fd5b6001600160401b03818116838216019080821115620051235762005123620050ea565b5092915050565b808202811582820484141762000f705762000f70620050ea565b600063ffffffff808316818103620051605762005160620050ea565b6001019392505050565b6001600160a01b03848116825283166020820152606060408201819052600090620051989083018462004d08565b95945050505050565b6001600160a01b038781168252868116602083015263ffffffff861660408301528416606082015260c060808201819052600090620051e39083018562004d08565b82810360a0840152620051f7818562004d08565b9998505050505050505050565b6001600160401b03828116828216039080821115620051235762005123620050ea565b60006001600160401b038281166002600160401b03198101620051605762005160620050ea565b6000602082840312156200526157600080fd5b5051919050565b634e487b7160e01b600052601260045260246000fd5b60008262005290576200529062005268565b500490565b8082018082111562000f705762000f70620050ea565b634e487b7160e01b600052603260045260246000fd5b600060018201620052d657620052d6620050ea565b5060010190565b600082620052ef57620052ef62005268565b500690565b8181038181111562000f705762000f70620050ea565b918252602082015260400190565b6000816200532a576200532a620050ea565b506000190190565b6001600160a01b03841681526040602082018190528101829052818360608301376000818301606090810191909152601f909201601f1916010192915050565b6001600160a01b038781168252861660208201526001600160401b038516604082015260ff841660608201526080810183905260c060a08201819052600090620053bf9083018462004d08565b98975050505050505050565b60008251620053df81846020870162004ce2565b9190910192915050565b61032081016103008085843782018360005b60018110156200541c578151835260209283019290910190600101620053fb565b5050509392505050565b6000602082840312156200543957600080fd5b8151801515811462004a9357600080fd5b60006001600160401b038381168062005467576200546762005268565b9216919091049291505056fe60a0604052604051620008f5380380620008f58339810160408190526100249161035b565b82816100308282610058565b50506001600160a01b03821660805261005061004b60805190565b6100b7565b505050610447565b61006182610126565b6040516001600160a01b038316907fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b90600090a28051156100ab576100a682826101a5565b505050565b6100b361021c565b5050565b7f7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f6100f8600080516020620008d5833981519152546001600160a01b031690565b604080516001600160a01b03928316815291841660208301520160405180910390a16101238161023d565b50565b806001600160a01b03163b60000361016157604051634c9c8ce360e01b81526001600160a01b03821660048201526024015b60405180910390fd5b807f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc5b80546001600160a01b0319166001600160a01b039290921691909117905550565b6060600080846001600160a01b0316846040516101c2919061042b565b600060405180830381855af49150503d80600081146101fd576040519150601f19603f3d011682016040523d82523d6000602084013e610202565b606091505b50909250905061021385838361027d565b95945050505050565b341561023b5760405163b398979f60e01b815260040160405180910390fd5b565b6001600160a01b03811661026757604051633173bdd160e11b815260006004820152602401610158565b80600080516020620008d5833981519152610184565b6060826102925761028d826102dc565b6102d5565b81511580156102a957506001600160a01b0384163b155b156102d257604051639996b31560e01b81526001600160a01b0385166004820152602401610158565b50805b9392505050565b8051156102ec5780518082602001fd5b604051630a12f52160e11b815260040160405180910390fd5b80516001600160a01b038116811461031c57600080fd5b919050565b634e487b7160e01b600052604160045260246000fd5b60005b8381101561035257818101518382015260200161033a565b50506000910152565b60008060006060848603121561037057600080fd5b61037984610305565b925061038760208501610305565b60408501519092506001600160401b03808211156103a457600080fd5b818601915086601f8301126103b857600080fd5b8151818111156103ca576103ca610321565b604051601f8201601f19908116603f011681019083821181831017156103f2576103f2610321565b8160405282815289602084870101111561040b57600080fd5b61041c836020830160208801610337565b80955050505050509250925092565b6000825161043d818460208701610337565b9190910192915050565b608051610473620004626000396000601001526104736000f3fe608060405261000c61000e565b005b7f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316330361006a576000356001600160e01b03191663278f794360e11b146100625761006061006e565b565b61006061007e565b6100605b6100606100796100ad565b6100d3565b60008061008e36600481846102cb565b81019061009b919061030b565b915091506100a982826100f7565b5050565b60006100ce60008051602061041e833981519152546001600160a01b031690565b905090565b3660008037600080366000845af43d6000803e8080156100f2573d6000f35b3d6000fd5b61010082610152565b6040516001600160a01b038316907fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b90600090a280511561014a5761014582826101b7565b505050565b6100a961022d565b806001600160a01b03163b6000036101885780604051634c9c8ce360e01b815260040161017f91906103da565b60405180910390fd5b60008051602061041e83398151915280546001600160a01b0319166001600160a01b0392909216919091179055565b6060600080846001600160a01b0316846040516101d491906103ee565b600060405180830381855af49150503d806000811461020f576040519150601f19603f3d011682016040523d82523d6000602084013e610214565b606091505b509150915061022485838361024c565b95945050505050565b34156100605760405163b398979f60e01b815260040160405180910390fd5b6060826102615761025c826102a2565b61029b565b815115801561027857506001600160a01b0384163b155b156102985783604051639996b31560e01b815260040161017f91906103da565b50805b9392505050565b8051156102b25780518082602001fd5b604051630a12f52160e11b815260040160405180910390fd5b600080858511156102db57600080fd5b838611156102e857600080fd5b5050820193919092039150565b634e487b7160e01b600052604160045260246000fd5b6000806040838503121561031e57600080fd5b82356001600160a01b038116811461033557600080fd5b915060208301356001600160401b038082111561035157600080fd5b818501915085601f83011261036557600080fd5b813581811115610377576103776102f5565b604051601f8201601f19908116603f0116810190838211818310171561039f5761039f6102f5565b816040528281528860208487010111156103b857600080fd5b8260208601602083013760006020848301015280955050505050509250929050565b6001600160a01b0391909116815260200190565b6000825160005b8181101561040f57602081860181015185830152016103f5565b50600092019182525091905056fe360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbca2646970667358221220a19e7a72432195d9a35c7ce8fa5f1284415aac66bb1ad08a4c2e1c252fd8690864736f6c63430008140033b53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d610373cb0569fdbea2544dae03fdb2fe10eda92a72a2e8cd2bd496e85b762505a3f066156603fe29d13f97c6f3e3dff4ef71919f9aa61c555be0182d954e94221aac8cf807f6970720f8e2c208c7c5037595982c7bd9ed93c380d09df743d0dcc3fbab66e11c4f712cd06ab11bf9339b48bef39e12d4a22eeef71d2860a0c90482bdac75d24dbb35ea80e25fab167da4dea46c1915260426570db84f184891f5f59062ba6ba2ffed8cfe316b583325ea41ac6e7ba9e5864d2bc6fabba7ac26d2f0f430644e72e131a029b85045b68181585d2833e84879b9709143e1f593f00000017f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb38474024983dfe277d2a2c04b75fb2eb3743fa00005ae3678a20c299e65fdf4df76517f68ea5c5790f581d443ed43873ab47cfb8c5d66a6db268e58b5971bb33fc66e07db19b6f082d8d3644ae2f24a3c32e356d6f2d9b2844d9b26164fbc82663ff285951141f8f32ce6198eee741f695cec728bfd32d289f1acf73621fb303581000545ea0fab074aba36a6fa69f1a83ee86e5abfb8433966eb57efb13dc2fc2f24ddd08084e94f375e9d647f87f5b2ceffba1e062c70f6009fdbcf80291e803b5c9edd4a26469706673582212203f12260f62b0d87f840f477a6be35cf07e8ec905f8d0f0ce1838a89a9200b2cd64736f6c63430008140033", +} + +// MockpolygonrollupmanagerABI is the input ABI used to generate the binding from. +// Deprecated: Use MockpolygonrollupmanagerMetaData.ABI instead. +var MockpolygonrollupmanagerABI = MockpolygonrollupmanagerMetaData.ABI + +// MockpolygonrollupmanagerBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use MockpolygonrollupmanagerMetaData.Bin instead. +var MockpolygonrollupmanagerBin = MockpolygonrollupmanagerMetaData.Bin + +// DeployMockpolygonrollupmanager deploys a new Ethereum contract, binding an instance of Mockpolygonrollupmanager to it. +func DeployMockpolygonrollupmanager(auth *bind.TransactOpts, backend bind.ContractBackend, _globalExitRootManager common.Address, _pol common.Address, _bridgeAddress common.Address) (common.Address, *types.Transaction, *Mockpolygonrollupmanager, error) { + parsed, err := MockpolygonrollupmanagerMetaData.GetAbi() + if err != nil { + return common.Address{}, nil, nil, err + } + if parsed == nil { + return common.Address{}, nil, nil, errors.New("GetABI returned nil") + } + + address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex(MockpolygonrollupmanagerBin), backend, _globalExitRootManager, _pol, _bridgeAddress) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &Mockpolygonrollupmanager{MockpolygonrollupmanagerCaller: MockpolygonrollupmanagerCaller{contract: contract}, MockpolygonrollupmanagerTransactor: MockpolygonrollupmanagerTransactor{contract: contract}, MockpolygonrollupmanagerFilterer: MockpolygonrollupmanagerFilterer{contract: contract}}, nil +} + +// Mockpolygonrollupmanager is an auto generated Go binding around an Ethereum contract. +type Mockpolygonrollupmanager struct { + MockpolygonrollupmanagerCaller // Read-only binding to the contract + MockpolygonrollupmanagerTransactor // Write-only binding to the contract + MockpolygonrollupmanagerFilterer // Log filterer for contract events +} + +// MockpolygonrollupmanagerCaller is an auto generated read-only Go binding around an Ethereum contract. +type MockpolygonrollupmanagerCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// MockpolygonrollupmanagerTransactor is an auto generated write-only Go binding around an Ethereum contract. +type MockpolygonrollupmanagerTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// MockpolygonrollupmanagerFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type MockpolygonrollupmanagerFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// MockpolygonrollupmanagerSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type MockpolygonrollupmanagerSession struct { + Contract *Mockpolygonrollupmanager // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// MockpolygonrollupmanagerCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type MockpolygonrollupmanagerCallerSession struct { + Contract *MockpolygonrollupmanagerCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// MockpolygonrollupmanagerTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type MockpolygonrollupmanagerTransactorSession struct { + Contract *MockpolygonrollupmanagerTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// MockpolygonrollupmanagerRaw is an auto generated low-level Go binding around an Ethereum contract. +type MockpolygonrollupmanagerRaw struct { + Contract *Mockpolygonrollupmanager // Generic contract binding to access the raw methods on +} + +// MockpolygonrollupmanagerCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type MockpolygonrollupmanagerCallerRaw struct { + Contract *MockpolygonrollupmanagerCaller // Generic read-only contract binding to access the raw methods on +} + +// MockpolygonrollupmanagerTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type MockpolygonrollupmanagerTransactorRaw struct { + Contract *MockpolygonrollupmanagerTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewMockpolygonrollupmanager creates a new instance of Mockpolygonrollupmanager, bound to a specific deployed contract. +func NewMockpolygonrollupmanager(address common.Address, backend bind.ContractBackend) (*Mockpolygonrollupmanager, error) { + contract, err := bindMockpolygonrollupmanager(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &Mockpolygonrollupmanager{MockpolygonrollupmanagerCaller: MockpolygonrollupmanagerCaller{contract: contract}, MockpolygonrollupmanagerTransactor: MockpolygonrollupmanagerTransactor{contract: contract}, MockpolygonrollupmanagerFilterer: MockpolygonrollupmanagerFilterer{contract: contract}}, nil +} + +// NewMockpolygonrollupmanagerCaller creates a new read-only instance of Mockpolygonrollupmanager, bound to a specific deployed contract. +func NewMockpolygonrollupmanagerCaller(address common.Address, caller bind.ContractCaller) (*MockpolygonrollupmanagerCaller, error) { + contract, err := bindMockpolygonrollupmanager(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &MockpolygonrollupmanagerCaller{contract: contract}, nil +} + +// NewMockpolygonrollupmanagerTransactor creates a new write-only instance of Mockpolygonrollupmanager, bound to a specific deployed contract. +func NewMockpolygonrollupmanagerTransactor(address common.Address, transactor bind.ContractTransactor) (*MockpolygonrollupmanagerTransactor, error) { + contract, err := bindMockpolygonrollupmanager(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &MockpolygonrollupmanagerTransactor{contract: contract}, nil +} + +// NewMockpolygonrollupmanagerFilterer creates a new log filterer instance of Mockpolygonrollupmanager, bound to a specific deployed contract. +func NewMockpolygonrollupmanagerFilterer(address common.Address, filterer bind.ContractFilterer) (*MockpolygonrollupmanagerFilterer, error) { + contract, err := bindMockpolygonrollupmanager(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &MockpolygonrollupmanagerFilterer{contract: contract}, nil +} + +// bindMockpolygonrollupmanager binds a generic wrapper to an already deployed contract. +func bindMockpolygonrollupmanager(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := MockpolygonrollupmanagerMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Mockpolygonrollupmanager.Contract.MockpolygonrollupmanagerCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.Contract.MockpolygonrollupmanagerTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.Contract.MockpolygonrollupmanagerTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Mockpolygonrollupmanager.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.Contract.contract.Transact(opts, method, params...) +} + +// DEFAULTADMINROLE is a free data retrieval call binding the contract method 0xa217fddf. +// +// Solidity: function DEFAULT_ADMIN_ROLE() view returns(bytes32) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCaller) DEFAULTADMINROLE(opts *bind.CallOpts) ([32]byte, error) { + var out []interface{} + err := _Mockpolygonrollupmanager.contract.Call(opts, &out, "DEFAULT_ADMIN_ROLE") + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// DEFAULTADMINROLE is a free data retrieval call binding the contract method 0xa217fddf. +// +// Solidity: function DEFAULT_ADMIN_ROLE() view returns(bytes32) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) DEFAULTADMINROLE() ([32]byte, error) { + return _Mockpolygonrollupmanager.Contract.DEFAULTADMINROLE(&_Mockpolygonrollupmanager.CallOpts) +} + +// DEFAULTADMINROLE is a free data retrieval call binding the contract method 0xa217fddf. +// +// Solidity: function DEFAULT_ADMIN_ROLE() view returns(bytes32) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCallerSession) DEFAULTADMINROLE() ([32]byte, error) { + return _Mockpolygonrollupmanager.Contract.DEFAULTADMINROLE(&_Mockpolygonrollupmanager.CallOpts) +} + +// BridgeAddress is a free data retrieval call binding the contract method 0xa3c573eb. +// +// Solidity: function bridgeAddress() view returns(address) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCaller) BridgeAddress(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Mockpolygonrollupmanager.contract.Call(opts, &out, "bridgeAddress") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// BridgeAddress is a free data retrieval call binding the contract method 0xa3c573eb. +// +// Solidity: function bridgeAddress() view returns(address) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) BridgeAddress() (common.Address, error) { + return _Mockpolygonrollupmanager.Contract.BridgeAddress(&_Mockpolygonrollupmanager.CallOpts) +} + +// BridgeAddress is a free data retrieval call binding the contract method 0xa3c573eb. +// +// Solidity: function bridgeAddress() view returns(address) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCallerSession) BridgeAddress() (common.Address, error) { + return _Mockpolygonrollupmanager.Contract.BridgeAddress(&_Mockpolygonrollupmanager.CallOpts) +} + +// CalculateRewardPerBatch is a free data retrieval call binding the contract method 0x99f5634e. +// +// Solidity: function calculateRewardPerBatch() view returns(uint256) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCaller) CalculateRewardPerBatch(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _Mockpolygonrollupmanager.contract.Call(opts, &out, "calculateRewardPerBatch") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// CalculateRewardPerBatch is a free data retrieval call binding the contract method 0x99f5634e. +// +// Solidity: function calculateRewardPerBatch() view returns(uint256) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) CalculateRewardPerBatch() (*big.Int, error) { + return _Mockpolygonrollupmanager.Contract.CalculateRewardPerBatch(&_Mockpolygonrollupmanager.CallOpts) +} + +// CalculateRewardPerBatch is a free data retrieval call binding the contract method 0x99f5634e. +// +// Solidity: function calculateRewardPerBatch() view returns(uint256) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCallerSession) CalculateRewardPerBatch() (*big.Int, error) { + return _Mockpolygonrollupmanager.Contract.CalculateRewardPerBatch(&_Mockpolygonrollupmanager.CallOpts) +} + +// ChainIDToRollupID is a free data retrieval call binding the contract method 0x7fb6e76a. +// +// Solidity: function chainIDToRollupID(uint64 chainID) view returns(uint32 rollupID) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCaller) ChainIDToRollupID(opts *bind.CallOpts, chainID uint64) (uint32, error) { + var out []interface{} + err := _Mockpolygonrollupmanager.contract.Call(opts, &out, "chainIDToRollupID", chainID) + + if err != nil { + return *new(uint32), err + } + + out0 := *abi.ConvertType(out[0], new(uint32)).(*uint32) + + return out0, err + +} + +// ChainIDToRollupID is a free data retrieval call binding the contract method 0x7fb6e76a. +// +// Solidity: function chainIDToRollupID(uint64 chainID) view returns(uint32 rollupID) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) ChainIDToRollupID(chainID uint64) (uint32, error) { + return _Mockpolygonrollupmanager.Contract.ChainIDToRollupID(&_Mockpolygonrollupmanager.CallOpts, chainID) +} + +// ChainIDToRollupID is a free data retrieval call binding the contract method 0x7fb6e76a. +// +// Solidity: function chainIDToRollupID(uint64 chainID) view returns(uint32 rollupID) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCallerSession) ChainIDToRollupID(chainID uint64) (uint32, error) { + return _Mockpolygonrollupmanager.Contract.ChainIDToRollupID(&_Mockpolygonrollupmanager.CallOpts, chainID) +} + +// GetBatchFee is a free data retrieval call binding the contract method 0x477fa270. +// +// Solidity: function getBatchFee() view returns(uint256) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCaller) GetBatchFee(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _Mockpolygonrollupmanager.contract.Call(opts, &out, "getBatchFee") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// GetBatchFee is a free data retrieval call binding the contract method 0x477fa270. +// +// Solidity: function getBatchFee() view returns(uint256) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) GetBatchFee() (*big.Int, error) { + return _Mockpolygonrollupmanager.Contract.GetBatchFee(&_Mockpolygonrollupmanager.CallOpts) +} + +// GetBatchFee is a free data retrieval call binding the contract method 0x477fa270. +// +// Solidity: function getBatchFee() view returns(uint256) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCallerSession) GetBatchFee() (*big.Int, error) { + return _Mockpolygonrollupmanager.Contract.GetBatchFee(&_Mockpolygonrollupmanager.CallOpts) +} + +// GetForcedBatchFee is a free data retrieval call binding the contract method 0x60469169. +// +// Solidity: function getForcedBatchFee() view returns(uint256) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCaller) GetForcedBatchFee(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _Mockpolygonrollupmanager.contract.Call(opts, &out, "getForcedBatchFee") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// GetForcedBatchFee is a free data retrieval call binding the contract method 0x60469169. +// +// Solidity: function getForcedBatchFee() view returns(uint256) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) GetForcedBatchFee() (*big.Int, error) { + return _Mockpolygonrollupmanager.Contract.GetForcedBatchFee(&_Mockpolygonrollupmanager.CallOpts) +} + +// GetForcedBatchFee is a free data retrieval call binding the contract method 0x60469169. +// +// Solidity: function getForcedBatchFee() view returns(uint256) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCallerSession) GetForcedBatchFee() (*big.Int, error) { + return _Mockpolygonrollupmanager.Contract.GetForcedBatchFee(&_Mockpolygonrollupmanager.CallOpts) +} + +// GetInputSnarkBytes is a free data retrieval call binding the contract method 0x7975fcfe. +// +// Solidity: function getInputSnarkBytes(uint32 rollupID, uint64 initNumBatch, uint64 finalNewBatch, bytes32 newLocalExitRoot, bytes32 oldStateRoot, bytes32 newStateRoot) view returns(bytes) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCaller) GetInputSnarkBytes(opts *bind.CallOpts, rollupID uint32, initNumBatch uint64, finalNewBatch uint64, newLocalExitRoot [32]byte, oldStateRoot [32]byte, newStateRoot [32]byte) ([]byte, error) { + var out []interface{} + err := _Mockpolygonrollupmanager.contract.Call(opts, &out, "getInputSnarkBytes", rollupID, initNumBatch, finalNewBatch, newLocalExitRoot, oldStateRoot, newStateRoot) + + if err != nil { + return *new([]byte), err + } + + out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte) + + return out0, err + +} + +// GetInputSnarkBytes is a free data retrieval call binding the contract method 0x7975fcfe. +// +// Solidity: function getInputSnarkBytes(uint32 rollupID, uint64 initNumBatch, uint64 finalNewBatch, bytes32 newLocalExitRoot, bytes32 oldStateRoot, bytes32 newStateRoot) view returns(bytes) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) GetInputSnarkBytes(rollupID uint32, initNumBatch uint64, finalNewBatch uint64, newLocalExitRoot [32]byte, oldStateRoot [32]byte, newStateRoot [32]byte) ([]byte, error) { + return _Mockpolygonrollupmanager.Contract.GetInputSnarkBytes(&_Mockpolygonrollupmanager.CallOpts, rollupID, initNumBatch, finalNewBatch, newLocalExitRoot, oldStateRoot, newStateRoot) +} + +// GetInputSnarkBytes is a free data retrieval call binding the contract method 0x7975fcfe. +// +// Solidity: function getInputSnarkBytes(uint32 rollupID, uint64 initNumBatch, uint64 finalNewBatch, bytes32 newLocalExitRoot, bytes32 oldStateRoot, bytes32 newStateRoot) view returns(bytes) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCallerSession) GetInputSnarkBytes(rollupID uint32, initNumBatch uint64, finalNewBatch uint64, newLocalExitRoot [32]byte, oldStateRoot [32]byte, newStateRoot [32]byte) ([]byte, error) { + return _Mockpolygonrollupmanager.Contract.GetInputSnarkBytes(&_Mockpolygonrollupmanager.CallOpts, rollupID, initNumBatch, finalNewBatch, newLocalExitRoot, oldStateRoot, newStateRoot) +} + +// GetLastVerifiedBatch is a free data retrieval call binding the contract method 0x11f6b287. +// +// Solidity: function getLastVerifiedBatch(uint32 rollupID) view returns(uint64) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCaller) GetLastVerifiedBatch(opts *bind.CallOpts, rollupID uint32) (uint64, error) { + var out []interface{} + err := _Mockpolygonrollupmanager.contract.Call(opts, &out, "getLastVerifiedBatch", rollupID) + + if err != nil { + return *new(uint64), err + } + + out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64) + + return out0, err + +} + +// GetLastVerifiedBatch is a free data retrieval call binding the contract method 0x11f6b287. +// +// Solidity: function getLastVerifiedBatch(uint32 rollupID) view returns(uint64) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) GetLastVerifiedBatch(rollupID uint32) (uint64, error) { + return _Mockpolygonrollupmanager.Contract.GetLastVerifiedBatch(&_Mockpolygonrollupmanager.CallOpts, rollupID) +} + +// GetLastVerifiedBatch is a free data retrieval call binding the contract method 0x11f6b287. +// +// Solidity: function getLastVerifiedBatch(uint32 rollupID) view returns(uint64) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCallerSession) GetLastVerifiedBatch(rollupID uint32) (uint64, error) { + return _Mockpolygonrollupmanager.Contract.GetLastVerifiedBatch(&_Mockpolygonrollupmanager.CallOpts, rollupID) +} + +// GetRoleAdmin is a free data retrieval call binding the contract method 0x248a9ca3. +// +// Solidity: function getRoleAdmin(bytes32 role) view returns(bytes32) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCaller) GetRoleAdmin(opts *bind.CallOpts, role [32]byte) ([32]byte, error) { + var out []interface{} + err := _Mockpolygonrollupmanager.contract.Call(opts, &out, "getRoleAdmin", role) + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// GetRoleAdmin is a free data retrieval call binding the contract method 0x248a9ca3. +// +// Solidity: function getRoleAdmin(bytes32 role) view returns(bytes32) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) GetRoleAdmin(role [32]byte) ([32]byte, error) { + return _Mockpolygonrollupmanager.Contract.GetRoleAdmin(&_Mockpolygonrollupmanager.CallOpts, role) +} + +// GetRoleAdmin is a free data retrieval call binding the contract method 0x248a9ca3. +// +// Solidity: function getRoleAdmin(bytes32 role) view returns(bytes32) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCallerSession) GetRoleAdmin(role [32]byte) ([32]byte, error) { + return _Mockpolygonrollupmanager.Contract.GetRoleAdmin(&_Mockpolygonrollupmanager.CallOpts, role) +} + +// GetRollupBatchNumToStateRoot is a free data retrieval call binding the contract method 0x55a71ee0. +// +// Solidity: function getRollupBatchNumToStateRoot(uint32 rollupID, uint64 batchNum) view returns(bytes32) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCaller) GetRollupBatchNumToStateRoot(opts *bind.CallOpts, rollupID uint32, batchNum uint64) ([32]byte, error) { + var out []interface{} + err := _Mockpolygonrollupmanager.contract.Call(opts, &out, "getRollupBatchNumToStateRoot", rollupID, batchNum) + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// GetRollupBatchNumToStateRoot is a free data retrieval call binding the contract method 0x55a71ee0. +// +// Solidity: function getRollupBatchNumToStateRoot(uint32 rollupID, uint64 batchNum) view returns(bytes32) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) GetRollupBatchNumToStateRoot(rollupID uint32, batchNum uint64) ([32]byte, error) { + return _Mockpolygonrollupmanager.Contract.GetRollupBatchNumToStateRoot(&_Mockpolygonrollupmanager.CallOpts, rollupID, batchNum) +} + +// GetRollupBatchNumToStateRoot is a free data retrieval call binding the contract method 0x55a71ee0. +// +// Solidity: function getRollupBatchNumToStateRoot(uint32 rollupID, uint64 batchNum) view returns(bytes32) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCallerSession) GetRollupBatchNumToStateRoot(rollupID uint32, batchNum uint64) ([32]byte, error) { + return _Mockpolygonrollupmanager.Contract.GetRollupBatchNumToStateRoot(&_Mockpolygonrollupmanager.CallOpts, rollupID, batchNum) +} + +// GetRollupExitRoot is a free data retrieval call binding the contract method 0xa2967d99. +// +// Solidity: function getRollupExitRoot() view returns(bytes32) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCaller) GetRollupExitRoot(opts *bind.CallOpts) ([32]byte, error) { + var out []interface{} + err := _Mockpolygonrollupmanager.contract.Call(opts, &out, "getRollupExitRoot") + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// GetRollupExitRoot is a free data retrieval call binding the contract method 0xa2967d99. +// +// Solidity: function getRollupExitRoot() view returns(bytes32) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) GetRollupExitRoot() ([32]byte, error) { + return _Mockpolygonrollupmanager.Contract.GetRollupExitRoot(&_Mockpolygonrollupmanager.CallOpts) +} + +// GetRollupExitRoot is a free data retrieval call binding the contract method 0xa2967d99. +// +// Solidity: function getRollupExitRoot() view returns(bytes32) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCallerSession) GetRollupExitRoot() ([32]byte, error) { + return _Mockpolygonrollupmanager.Contract.GetRollupExitRoot(&_Mockpolygonrollupmanager.CallOpts) +} + +// GetRollupPendingStateTransitions is a free data retrieval call binding the contract method 0xb99d0ad7. +// +// Solidity: function getRollupPendingStateTransitions(uint32 rollupID, uint64 batchNum) view returns((uint64,uint64,bytes32,bytes32)) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCaller) GetRollupPendingStateTransitions(opts *bind.CallOpts, rollupID uint32, batchNum uint64) (LegacyZKEVMStateVariablesPendingState, error) { + var out []interface{} + err := _Mockpolygonrollupmanager.contract.Call(opts, &out, "getRollupPendingStateTransitions", rollupID, batchNum) + + if err != nil { + return *new(LegacyZKEVMStateVariablesPendingState), err + } + + out0 := *abi.ConvertType(out[0], new(LegacyZKEVMStateVariablesPendingState)).(*LegacyZKEVMStateVariablesPendingState) + + return out0, err + +} + +// GetRollupPendingStateTransitions is a free data retrieval call binding the contract method 0xb99d0ad7. +// +// Solidity: function getRollupPendingStateTransitions(uint32 rollupID, uint64 batchNum) view returns((uint64,uint64,bytes32,bytes32)) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) GetRollupPendingStateTransitions(rollupID uint32, batchNum uint64) (LegacyZKEVMStateVariablesPendingState, error) { + return _Mockpolygonrollupmanager.Contract.GetRollupPendingStateTransitions(&_Mockpolygonrollupmanager.CallOpts, rollupID, batchNum) +} + +// GetRollupPendingStateTransitions is a free data retrieval call binding the contract method 0xb99d0ad7. +// +// Solidity: function getRollupPendingStateTransitions(uint32 rollupID, uint64 batchNum) view returns((uint64,uint64,bytes32,bytes32)) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCallerSession) GetRollupPendingStateTransitions(rollupID uint32, batchNum uint64) (LegacyZKEVMStateVariablesPendingState, error) { + return _Mockpolygonrollupmanager.Contract.GetRollupPendingStateTransitions(&_Mockpolygonrollupmanager.CallOpts, rollupID, batchNum) +} + +// GetRollupSequencedBatches is a free data retrieval call binding the contract method 0x25280169. +// +// Solidity: function getRollupSequencedBatches(uint32 rollupID, uint64 batchNum) view returns((bytes32,uint64,uint64)) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCaller) GetRollupSequencedBatches(opts *bind.CallOpts, rollupID uint32, batchNum uint64) (LegacyZKEVMStateVariablesSequencedBatchData, error) { + var out []interface{} + err := _Mockpolygonrollupmanager.contract.Call(opts, &out, "getRollupSequencedBatches", rollupID, batchNum) + + if err != nil { + return *new(LegacyZKEVMStateVariablesSequencedBatchData), err + } + + out0 := *abi.ConvertType(out[0], new(LegacyZKEVMStateVariablesSequencedBatchData)).(*LegacyZKEVMStateVariablesSequencedBatchData) + + return out0, err + +} + +// GetRollupSequencedBatches is a free data retrieval call binding the contract method 0x25280169. +// +// Solidity: function getRollupSequencedBatches(uint32 rollupID, uint64 batchNum) view returns((bytes32,uint64,uint64)) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) GetRollupSequencedBatches(rollupID uint32, batchNum uint64) (LegacyZKEVMStateVariablesSequencedBatchData, error) { + return _Mockpolygonrollupmanager.Contract.GetRollupSequencedBatches(&_Mockpolygonrollupmanager.CallOpts, rollupID, batchNum) +} + +// GetRollupSequencedBatches is a free data retrieval call binding the contract method 0x25280169. +// +// Solidity: function getRollupSequencedBatches(uint32 rollupID, uint64 batchNum) view returns((bytes32,uint64,uint64)) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCallerSession) GetRollupSequencedBatches(rollupID uint32, batchNum uint64) (LegacyZKEVMStateVariablesSequencedBatchData, error) { + return _Mockpolygonrollupmanager.Contract.GetRollupSequencedBatches(&_Mockpolygonrollupmanager.CallOpts, rollupID, batchNum) +} + +// GlobalExitRootManager is a free data retrieval call binding the contract method 0xd02103ca. +// +// Solidity: function globalExitRootManager() view returns(address) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCaller) GlobalExitRootManager(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Mockpolygonrollupmanager.contract.Call(opts, &out, "globalExitRootManager") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// GlobalExitRootManager is a free data retrieval call binding the contract method 0xd02103ca. +// +// Solidity: function globalExitRootManager() view returns(address) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) GlobalExitRootManager() (common.Address, error) { + return _Mockpolygonrollupmanager.Contract.GlobalExitRootManager(&_Mockpolygonrollupmanager.CallOpts) +} + +// GlobalExitRootManager is a free data retrieval call binding the contract method 0xd02103ca. +// +// Solidity: function globalExitRootManager() view returns(address) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCallerSession) GlobalExitRootManager() (common.Address, error) { + return _Mockpolygonrollupmanager.Contract.GlobalExitRootManager(&_Mockpolygonrollupmanager.CallOpts) +} + +// HasRole is a free data retrieval call binding the contract method 0x91d14854. +// +// Solidity: function hasRole(bytes32 role, address account) view returns(bool) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCaller) HasRole(opts *bind.CallOpts, role [32]byte, account common.Address) (bool, error) { + var out []interface{} + err := _Mockpolygonrollupmanager.contract.Call(opts, &out, "hasRole", role, account) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// HasRole is a free data retrieval call binding the contract method 0x91d14854. +// +// Solidity: function hasRole(bytes32 role, address account) view returns(bool) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) HasRole(role [32]byte, account common.Address) (bool, error) { + return _Mockpolygonrollupmanager.Contract.HasRole(&_Mockpolygonrollupmanager.CallOpts, role, account) +} + +// HasRole is a free data retrieval call binding the contract method 0x91d14854. +// +// Solidity: function hasRole(bytes32 role, address account) view returns(bool) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCallerSession) HasRole(role [32]byte, account common.Address) (bool, error) { + return _Mockpolygonrollupmanager.Contract.HasRole(&_Mockpolygonrollupmanager.CallOpts, role, account) +} + +// IsEmergencyState is a free data retrieval call binding the contract method 0x15064c96. +// +// Solidity: function isEmergencyState() view returns(bool) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCaller) IsEmergencyState(opts *bind.CallOpts) (bool, error) { + var out []interface{} + err := _Mockpolygonrollupmanager.contract.Call(opts, &out, "isEmergencyState") + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// IsEmergencyState is a free data retrieval call binding the contract method 0x15064c96. +// +// Solidity: function isEmergencyState() view returns(bool) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) IsEmergencyState() (bool, error) { + return _Mockpolygonrollupmanager.Contract.IsEmergencyState(&_Mockpolygonrollupmanager.CallOpts) +} + +// IsEmergencyState is a free data retrieval call binding the contract method 0x15064c96. +// +// Solidity: function isEmergencyState() view returns(bool) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCallerSession) IsEmergencyState() (bool, error) { + return _Mockpolygonrollupmanager.Contract.IsEmergencyState(&_Mockpolygonrollupmanager.CallOpts) +} + +// IsPendingStateConsolidable is a free data retrieval call binding the contract method 0x080b3111. +// +// Solidity: function isPendingStateConsolidable(uint32 rollupID, uint64 pendingStateNum) view returns(bool) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCaller) IsPendingStateConsolidable(opts *bind.CallOpts, rollupID uint32, pendingStateNum uint64) (bool, error) { + var out []interface{} + err := _Mockpolygonrollupmanager.contract.Call(opts, &out, "isPendingStateConsolidable", rollupID, pendingStateNum) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// IsPendingStateConsolidable is a free data retrieval call binding the contract method 0x080b3111. +// +// Solidity: function isPendingStateConsolidable(uint32 rollupID, uint64 pendingStateNum) view returns(bool) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) IsPendingStateConsolidable(rollupID uint32, pendingStateNum uint64) (bool, error) { + return _Mockpolygonrollupmanager.Contract.IsPendingStateConsolidable(&_Mockpolygonrollupmanager.CallOpts, rollupID, pendingStateNum) +} + +// IsPendingStateConsolidable is a free data retrieval call binding the contract method 0x080b3111. +// +// Solidity: function isPendingStateConsolidable(uint32 rollupID, uint64 pendingStateNum) view returns(bool) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCallerSession) IsPendingStateConsolidable(rollupID uint32, pendingStateNum uint64) (bool, error) { + return _Mockpolygonrollupmanager.Contract.IsPendingStateConsolidable(&_Mockpolygonrollupmanager.CallOpts, rollupID, pendingStateNum) +} + +// LastAggregationTimestamp is a free data retrieval call binding the contract method 0xc1acbc34. +// +// Solidity: function lastAggregationTimestamp() view returns(uint64) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCaller) LastAggregationTimestamp(opts *bind.CallOpts) (uint64, error) { + var out []interface{} + err := _Mockpolygonrollupmanager.contract.Call(opts, &out, "lastAggregationTimestamp") + + if err != nil { + return *new(uint64), err + } + + out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64) + + return out0, err + +} + +// LastAggregationTimestamp is a free data retrieval call binding the contract method 0xc1acbc34. +// +// Solidity: function lastAggregationTimestamp() view returns(uint64) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) LastAggregationTimestamp() (uint64, error) { + return _Mockpolygonrollupmanager.Contract.LastAggregationTimestamp(&_Mockpolygonrollupmanager.CallOpts) +} + +// LastAggregationTimestamp is a free data retrieval call binding the contract method 0xc1acbc34. +// +// Solidity: function lastAggregationTimestamp() view returns(uint64) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCallerSession) LastAggregationTimestamp() (uint64, error) { + return _Mockpolygonrollupmanager.Contract.LastAggregationTimestamp(&_Mockpolygonrollupmanager.CallOpts) +} + +// MultiplierBatchFee is a free data retrieval call binding the contract method 0xafd23cbe. +// +// Solidity: function multiplierBatchFee() view returns(uint16) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCaller) MultiplierBatchFee(opts *bind.CallOpts) (uint16, error) { + var out []interface{} + err := _Mockpolygonrollupmanager.contract.Call(opts, &out, "multiplierBatchFee") + + if err != nil { + return *new(uint16), err + } + + out0 := *abi.ConvertType(out[0], new(uint16)).(*uint16) + + return out0, err + +} + +// MultiplierBatchFee is a free data retrieval call binding the contract method 0xafd23cbe. +// +// Solidity: function multiplierBatchFee() view returns(uint16) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) MultiplierBatchFee() (uint16, error) { + return _Mockpolygonrollupmanager.Contract.MultiplierBatchFee(&_Mockpolygonrollupmanager.CallOpts) +} + +// MultiplierBatchFee is a free data retrieval call binding the contract method 0xafd23cbe. +// +// Solidity: function multiplierBatchFee() view returns(uint16) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCallerSession) MultiplierBatchFee() (uint16, error) { + return _Mockpolygonrollupmanager.Contract.MultiplierBatchFee(&_Mockpolygonrollupmanager.CallOpts) +} + +// PendingStateTimeout is a free data retrieval call binding the contract method 0xd939b315. +// +// Solidity: function pendingStateTimeout() view returns(uint64) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCaller) PendingStateTimeout(opts *bind.CallOpts) (uint64, error) { + var out []interface{} + err := _Mockpolygonrollupmanager.contract.Call(opts, &out, "pendingStateTimeout") + + if err != nil { + return *new(uint64), err + } + + out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64) + + return out0, err + +} + +// PendingStateTimeout is a free data retrieval call binding the contract method 0xd939b315. +// +// Solidity: function pendingStateTimeout() view returns(uint64) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) PendingStateTimeout() (uint64, error) { + return _Mockpolygonrollupmanager.Contract.PendingStateTimeout(&_Mockpolygonrollupmanager.CallOpts) +} + +// PendingStateTimeout is a free data retrieval call binding the contract method 0xd939b315. +// +// Solidity: function pendingStateTimeout() view returns(uint64) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCallerSession) PendingStateTimeout() (uint64, error) { + return _Mockpolygonrollupmanager.Contract.PendingStateTimeout(&_Mockpolygonrollupmanager.CallOpts) +} + +// Pol is a free data retrieval call binding the contract method 0xe46761c4. +// +// Solidity: function pol() view returns(address) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCaller) Pol(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Mockpolygonrollupmanager.contract.Call(opts, &out, "pol") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// Pol is a free data retrieval call binding the contract method 0xe46761c4. +// +// Solidity: function pol() view returns(address) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) Pol() (common.Address, error) { + return _Mockpolygonrollupmanager.Contract.Pol(&_Mockpolygonrollupmanager.CallOpts) +} + +// Pol is a free data retrieval call binding the contract method 0xe46761c4. +// +// Solidity: function pol() view returns(address) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCallerSession) Pol() (common.Address, error) { + return _Mockpolygonrollupmanager.Contract.Pol(&_Mockpolygonrollupmanager.CallOpts) +} + +// RollupAddressToID is a free data retrieval call binding the contract method 0xceee281d. +// +// Solidity: function rollupAddressToID(address rollupAddress) view returns(uint32 rollupID) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCaller) RollupAddressToID(opts *bind.CallOpts, rollupAddress common.Address) (uint32, error) { + var out []interface{} + err := _Mockpolygonrollupmanager.contract.Call(opts, &out, "rollupAddressToID", rollupAddress) + + if err != nil { + return *new(uint32), err + } + + out0 := *abi.ConvertType(out[0], new(uint32)).(*uint32) + + return out0, err + +} + +// RollupAddressToID is a free data retrieval call binding the contract method 0xceee281d. +// +// Solidity: function rollupAddressToID(address rollupAddress) view returns(uint32 rollupID) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) RollupAddressToID(rollupAddress common.Address) (uint32, error) { + return _Mockpolygonrollupmanager.Contract.RollupAddressToID(&_Mockpolygonrollupmanager.CallOpts, rollupAddress) +} + +// RollupAddressToID is a free data retrieval call binding the contract method 0xceee281d. +// +// Solidity: function rollupAddressToID(address rollupAddress) view returns(uint32 rollupID) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCallerSession) RollupAddressToID(rollupAddress common.Address) (uint32, error) { + return _Mockpolygonrollupmanager.Contract.RollupAddressToID(&_Mockpolygonrollupmanager.CallOpts, rollupAddress) +} + +// RollupCount is a free data retrieval call binding the contract method 0xf4e92675. +// +// Solidity: function rollupCount() view returns(uint32) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCaller) RollupCount(opts *bind.CallOpts) (uint32, error) { + var out []interface{} + err := _Mockpolygonrollupmanager.contract.Call(opts, &out, "rollupCount") + + if err != nil { + return *new(uint32), err + } + + out0 := *abi.ConvertType(out[0], new(uint32)).(*uint32) + + return out0, err + +} + +// RollupCount is a free data retrieval call binding the contract method 0xf4e92675. +// +// Solidity: function rollupCount() view returns(uint32) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) RollupCount() (uint32, error) { + return _Mockpolygonrollupmanager.Contract.RollupCount(&_Mockpolygonrollupmanager.CallOpts) +} + +// RollupCount is a free data retrieval call binding the contract method 0xf4e92675. +// +// Solidity: function rollupCount() view returns(uint32) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCallerSession) RollupCount() (uint32, error) { + return _Mockpolygonrollupmanager.Contract.RollupCount(&_Mockpolygonrollupmanager.CallOpts) +} + +// RollupIDToRollupData is a free data retrieval call binding the contract method 0xf9c4c2ae. +// +// Solidity: function rollupIDToRollupData(uint32 rollupID) view returns(address rollupContract, uint64 chainID, address verifier, uint64 forkID, bytes32 lastLocalExitRoot, uint64 lastBatchSequenced, uint64 lastVerifiedBatch, uint64 lastPendingState, uint64 lastPendingStateConsolidated, uint64 lastVerifiedBatchBeforeUpgrade, uint64 rollupTypeID, uint8 rollupCompatibilityID) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCaller) RollupIDToRollupData(opts *bind.CallOpts, rollupID uint32) (struct { + RollupContract common.Address + ChainID uint64 + Verifier common.Address + ForkID uint64 + LastLocalExitRoot [32]byte + LastBatchSequenced uint64 + LastVerifiedBatch uint64 + LastPendingState uint64 + LastPendingStateConsolidated uint64 + LastVerifiedBatchBeforeUpgrade uint64 + RollupTypeID uint64 + RollupCompatibilityID uint8 +}, error) { + var out []interface{} + err := _Mockpolygonrollupmanager.contract.Call(opts, &out, "rollupIDToRollupData", rollupID) + + outstruct := new(struct { + RollupContract common.Address + ChainID uint64 + Verifier common.Address + ForkID uint64 + LastLocalExitRoot [32]byte + LastBatchSequenced uint64 + LastVerifiedBatch uint64 + LastPendingState uint64 + LastPendingStateConsolidated uint64 + LastVerifiedBatchBeforeUpgrade uint64 + RollupTypeID uint64 + RollupCompatibilityID uint8 + }) + if err != nil { + return *outstruct, err + } + + outstruct.RollupContract = *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + outstruct.ChainID = *abi.ConvertType(out[1], new(uint64)).(*uint64) + outstruct.Verifier = *abi.ConvertType(out[2], new(common.Address)).(*common.Address) + outstruct.ForkID = *abi.ConvertType(out[3], new(uint64)).(*uint64) + outstruct.LastLocalExitRoot = *abi.ConvertType(out[4], new([32]byte)).(*[32]byte) + outstruct.LastBatchSequenced = *abi.ConvertType(out[5], new(uint64)).(*uint64) + outstruct.LastVerifiedBatch = *abi.ConvertType(out[6], new(uint64)).(*uint64) + outstruct.LastPendingState = *abi.ConvertType(out[7], new(uint64)).(*uint64) + outstruct.LastPendingStateConsolidated = *abi.ConvertType(out[8], new(uint64)).(*uint64) + outstruct.LastVerifiedBatchBeforeUpgrade = *abi.ConvertType(out[9], new(uint64)).(*uint64) + outstruct.RollupTypeID = *abi.ConvertType(out[10], new(uint64)).(*uint64) + outstruct.RollupCompatibilityID = *abi.ConvertType(out[11], new(uint8)).(*uint8) + + return *outstruct, err + +} + +// RollupIDToRollupData is a free data retrieval call binding the contract method 0xf9c4c2ae. +// +// Solidity: function rollupIDToRollupData(uint32 rollupID) view returns(address rollupContract, uint64 chainID, address verifier, uint64 forkID, bytes32 lastLocalExitRoot, uint64 lastBatchSequenced, uint64 lastVerifiedBatch, uint64 lastPendingState, uint64 lastPendingStateConsolidated, uint64 lastVerifiedBatchBeforeUpgrade, uint64 rollupTypeID, uint8 rollupCompatibilityID) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) RollupIDToRollupData(rollupID uint32) (struct { + RollupContract common.Address + ChainID uint64 + Verifier common.Address + ForkID uint64 + LastLocalExitRoot [32]byte + LastBatchSequenced uint64 + LastVerifiedBatch uint64 + LastPendingState uint64 + LastPendingStateConsolidated uint64 + LastVerifiedBatchBeforeUpgrade uint64 + RollupTypeID uint64 + RollupCompatibilityID uint8 +}, error) { + return _Mockpolygonrollupmanager.Contract.RollupIDToRollupData(&_Mockpolygonrollupmanager.CallOpts, rollupID) +} + +// RollupIDToRollupData is a free data retrieval call binding the contract method 0xf9c4c2ae. +// +// Solidity: function rollupIDToRollupData(uint32 rollupID) view returns(address rollupContract, uint64 chainID, address verifier, uint64 forkID, bytes32 lastLocalExitRoot, uint64 lastBatchSequenced, uint64 lastVerifiedBatch, uint64 lastPendingState, uint64 lastPendingStateConsolidated, uint64 lastVerifiedBatchBeforeUpgrade, uint64 rollupTypeID, uint8 rollupCompatibilityID) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCallerSession) RollupIDToRollupData(rollupID uint32) (struct { + RollupContract common.Address + ChainID uint64 + Verifier common.Address + ForkID uint64 + LastLocalExitRoot [32]byte + LastBatchSequenced uint64 + LastVerifiedBatch uint64 + LastPendingState uint64 + LastPendingStateConsolidated uint64 + LastVerifiedBatchBeforeUpgrade uint64 + RollupTypeID uint64 + RollupCompatibilityID uint8 +}, error) { + return _Mockpolygonrollupmanager.Contract.RollupIDToRollupData(&_Mockpolygonrollupmanager.CallOpts, rollupID) +} + +// RollupTypeCount is a free data retrieval call binding the contract method 0x1796a1ae. +// +// Solidity: function rollupTypeCount() view returns(uint32) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCaller) RollupTypeCount(opts *bind.CallOpts) (uint32, error) { + var out []interface{} + err := _Mockpolygonrollupmanager.contract.Call(opts, &out, "rollupTypeCount") + + if err != nil { + return *new(uint32), err + } + + out0 := *abi.ConvertType(out[0], new(uint32)).(*uint32) + + return out0, err + +} + +// RollupTypeCount is a free data retrieval call binding the contract method 0x1796a1ae. +// +// Solidity: function rollupTypeCount() view returns(uint32) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) RollupTypeCount() (uint32, error) { + return _Mockpolygonrollupmanager.Contract.RollupTypeCount(&_Mockpolygonrollupmanager.CallOpts) +} + +// RollupTypeCount is a free data retrieval call binding the contract method 0x1796a1ae. +// +// Solidity: function rollupTypeCount() view returns(uint32) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCallerSession) RollupTypeCount() (uint32, error) { + return _Mockpolygonrollupmanager.Contract.RollupTypeCount(&_Mockpolygonrollupmanager.CallOpts) +} + +// RollupTypeMap is a free data retrieval call binding the contract method 0x65c0504d. +// +// Solidity: function rollupTypeMap(uint32 rollupTypeID) view returns(address consensusImplementation, address verifier, uint64 forkID, uint8 rollupCompatibilityID, bool obsolete, bytes32 genesis) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCaller) RollupTypeMap(opts *bind.CallOpts, rollupTypeID uint32) (struct { + ConsensusImplementation common.Address + Verifier common.Address + ForkID uint64 + RollupCompatibilityID uint8 + Obsolete bool + Genesis [32]byte +}, error) { + var out []interface{} + err := _Mockpolygonrollupmanager.contract.Call(opts, &out, "rollupTypeMap", rollupTypeID) + + outstruct := new(struct { + ConsensusImplementation common.Address + Verifier common.Address + ForkID uint64 + RollupCompatibilityID uint8 + Obsolete bool + Genesis [32]byte + }) + if err != nil { + return *outstruct, err + } + + outstruct.ConsensusImplementation = *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + outstruct.Verifier = *abi.ConvertType(out[1], new(common.Address)).(*common.Address) + outstruct.ForkID = *abi.ConvertType(out[2], new(uint64)).(*uint64) + outstruct.RollupCompatibilityID = *abi.ConvertType(out[3], new(uint8)).(*uint8) + outstruct.Obsolete = *abi.ConvertType(out[4], new(bool)).(*bool) + outstruct.Genesis = *abi.ConvertType(out[5], new([32]byte)).(*[32]byte) + + return *outstruct, err + +} + +// RollupTypeMap is a free data retrieval call binding the contract method 0x65c0504d. +// +// Solidity: function rollupTypeMap(uint32 rollupTypeID) view returns(address consensusImplementation, address verifier, uint64 forkID, uint8 rollupCompatibilityID, bool obsolete, bytes32 genesis) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) RollupTypeMap(rollupTypeID uint32) (struct { + ConsensusImplementation common.Address + Verifier common.Address + ForkID uint64 + RollupCompatibilityID uint8 + Obsolete bool + Genesis [32]byte +}, error) { + return _Mockpolygonrollupmanager.Contract.RollupTypeMap(&_Mockpolygonrollupmanager.CallOpts, rollupTypeID) +} + +// RollupTypeMap is a free data retrieval call binding the contract method 0x65c0504d. +// +// Solidity: function rollupTypeMap(uint32 rollupTypeID) view returns(address consensusImplementation, address verifier, uint64 forkID, uint8 rollupCompatibilityID, bool obsolete, bytes32 genesis) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCallerSession) RollupTypeMap(rollupTypeID uint32) (struct { + ConsensusImplementation common.Address + Verifier common.Address + ForkID uint64 + RollupCompatibilityID uint8 + Obsolete bool + Genesis [32]byte +}, error) { + return _Mockpolygonrollupmanager.Contract.RollupTypeMap(&_Mockpolygonrollupmanager.CallOpts, rollupTypeID) +} + +// TotalSequencedBatches is a free data retrieval call binding the contract method 0x066ec012. +// +// Solidity: function totalSequencedBatches() view returns(uint64) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCaller) TotalSequencedBatches(opts *bind.CallOpts) (uint64, error) { + var out []interface{} + err := _Mockpolygonrollupmanager.contract.Call(opts, &out, "totalSequencedBatches") + + if err != nil { + return *new(uint64), err + } + + out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64) + + return out0, err + +} + +// TotalSequencedBatches is a free data retrieval call binding the contract method 0x066ec012. +// +// Solidity: function totalSequencedBatches() view returns(uint64) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) TotalSequencedBatches() (uint64, error) { + return _Mockpolygonrollupmanager.Contract.TotalSequencedBatches(&_Mockpolygonrollupmanager.CallOpts) +} + +// TotalSequencedBatches is a free data retrieval call binding the contract method 0x066ec012. +// +// Solidity: function totalSequencedBatches() view returns(uint64) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCallerSession) TotalSequencedBatches() (uint64, error) { + return _Mockpolygonrollupmanager.Contract.TotalSequencedBatches(&_Mockpolygonrollupmanager.CallOpts) +} + +// TotalVerifiedBatches is a free data retrieval call binding the contract method 0xdde0ff77. +// +// Solidity: function totalVerifiedBatches() view returns(uint64) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCaller) TotalVerifiedBatches(opts *bind.CallOpts) (uint64, error) { + var out []interface{} + err := _Mockpolygonrollupmanager.contract.Call(opts, &out, "totalVerifiedBatches") + + if err != nil { + return *new(uint64), err + } + + out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64) + + return out0, err + +} + +// TotalVerifiedBatches is a free data retrieval call binding the contract method 0xdde0ff77. +// +// Solidity: function totalVerifiedBatches() view returns(uint64) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) TotalVerifiedBatches() (uint64, error) { + return _Mockpolygonrollupmanager.Contract.TotalVerifiedBatches(&_Mockpolygonrollupmanager.CallOpts) +} + +// TotalVerifiedBatches is a free data retrieval call binding the contract method 0xdde0ff77. +// +// Solidity: function totalVerifiedBatches() view returns(uint64) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCallerSession) TotalVerifiedBatches() (uint64, error) { + return _Mockpolygonrollupmanager.Contract.TotalVerifiedBatches(&_Mockpolygonrollupmanager.CallOpts) +} + +// TrustedAggregatorTimeout is a free data retrieval call binding the contract method 0x841b24d7. +// +// Solidity: function trustedAggregatorTimeout() view returns(uint64) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCaller) TrustedAggregatorTimeout(opts *bind.CallOpts) (uint64, error) { + var out []interface{} + err := _Mockpolygonrollupmanager.contract.Call(opts, &out, "trustedAggregatorTimeout") + + if err != nil { + return *new(uint64), err + } + + out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64) + + return out0, err + +} + +// TrustedAggregatorTimeout is a free data retrieval call binding the contract method 0x841b24d7. +// +// Solidity: function trustedAggregatorTimeout() view returns(uint64) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) TrustedAggregatorTimeout() (uint64, error) { + return _Mockpolygonrollupmanager.Contract.TrustedAggregatorTimeout(&_Mockpolygonrollupmanager.CallOpts) +} + +// TrustedAggregatorTimeout is a free data retrieval call binding the contract method 0x841b24d7. +// +// Solidity: function trustedAggregatorTimeout() view returns(uint64) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCallerSession) TrustedAggregatorTimeout() (uint64, error) { + return _Mockpolygonrollupmanager.Contract.TrustedAggregatorTimeout(&_Mockpolygonrollupmanager.CallOpts) +} + +// VerifyBatchTimeTarget is a free data retrieval call binding the contract method 0x0a0d9fbe. +// +// Solidity: function verifyBatchTimeTarget() view returns(uint64) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCaller) VerifyBatchTimeTarget(opts *bind.CallOpts) (uint64, error) { + var out []interface{} + err := _Mockpolygonrollupmanager.contract.Call(opts, &out, "verifyBatchTimeTarget") + + if err != nil { + return *new(uint64), err + } + + out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64) + + return out0, err + +} + +// VerifyBatchTimeTarget is a free data retrieval call binding the contract method 0x0a0d9fbe. +// +// Solidity: function verifyBatchTimeTarget() view returns(uint64) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) VerifyBatchTimeTarget() (uint64, error) { + return _Mockpolygonrollupmanager.Contract.VerifyBatchTimeTarget(&_Mockpolygonrollupmanager.CallOpts) +} + +// VerifyBatchTimeTarget is a free data retrieval call binding the contract method 0x0a0d9fbe. +// +// Solidity: function verifyBatchTimeTarget() view returns(uint64) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCallerSession) VerifyBatchTimeTarget() (uint64, error) { + return _Mockpolygonrollupmanager.Contract.VerifyBatchTimeTarget(&_Mockpolygonrollupmanager.CallOpts) +} + +// ActivateEmergencyState is a paid mutator transaction binding the contract method 0x2072f6c5. +// +// Solidity: function activateEmergencyState() returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerTransactor) ActivateEmergencyState(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.contract.Transact(opts, "activateEmergencyState") +} + +// ActivateEmergencyState is a paid mutator transaction binding the contract method 0x2072f6c5. +// +// Solidity: function activateEmergencyState() returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) ActivateEmergencyState() (*types.Transaction, error) { + return _Mockpolygonrollupmanager.Contract.ActivateEmergencyState(&_Mockpolygonrollupmanager.TransactOpts) +} + +// ActivateEmergencyState is a paid mutator transaction binding the contract method 0x2072f6c5. +// +// Solidity: function activateEmergencyState() returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerTransactorSession) ActivateEmergencyState() (*types.Transaction, error) { + return _Mockpolygonrollupmanager.Contract.ActivateEmergencyState(&_Mockpolygonrollupmanager.TransactOpts) +} + +// AddExistingRollup is a paid mutator transaction binding the contract method 0xe0bfd3d2. +// +// Solidity: function addExistingRollup(address rollupAddress, address verifier, uint64 forkID, uint64 chainID, bytes32 genesis, uint8 rollupCompatibilityID) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerTransactor) AddExistingRollup(opts *bind.TransactOpts, rollupAddress common.Address, verifier common.Address, forkID uint64, chainID uint64, genesis [32]byte, rollupCompatibilityID uint8) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.contract.Transact(opts, "addExistingRollup", rollupAddress, verifier, forkID, chainID, genesis, rollupCompatibilityID) +} + +// AddExistingRollup is a paid mutator transaction binding the contract method 0xe0bfd3d2. +// +// Solidity: function addExistingRollup(address rollupAddress, address verifier, uint64 forkID, uint64 chainID, bytes32 genesis, uint8 rollupCompatibilityID) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) AddExistingRollup(rollupAddress common.Address, verifier common.Address, forkID uint64, chainID uint64, genesis [32]byte, rollupCompatibilityID uint8) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.Contract.AddExistingRollup(&_Mockpolygonrollupmanager.TransactOpts, rollupAddress, verifier, forkID, chainID, genesis, rollupCompatibilityID) +} + +// AddExistingRollup is a paid mutator transaction binding the contract method 0xe0bfd3d2. +// +// Solidity: function addExistingRollup(address rollupAddress, address verifier, uint64 forkID, uint64 chainID, bytes32 genesis, uint8 rollupCompatibilityID) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerTransactorSession) AddExistingRollup(rollupAddress common.Address, verifier common.Address, forkID uint64, chainID uint64, genesis [32]byte, rollupCompatibilityID uint8) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.Contract.AddExistingRollup(&_Mockpolygonrollupmanager.TransactOpts, rollupAddress, verifier, forkID, chainID, genesis, rollupCompatibilityID) +} + +// AddNewRollupType is a paid mutator transaction binding the contract method 0xf34eb8eb. +// +// Solidity: function addNewRollupType(address consensusImplementation, address verifier, uint64 forkID, uint8 rollupCompatibilityID, bytes32 genesis, string description) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerTransactor) AddNewRollupType(opts *bind.TransactOpts, consensusImplementation common.Address, verifier common.Address, forkID uint64, rollupCompatibilityID uint8, genesis [32]byte, description string) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.contract.Transact(opts, "addNewRollupType", consensusImplementation, verifier, forkID, rollupCompatibilityID, genesis, description) +} + +// AddNewRollupType is a paid mutator transaction binding the contract method 0xf34eb8eb. +// +// Solidity: function addNewRollupType(address consensusImplementation, address verifier, uint64 forkID, uint8 rollupCompatibilityID, bytes32 genesis, string description) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) AddNewRollupType(consensusImplementation common.Address, verifier common.Address, forkID uint64, rollupCompatibilityID uint8, genesis [32]byte, description string) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.Contract.AddNewRollupType(&_Mockpolygonrollupmanager.TransactOpts, consensusImplementation, verifier, forkID, rollupCompatibilityID, genesis, description) +} + +// AddNewRollupType is a paid mutator transaction binding the contract method 0xf34eb8eb. +// +// Solidity: function addNewRollupType(address consensusImplementation, address verifier, uint64 forkID, uint8 rollupCompatibilityID, bytes32 genesis, string description) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerTransactorSession) AddNewRollupType(consensusImplementation common.Address, verifier common.Address, forkID uint64, rollupCompatibilityID uint8, genesis [32]byte, description string) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.Contract.AddNewRollupType(&_Mockpolygonrollupmanager.TransactOpts, consensusImplementation, verifier, forkID, rollupCompatibilityID, genesis, description) +} + +// ConsolidatePendingState is a paid mutator transaction binding the contract method 0x1608859c. +// +// Solidity: function consolidatePendingState(uint32 rollupID, uint64 pendingStateNum) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerTransactor) ConsolidatePendingState(opts *bind.TransactOpts, rollupID uint32, pendingStateNum uint64) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.contract.Transact(opts, "consolidatePendingState", rollupID, pendingStateNum) +} + +// ConsolidatePendingState is a paid mutator transaction binding the contract method 0x1608859c. +// +// Solidity: function consolidatePendingState(uint32 rollupID, uint64 pendingStateNum) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) ConsolidatePendingState(rollupID uint32, pendingStateNum uint64) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.Contract.ConsolidatePendingState(&_Mockpolygonrollupmanager.TransactOpts, rollupID, pendingStateNum) +} + +// ConsolidatePendingState is a paid mutator transaction binding the contract method 0x1608859c. +// +// Solidity: function consolidatePendingState(uint32 rollupID, uint64 pendingStateNum) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerTransactorSession) ConsolidatePendingState(rollupID uint32, pendingStateNum uint64) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.Contract.ConsolidatePendingState(&_Mockpolygonrollupmanager.TransactOpts, rollupID, pendingStateNum) +} + +// CreateNewRollup is a paid mutator transaction binding the contract method 0x727885e9. +// +// Solidity: function createNewRollup(uint32 rollupTypeID, uint64 chainID, address admin, address sequencer, address gasTokenAddress, string sequencerURL, string networkName) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerTransactor) CreateNewRollup(opts *bind.TransactOpts, rollupTypeID uint32, chainID uint64, admin common.Address, sequencer common.Address, gasTokenAddress common.Address, sequencerURL string, networkName string) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.contract.Transact(opts, "createNewRollup", rollupTypeID, chainID, admin, sequencer, gasTokenAddress, sequencerURL, networkName) +} + +// CreateNewRollup is a paid mutator transaction binding the contract method 0x727885e9. +// +// Solidity: function createNewRollup(uint32 rollupTypeID, uint64 chainID, address admin, address sequencer, address gasTokenAddress, string sequencerURL, string networkName) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) CreateNewRollup(rollupTypeID uint32, chainID uint64, admin common.Address, sequencer common.Address, gasTokenAddress common.Address, sequencerURL string, networkName string) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.Contract.CreateNewRollup(&_Mockpolygonrollupmanager.TransactOpts, rollupTypeID, chainID, admin, sequencer, gasTokenAddress, sequencerURL, networkName) +} + +// CreateNewRollup is a paid mutator transaction binding the contract method 0x727885e9. +// +// Solidity: function createNewRollup(uint32 rollupTypeID, uint64 chainID, address admin, address sequencer, address gasTokenAddress, string sequencerURL, string networkName) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerTransactorSession) CreateNewRollup(rollupTypeID uint32, chainID uint64, admin common.Address, sequencer common.Address, gasTokenAddress common.Address, sequencerURL string, networkName string) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.Contract.CreateNewRollup(&_Mockpolygonrollupmanager.TransactOpts, rollupTypeID, chainID, admin, sequencer, gasTokenAddress, sequencerURL, networkName) +} + +// DeactivateEmergencyState is a paid mutator transaction binding the contract method 0xdbc16976. +// +// Solidity: function deactivateEmergencyState() returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerTransactor) DeactivateEmergencyState(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.contract.Transact(opts, "deactivateEmergencyState") +} + +// DeactivateEmergencyState is a paid mutator transaction binding the contract method 0xdbc16976. +// +// Solidity: function deactivateEmergencyState() returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) DeactivateEmergencyState() (*types.Transaction, error) { + return _Mockpolygonrollupmanager.Contract.DeactivateEmergencyState(&_Mockpolygonrollupmanager.TransactOpts) +} + +// DeactivateEmergencyState is a paid mutator transaction binding the contract method 0xdbc16976. +// +// Solidity: function deactivateEmergencyState() returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerTransactorSession) DeactivateEmergencyState() (*types.Transaction, error) { + return _Mockpolygonrollupmanager.Contract.DeactivateEmergencyState(&_Mockpolygonrollupmanager.TransactOpts) +} + +// GrantRole is a paid mutator transaction binding the contract method 0x2f2ff15d. +// +// Solidity: function grantRole(bytes32 role, address account) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerTransactor) GrantRole(opts *bind.TransactOpts, role [32]byte, account common.Address) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.contract.Transact(opts, "grantRole", role, account) +} + +// GrantRole is a paid mutator transaction binding the contract method 0x2f2ff15d. +// +// Solidity: function grantRole(bytes32 role, address account) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) GrantRole(role [32]byte, account common.Address) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.Contract.GrantRole(&_Mockpolygonrollupmanager.TransactOpts, role, account) +} + +// GrantRole is a paid mutator transaction binding the contract method 0x2f2ff15d. +// +// Solidity: function grantRole(bytes32 role, address account) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerTransactorSession) GrantRole(role [32]byte, account common.Address) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.Contract.GrantRole(&_Mockpolygonrollupmanager.TransactOpts, role, account) +} + +// Initialize is a paid mutator transaction binding the contract method 0x0645af09. +// +// Solidity: function initialize(address trustedAggregator, uint64 _pendingStateTimeout, uint64 _trustedAggregatorTimeout, address admin, address timelock, address emergencyCouncil, address polygonZkEVM, address zkEVMVerifier, uint64 zkEVMForkID, uint64 zkEVMChainID) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerTransactor) Initialize(opts *bind.TransactOpts, trustedAggregator common.Address, _pendingStateTimeout uint64, _trustedAggregatorTimeout uint64, admin common.Address, timelock common.Address, emergencyCouncil common.Address, polygonZkEVM common.Address, zkEVMVerifier common.Address, zkEVMForkID uint64, zkEVMChainID uint64) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.contract.Transact(opts, "initialize", trustedAggregator, _pendingStateTimeout, _trustedAggregatorTimeout, admin, timelock, emergencyCouncil, polygonZkEVM, zkEVMVerifier, zkEVMForkID, zkEVMChainID) +} + +// Initialize is a paid mutator transaction binding the contract method 0x0645af09. +// +// Solidity: function initialize(address trustedAggregator, uint64 _pendingStateTimeout, uint64 _trustedAggregatorTimeout, address admin, address timelock, address emergencyCouncil, address polygonZkEVM, address zkEVMVerifier, uint64 zkEVMForkID, uint64 zkEVMChainID) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) Initialize(trustedAggregator common.Address, _pendingStateTimeout uint64, _trustedAggregatorTimeout uint64, admin common.Address, timelock common.Address, emergencyCouncil common.Address, polygonZkEVM common.Address, zkEVMVerifier common.Address, zkEVMForkID uint64, zkEVMChainID uint64) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.Contract.Initialize(&_Mockpolygonrollupmanager.TransactOpts, trustedAggregator, _pendingStateTimeout, _trustedAggregatorTimeout, admin, timelock, emergencyCouncil, polygonZkEVM, zkEVMVerifier, zkEVMForkID, zkEVMChainID) +} + +// Initialize is a paid mutator transaction binding the contract method 0x0645af09. +// +// Solidity: function initialize(address trustedAggregator, uint64 _pendingStateTimeout, uint64 _trustedAggregatorTimeout, address admin, address timelock, address emergencyCouncil, address polygonZkEVM, address zkEVMVerifier, uint64 zkEVMForkID, uint64 zkEVMChainID) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerTransactorSession) Initialize(trustedAggregator common.Address, _pendingStateTimeout uint64, _trustedAggregatorTimeout uint64, admin common.Address, timelock common.Address, emergencyCouncil common.Address, polygonZkEVM common.Address, zkEVMVerifier common.Address, zkEVMForkID uint64, zkEVMChainID uint64) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.Contract.Initialize(&_Mockpolygonrollupmanager.TransactOpts, trustedAggregator, _pendingStateTimeout, _trustedAggregatorTimeout, admin, timelock, emergencyCouncil, polygonZkEVM, zkEVMVerifier, zkEVMForkID, zkEVMChainID) +} + +// InitializeMock is a paid mutator transaction binding the contract method 0x0e36f582. +// +// Solidity: function initializeMock(address trustedAggregator, uint64 _pendingStateTimeout, uint64 _trustedAggregatorTimeout, address admin, address timelock, address emergencyCouncil) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerTransactor) InitializeMock(opts *bind.TransactOpts, trustedAggregator common.Address, _pendingStateTimeout uint64, _trustedAggregatorTimeout uint64, admin common.Address, timelock common.Address, emergencyCouncil common.Address) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.contract.Transact(opts, "initializeMock", trustedAggregator, _pendingStateTimeout, _trustedAggregatorTimeout, admin, timelock, emergencyCouncil) +} + +// InitializeMock is a paid mutator transaction binding the contract method 0x0e36f582. +// +// Solidity: function initializeMock(address trustedAggregator, uint64 _pendingStateTimeout, uint64 _trustedAggregatorTimeout, address admin, address timelock, address emergencyCouncil) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) InitializeMock(trustedAggregator common.Address, _pendingStateTimeout uint64, _trustedAggregatorTimeout uint64, admin common.Address, timelock common.Address, emergencyCouncil common.Address) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.Contract.InitializeMock(&_Mockpolygonrollupmanager.TransactOpts, trustedAggregator, _pendingStateTimeout, _trustedAggregatorTimeout, admin, timelock, emergencyCouncil) +} + +// InitializeMock is a paid mutator transaction binding the contract method 0x0e36f582. +// +// Solidity: function initializeMock(address trustedAggregator, uint64 _pendingStateTimeout, uint64 _trustedAggregatorTimeout, address admin, address timelock, address emergencyCouncil) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerTransactorSession) InitializeMock(trustedAggregator common.Address, _pendingStateTimeout uint64, _trustedAggregatorTimeout uint64, admin common.Address, timelock common.Address, emergencyCouncil common.Address) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.Contract.InitializeMock(&_Mockpolygonrollupmanager.TransactOpts, trustedAggregator, _pendingStateTimeout, _trustedAggregatorTimeout, admin, timelock, emergencyCouncil) +} + +// ObsoleteRollupType is a paid mutator transaction binding the contract method 0x7222020f. +// +// Solidity: function obsoleteRollupType(uint32 rollupTypeID) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerTransactor) ObsoleteRollupType(opts *bind.TransactOpts, rollupTypeID uint32) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.contract.Transact(opts, "obsoleteRollupType", rollupTypeID) +} + +// ObsoleteRollupType is a paid mutator transaction binding the contract method 0x7222020f. +// +// Solidity: function obsoleteRollupType(uint32 rollupTypeID) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) ObsoleteRollupType(rollupTypeID uint32) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.Contract.ObsoleteRollupType(&_Mockpolygonrollupmanager.TransactOpts, rollupTypeID) +} + +// ObsoleteRollupType is a paid mutator transaction binding the contract method 0x7222020f. +// +// Solidity: function obsoleteRollupType(uint32 rollupTypeID) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerTransactorSession) ObsoleteRollupType(rollupTypeID uint32) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.Contract.ObsoleteRollupType(&_Mockpolygonrollupmanager.TransactOpts, rollupTypeID) +} + +// OnSequenceBatches is a paid mutator transaction binding the contract method 0x9a908e73. +// +// Solidity: function onSequenceBatches(uint64 newSequencedBatches, bytes32 newAccInputHash) returns(uint64) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerTransactor) OnSequenceBatches(opts *bind.TransactOpts, newSequencedBatches uint64, newAccInputHash [32]byte) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.contract.Transact(opts, "onSequenceBatches", newSequencedBatches, newAccInputHash) +} + +// OnSequenceBatches is a paid mutator transaction binding the contract method 0x9a908e73. +// +// Solidity: function onSequenceBatches(uint64 newSequencedBatches, bytes32 newAccInputHash) returns(uint64) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) OnSequenceBatches(newSequencedBatches uint64, newAccInputHash [32]byte) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.Contract.OnSequenceBatches(&_Mockpolygonrollupmanager.TransactOpts, newSequencedBatches, newAccInputHash) +} + +// OnSequenceBatches is a paid mutator transaction binding the contract method 0x9a908e73. +// +// Solidity: function onSequenceBatches(uint64 newSequencedBatches, bytes32 newAccInputHash) returns(uint64) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerTransactorSession) OnSequenceBatches(newSequencedBatches uint64, newAccInputHash [32]byte) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.Contract.OnSequenceBatches(&_Mockpolygonrollupmanager.TransactOpts, newSequencedBatches, newAccInputHash) +} + +// OverridePendingState is a paid mutator transaction binding the contract method 0x12b86e19. +// +// Solidity: function overridePendingState(uint32 rollupID, uint64 initPendingStateNum, uint64 finalPendingStateNum, uint64 initNumBatch, uint64 finalNewBatch, bytes32 newLocalExitRoot, bytes32 newStateRoot, bytes32[24] proof) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerTransactor) OverridePendingState(opts *bind.TransactOpts, rollupID uint32, initPendingStateNum uint64, finalPendingStateNum uint64, initNumBatch uint64, finalNewBatch uint64, newLocalExitRoot [32]byte, newStateRoot [32]byte, proof [24][32]byte) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.contract.Transact(opts, "overridePendingState", rollupID, initPendingStateNum, finalPendingStateNum, initNumBatch, finalNewBatch, newLocalExitRoot, newStateRoot, proof) +} + +// OverridePendingState is a paid mutator transaction binding the contract method 0x12b86e19. +// +// Solidity: function overridePendingState(uint32 rollupID, uint64 initPendingStateNum, uint64 finalPendingStateNum, uint64 initNumBatch, uint64 finalNewBatch, bytes32 newLocalExitRoot, bytes32 newStateRoot, bytes32[24] proof) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) OverridePendingState(rollupID uint32, initPendingStateNum uint64, finalPendingStateNum uint64, initNumBatch uint64, finalNewBatch uint64, newLocalExitRoot [32]byte, newStateRoot [32]byte, proof [24][32]byte) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.Contract.OverridePendingState(&_Mockpolygonrollupmanager.TransactOpts, rollupID, initPendingStateNum, finalPendingStateNum, initNumBatch, finalNewBatch, newLocalExitRoot, newStateRoot, proof) +} + +// OverridePendingState is a paid mutator transaction binding the contract method 0x12b86e19. +// +// Solidity: function overridePendingState(uint32 rollupID, uint64 initPendingStateNum, uint64 finalPendingStateNum, uint64 initNumBatch, uint64 finalNewBatch, bytes32 newLocalExitRoot, bytes32 newStateRoot, bytes32[24] proof) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerTransactorSession) OverridePendingState(rollupID uint32, initPendingStateNum uint64, finalPendingStateNum uint64, initNumBatch uint64, finalNewBatch uint64, newLocalExitRoot [32]byte, newStateRoot [32]byte, proof [24][32]byte) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.Contract.OverridePendingState(&_Mockpolygonrollupmanager.TransactOpts, rollupID, initPendingStateNum, finalPendingStateNum, initNumBatch, finalNewBatch, newLocalExitRoot, newStateRoot, proof) +} + +// ProveNonDeterministicPendingState is a paid mutator transaction binding the contract method 0x8bd4f071. +// +// Solidity: function proveNonDeterministicPendingState(uint32 rollupID, uint64 initPendingStateNum, uint64 finalPendingStateNum, uint64 initNumBatch, uint64 finalNewBatch, bytes32 newLocalExitRoot, bytes32 newStateRoot, bytes32[24] proof) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerTransactor) ProveNonDeterministicPendingState(opts *bind.TransactOpts, rollupID uint32, initPendingStateNum uint64, finalPendingStateNum uint64, initNumBatch uint64, finalNewBatch uint64, newLocalExitRoot [32]byte, newStateRoot [32]byte, proof [24][32]byte) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.contract.Transact(opts, "proveNonDeterministicPendingState", rollupID, initPendingStateNum, finalPendingStateNum, initNumBatch, finalNewBatch, newLocalExitRoot, newStateRoot, proof) +} + +// ProveNonDeterministicPendingState is a paid mutator transaction binding the contract method 0x8bd4f071. +// +// Solidity: function proveNonDeterministicPendingState(uint32 rollupID, uint64 initPendingStateNum, uint64 finalPendingStateNum, uint64 initNumBatch, uint64 finalNewBatch, bytes32 newLocalExitRoot, bytes32 newStateRoot, bytes32[24] proof) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) ProveNonDeterministicPendingState(rollupID uint32, initPendingStateNum uint64, finalPendingStateNum uint64, initNumBatch uint64, finalNewBatch uint64, newLocalExitRoot [32]byte, newStateRoot [32]byte, proof [24][32]byte) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.Contract.ProveNonDeterministicPendingState(&_Mockpolygonrollupmanager.TransactOpts, rollupID, initPendingStateNum, finalPendingStateNum, initNumBatch, finalNewBatch, newLocalExitRoot, newStateRoot, proof) +} + +// ProveNonDeterministicPendingState is a paid mutator transaction binding the contract method 0x8bd4f071. +// +// Solidity: function proveNonDeterministicPendingState(uint32 rollupID, uint64 initPendingStateNum, uint64 finalPendingStateNum, uint64 initNumBatch, uint64 finalNewBatch, bytes32 newLocalExitRoot, bytes32 newStateRoot, bytes32[24] proof) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerTransactorSession) ProveNonDeterministicPendingState(rollupID uint32, initPendingStateNum uint64, finalPendingStateNum uint64, initNumBatch uint64, finalNewBatch uint64, newLocalExitRoot [32]byte, newStateRoot [32]byte, proof [24][32]byte) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.Contract.ProveNonDeterministicPendingState(&_Mockpolygonrollupmanager.TransactOpts, rollupID, initPendingStateNum, finalPendingStateNum, initNumBatch, finalNewBatch, newLocalExitRoot, newStateRoot, proof) +} + +// RenounceRole is a paid mutator transaction binding the contract method 0x36568abe. +// +// Solidity: function renounceRole(bytes32 role, address account) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerTransactor) RenounceRole(opts *bind.TransactOpts, role [32]byte, account common.Address) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.contract.Transact(opts, "renounceRole", role, account) +} + +// RenounceRole is a paid mutator transaction binding the contract method 0x36568abe. +// +// Solidity: function renounceRole(bytes32 role, address account) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) RenounceRole(role [32]byte, account common.Address) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.Contract.RenounceRole(&_Mockpolygonrollupmanager.TransactOpts, role, account) +} + +// RenounceRole is a paid mutator transaction binding the contract method 0x36568abe. +// +// Solidity: function renounceRole(bytes32 role, address account) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerTransactorSession) RenounceRole(role [32]byte, account common.Address) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.Contract.RenounceRole(&_Mockpolygonrollupmanager.TransactOpts, role, account) +} + +// RevokeRole is a paid mutator transaction binding the contract method 0xd547741f. +// +// Solidity: function revokeRole(bytes32 role, address account) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerTransactor) RevokeRole(opts *bind.TransactOpts, role [32]byte, account common.Address) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.contract.Transact(opts, "revokeRole", role, account) +} + +// RevokeRole is a paid mutator transaction binding the contract method 0xd547741f. +// +// Solidity: function revokeRole(bytes32 role, address account) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) RevokeRole(role [32]byte, account common.Address) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.Contract.RevokeRole(&_Mockpolygonrollupmanager.TransactOpts, role, account) +} + +// RevokeRole is a paid mutator transaction binding the contract method 0xd547741f. +// +// Solidity: function revokeRole(bytes32 role, address account) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerTransactorSession) RevokeRole(role [32]byte, account common.Address) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.Contract.RevokeRole(&_Mockpolygonrollupmanager.TransactOpts, role, account) +} + +// SetBatchFee is a paid mutator transaction binding the contract method 0xd5073f6f. +// +// Solidity: function setBatchFee(uint256 newBatchFee) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerTransactor) SetBatchFee(opts *bind.TransactOpts, newBatchFee *big.Int) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.contract.Transact(opts, "setBatchFee", newBatchFee) +} + +// SetBatchFee is a paid mutator transaction binding the contract method 0xd5073f6f. +// +// Solidity: function setBatchFee(uint256 newBatchFee) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) SetBatchFee(newBatchFee *big.Int) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.Contract.SetBatchFee(&_Mockpolygonrollupmanager.TransactOpts, newBatchFee) +} + +// SetBatchFee is a paid mutator transaction binding the contract method 0xd5073f6f. +// +// Solidity: function setBatchFee(uint256 newBatchFee) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerTransactorSession) SetBatchFee(newBatchFee *big.Int) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.Contract.SetBatchFee(&_Mockpolygonrollupmanager.TransactOpts, newBatchFee) +} + +// SetMultiplierBatchFee is a paid mutator transaction binding the contract method 0x1816b7e5. +// +// Solidity: function setMultiplierBatchFee(uint16 newMultiplierBatchFee) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerTransactor) SetMultiplierBatchFee(opts *bind.TransactOpts, newMultiplierBatchFee uint16) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.contract.Transact(opts, "setMultiplierBatchFee", newMultiplierBatchFee) +} + +// SetMultiplierBatchFee is a paid mutator transaction binding the contract method 0x1816b7e5. +// +// Solidity: function setMultiplierBatchFee(uint16 newMultiplierBatchFee) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) SetMultiplierBatchFee(newMultiplierBatchFee uint16) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.Contract.SetMultiplierBatchFee(&_Mockpolygonrollupmanager.TransactOpts, newMultiplierBatchFee) +} + +// SetMultiplierBatchFee is a paid mutator transaction binding the contract method 0x1816b7e5. +// +// Solidity: function setMultiplierBatchFee(uint16 newMultiplierBatchFee) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerTransactorSession) SetMultiplierBatchFee(newMultiplierBatchFee uint16) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.Contract.SetMultiplierBatchFee(&_Mockpolygonrollupmanager.TransactOpts, newMultiplierBatchFee) +} + +// SetPendingStateTimeout is a paid mutator transaction binding the contract method 0x9c9f3dfe. +// +// Solidity: function setPendingStateTimeout(uint64 newPendingStateTimeout) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerTransactor) SetPendingStateTimeout(opts *bind.TransactOpts, newPendingStateTimeout uint64) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.contract.Transact(opts, "setPendingStateTimeout", newPendingStateTimeout) +} + +// SetPendingStateTimeout is a paid mutator transaction binding the contract method 0x9c9f3dfe. +// +// Solidity: function setPendingStateTimeout(uint64 newPendingStateTimeout) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) SetPendingStateTimeout(newPendingStateTimeout uint64) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.Contract.SetPendingStateTimeout(&_Mockpolygonrollupmanager.TransactOpts, newPendingStateTimeout) +} + +// SetPendingStateTimeout is a paid mutator transaction binding the contract method 0x9c9f3dfe. +// +// Solidity: function setPendingStateTimeout(uint64 newPendingStateTimeout) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerTransactorSession) SetPendingStateTimeout(newPendingStateTimeout uint64) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.Contract.SetPendingStateTimeout(&_Mockpolygonrollupmanager.TransactOpts, newPendingStateTimeout) +} + +// SetTrustedAggregatorTimeout is a paid mutator transaction binding the contract method 0x394218e9. +// +// Solidity: function setTrustedAggregatorTimeout(uint64 newTrustedAggregatorTimeout) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerTransactor) SetTrustedAggregatorTimeout(opts *bind.TransactOpts, newTrustedAggregatorTimeout uint64) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.contract.Transact(opts, "setTrustedAggregatorTimeout", newTrustedAggregatorTimeout) +} + +// SetTrustedAggregatorTimeout is a paid mutator transaction binding the contract method 0x394218e9. +// +// Solidity: function setTrustedAggregatorTimeout(uint64 newTrustedAggregatorTimeout) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) SetTrustedAggregatorTimeout(newTrustedAggregatorTimeout uint64) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.Contract.SetTrustedAggregatorTimeout(&_Mockpolygonrollupmanager.TransactOpts, newTrustedAggregatorTimeout) +} + +// SetTrustedAggregatorTimeout is a paid mutator transaction binding the contract method 0x394218e9. +// +// Solidity: function setTrustedAggregatorTimeout(uint64 newTrustedAggregatorTimeout) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerTransactorSession) SetTrustedAggregatorTimeout(newTrustedAggregatorTimeout uint64) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.Contract.SetTrustedAggregatorTimeout(&_Mockpolygonrollupmanager.TransactOpts, newTrustedAggregatorTimeout) +} + +// SetVerifyBatchTimeTarget is a paid mutator transaction binding the contract method 0xa066215c. +// +// Solidity: function setVerifyBatchTimeTarget(uint64 newVerifyBatchTimeTarget) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerTransactor) SetVerifyBatchTimeTarget(opts *bind.TransactOpts, newVerifyBatchTimeTarget uint64) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.contract.Transact(opts, "setVerifyBatchTimeTarget", newVerifyBatchTimeTarget) +} + +// SetVerifyBatchTimeTarget is a paid mutator transaction binding the contract method 0xa066215c. +// +// Solidity: function setVerifyBatchTimeTarget(uint64 newVerifyBatchTimeTarget) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) SetVerifyBatchTimeTarget(newVerifyBatchTimeTarget uint64) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.Contract.SetVerifyBatchTimeTarget(&_Mockpolygonrollupmanager.TransactOpts, newVerifyBatchTimeTarget) +} + +// SetVerifyBatchTimeTarget is a paid mutator transaction binding the contract method 0xa066215c. +// +// Solidity: function setVerifyBatchTimeTarget(uint64 newVerifyBatchTimeTarget) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerTransactorSession) SetVerifyBatchTimeTarget(newVerifyBatchTimeTarget uint64) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.Contract.SetVerifyBatchTimeTarget(&_Mockpolygonrollupmanager.TransactOpts, newVerifyBatchTimeTarget) +} + +// UpdateRollup is a paid mutator transaction binding the contract method 0xc4c928c2. +// +// Solidity: function updateRollup(address rollupContract, uint32 newRollupTypeID, bytes upgradeData) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerTransactor) UpdateRollup(opts *bind.TransactOpts, rollupContract common.Address, newRollupTypeID uint32, upgradeData []byte) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.contract.Transact(opts, "updateRollup", rollupContract, newRollupTypeID, upgradeData) +} + +// UpdateRollup is a paid mutator transaction binding the contract method 0xc4c928c2. +// +// Solidity: function updateRollup(address rollupContract, uint32 newRollupTypeID, bytes upgradeData) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) UpdateRollup(rollupContract common.Address, newRollupTypeID uint32, upgradeData []byte) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.Contract.UpdateRollup(&_Mockpolygonrollupmanager.TransactOpts, rollupContract, newRollupTypeID, upgradeData) +} + +// UpdateRollup is a paid mutator transaction binding the contract method 0xc4c928c2. +// +// Solidity: function updateRollup(address rollupContract, uint32 newRollupTypeID, bytes upgradeData) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerTransactorSession) UpdateRollup(rollupContract common.Address, newRollupTypeID uint32, upgradeData []byte) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.Contract.UpdateRollup(&_Mockpolygonrollupmanager.TransactOpts, rollupContract, newRollupTypeID, upgradeData) +} + +// VerifyBatches is a paid mutator transaction binding the contract method 0x87c20c01. +// +// Solidity: function verifyBatches(uint32 rollupID, uint64 pendingStateNum, uint64 initNumBatch, uint64 finalNewBatch, bytes32 newLocalExitRoot, bytes32 newStateRoot, address beneficiary, bytes32[24] proof) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerTransactor) VerifyBatches(opts *bind.TransactOpts, rollupID uint32, pendingStateNum uint64, initNumBatch uint64, finalNewBatch uint64, newLocalExitRoot [32]byte, newStateRoot [32]byte, beneficiary common.Address, proof [24][32]byte) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.contract.Transact(opts, "verifyBatches", rollupID, pendingStateNum, initNumBatch, finalNewBatch, newLocalExitRoot, newStateRoot, beneficiary, proof) +} + +// VerifyBatches is a paid mutator transaction binding the contract method 0x87c20c01. +// +// Solidity: function verifyBatches(uint32 rollupID, uint64 pendingStateNum, uint64 initNumBatch, uint64 finalNewBatch, bytes32 newLocalExitRoot, bytes32 newStateRoot, address beneficiary, bytes32[24] proof) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) VerifyBatches(rollupID uint32, pendingStateNum uint64, initNumBatch uint64, finalNewBatch uint64, newLocalExitRoot [32]byte, newStateRoot [32]byte, beneficiary common.Address, proof [24][32]byte) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.Contract.VerifyBatches(&_Mockpolygonrollupmanager.TransactOpts, rollupID, pendingStateNum, initNumBatch, finalNewBatch, newLocalExitRoot, newStateRoot, beneficiary, proof) +} + +// VerifyBatches is a paid mutator transaction binding the contract method 0x87c20c01. +// +// Solidity: function verifyBatches(uint32 rollupID, uint64 pendingStateNum, uint64 initNumBatch, uint64 finalNewBatch, bytes32 newLocalExitRoot, bytes32 newStateRoot, address beneficiary, bytes32[24] proof) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerTransactorSession) VerifyBatches(rollupID uint32, pendingStateNum uint64, initNumBatch uint64, finalNewBatch uint64, newLocalExitRoot [32]byte, newStateRoot [32]byte, beneficiary common.Address, proof [24][32]byte) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.Contract.VerifyBatches(&_Mockpolygonrollupmanager.TransactOpts, rollupID, pendingStateNum, initNumBatch, finalNewBatch, newLocalExitRoot, newStateRoot, beneficiary, proof) +} + +// VerifyBatchesTrustedAggregator is a paid mutator transaction binding the contract method 0x1489ed10. +// +// Solidity: function verifyBatchesTrustedAggregator(uint32 rollupID, uint64 pendingStateNum, uint64 initNumBatch, uint64 finalNewBatch, bytes32 newLocalExitRoot, bytes32 newStateRoot, address beneficiary, bytes32[24] proof) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerTransactor) VerifyBatchesTrustedAggregator(opts *bind.TransactOpts, rollupID uint32, pendingStateNum uint64, initNumBatch uint64, finalNewBatch uint64, newLocalExitRoot [32]byte, newStateRoot [32]byte, beneficiary common.Address, proof [24][32]byte) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.contract.Transact(opts, "verifyBatchesTrustedAggregator", rollupID, pendingStateNum, initNumBatch, finalNewBatch, newLocalExitRoot, newStateRoot, beneficiary, proof) +} + +// VerifyBatchesTrustedAggregator is a paid mutator transaction binding the contract method 0x1489ed10. +// +// Solidity: function verifyBatchesTrustedAggregator(uint32 rollupID, uint64 pendingStateNum, uint64 initNumBatch, uint64 finalNewBatch, bytes32 newLocalExitRoot, bytes32 newStateRoot, address beneficiary, bytes32[24] proof) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) VerifyBatchesTrustedAggregator(rollupID uint32, pendingStateNum uint64, initNumBatch uint64, finalNewBatch uint64, newLocalExitRoot [32]byte, newStateRoot [32]byte, beneficiary common.Address, proof [24][32]byte) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.Contract.VerifyBatchesTrustedAggregator(&_Mockpolygonrollupmanager.TransactOpts, rollupID, pendingStateNum, initNumBatch, finalNewBatch, newLocalExitRoot, newStateRoot, beneficiary, proof) +} + +// VerifyBatchesTrustedAggregator is a paid mutator transaction binding the contract method 0x1489ed10. +// +// Solidity: function verifyBatchesTrustedAggregator(uint32 rollupID, uint64 pendingStateNum, uint64 initNumBatch, uint64 finalNewBatch, bytes32 newLocalExitRoot, bytes32 newStateRoot, address beneficiary, bytes32[24] proof) returns() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerTransactorSession) VerifyBatchesTrustedAggregator(rollupID uint32, pendingStateNum uint64, initNumBatch uint64, finalNewBatch uint64, newLocalExitRoot [32]byte, newStateRoot [32]byte, beneficiary common.Address, proof [24][32]byte) (*types.Transaction, error) { + return _Mockpolygonrollupmanager.Contract.VerifyBatchesTrustedAggregator(&_Mockpolygonrollupmanager.TransactOpts, rollupID, pendingStateNum, initNumBatch, finalNewBatch, newLocalExitRoot, newStateRoot, beneficiary, proof) +} + +// MockpolygonrollupmanagerAddExistingRollupIterator is returned from FilterAddExistingRollup and is used to iterate over the raw logs and unpacked data for AddExistingRollup events raised by the Mockpolygonrollupmanager contract. +type MockpolygonrollupmanagerAddExistingRollupIterator struct { + Event *MockpolygonrollupmanagerAddExistingRollup // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *MockpolygonrollupmanagerAddExistingRollupIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(MockpolygonrollupmanagerAddExistingRollup) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(MockpolygonrollupmanagerAddExistingRollup) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *MockpolygonrollupmanagerAddExistingRollupIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *MockpolygonrollupmanagerAddExistingRollupIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// MockpolygonrollupmanagerAddExistingRollup represents a AddExistingRollup event raised by the Mockpolygonrollupmanager contract. +type MockpolygonrollupmanagerAddExistingRollup struct { + RollupID uint32 + ForkID uint64 + RollupAddress common.Address + ChainID uint64 + RollupCompatibilityID uint8 + LastVerifiedBatchBeforeUpgrade uint64 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterAddExistingRollup is a free log retrieval operation binding the contract event 0xadfc7d56f7e39b08b321534f14bfb135ad27698f7d2f5ad0edc2356ea9a3f850. +// +// Solidity: event AddExistingRollup(uint32 indexed rollupID, uint64 forkID, address rollupAddress, uint64 chainID, uint8 rollupCompatibilityID, uint64 lastVerifiedBatchBeforeUpgrade) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) FilterAddExistingRollup(opts *bind.FilterOpts, rollupID []uint32) (*MockpolygonrollupmanagerAddExistingRollupIterator, error) { + + var rollupIDRule []interface{} + for _, rollupIDItem := range rollupID { + rollupIDRule = append(rollupIDRule, rollupIDItem) + } + + logs, sub, err := _Mockpolygonrollupmanager.contract.FilterLogs(opts, "AddExistingRollup", rollupIDRule) + if err != nil { + return nil, err + } + return &MockpolygonrollupmanagerAddExistingRollupIterator{contract: _Mockpolygonrollupmanager.contract, event: "AddExistingRollup", logs: logs, sub: sub}, nil +} + +// WatchAddExistingRollup is a free log subscription operation binding the contract event 0xadfc7d56f7e39b08b321534f14bfb135ad27698f7d2f5ad0edc2356ea9a3f850. +// +// Solidity: event AddExistingRollup(uint32 indexed rollupID, uint64 forkID, address rollupAddress, uint64 chainID, uint8 rollupCompatibilityID, uint64 lastVerifiedBatchBeforeUpgrade) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) WatchAddExistingRollup(opts *bind.WatchOpts, sink chan<- *MockpolygonrollupmanagerAddExistingRollup, rollupID []uint32) (event.Subscription, error) { + + var rollupIDRule []interface{} + for _, rollupIDItem := range rollupID { + rollupIDRule = append(rollupIDRule, rollupIDItem) + } + + logs, sub, err := _Mockpolygonrollupmanager.contract.WatchLogs(opts, "AddExistingRollup", rollupIDRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(MockpolygonrollupmanagerAddExistingRollup) + if err := _Mockpolygonrollupmanager.contract.UnpackLog(event, "AddExistingRollup", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseAddExistingRollup is a log parse operation binding the contract event 0xadfc7d56f7e39b08b321534f14bfb135ad27698f7d2f5ad0edc2356ea9a3f850. +// +// Solidity: event AddExistingRollup(uint32 indexed rollupID, uint64 forkID, address rollupAddress, uint64 chainID, uint8 rollupCompatibilityID, uint64 lastVerifiedBatchBeforeUpgrade) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) ParseAddExistingRollup(log types.Log) (*MockpolygonrollupmanagerAddExistingRollup, error) { + event := new(MockpolygonrollupmanagerAddExistingRollup) + if err := _Mockpolygonrollupmanager.contract.UnpackLog(event, "AddExistingRollup", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// MockpolygonrollupmanagerAddNewRollupTypeIterator is returned from FilterAddNewRollupType and is used to iterate over the raw logs and unpacked data for AddNewRollupType events raised by the Mockpolygonrollupmanager contract. +type MockpolygonrollupmanagerAddNewRollupTypeIterator struct { + Event *MockpolygonrollupmanagerAddNewRollupType // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *MockpolygonrollupmanagerAddNewRollupTypeIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(MockpolygonrollupmanagerAddNewRollupType) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(MockpolygonrollupmanagerAddNewRollupType) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *MockpolygonrollupmanagerAddNewRollupTypeIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *MockpolygonrollupmanagerAddNewRollupTypeIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// MockpolygonrollupmanagerAddNewRollupType represents a AddNewRollupType event raised by the Mockpolygonrollupmanager contract. +type MockpolygonrollupmanagerAddNewRollupType struct { + RollupTypeID uint32 + ConsensusImplementation common.Address + Verifier common.Address + ForkID uint64 + RollupCompatibilityID uint8 + Genesis [32]byte + Description string + Raw types.Log // Blockchain specific contextual infos +} + +// FilterAddNewRollupType is a free log retrieval operation binding the contract event 0xa2970448b3bd66ba7e524e7b2a5b9cf94fa29e32488fb942afdfe70dd4b77b52. +// +// Solidity: event AddNewRollupType(uint32 indexed rollupTypeID, address consensusImplementation, address verifier, uint64 forkID, uint8 rollupCompatibilityID, bytes32 genesis, string description) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) FilterAddNewRollupType(opts *bind.FilterOpts, rollupTypeID []uint32) (*MockpolygonrollupmanagerAddNewRollupTypeIterator, error) { + + var rollupTypeIDRule []interface{} + for _, rollupTypeIDItem := range rollupTypeID { + rollupTypeIDRule = append(rollupTypeIDRule, rollupTypeIDItem) + } + + logs, sub, err := _Mockpolygonrollupmanager.contract.FilterLogs(opts, "AddNewRollupType", rollupTypeIDRule) + if err != nil { + return nil, err + } + return &MockpolygonrollupmanagerAddNewRollupTypeIterator{contract: _Mockpolygonrollupmanager.contract, event: "AddNewRollupType", logs: logs, sub: sub}, nil +} + +// WatchAddNewRollupType is a free log subscription operation binding the contract event 0xa2970448b3bd66ba7e524e7b2a5b9cf94fa29e32488fb942afdfe70dd4b77b52. +// +// Solidity: event AddNewRollupType(uint32 indexed rollupTypeID, address consensusImplementation, address verifier, uint64 forkID, uint8 rollupCompatibilityID, bytes32 genesis, string description) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) WatchAddNewRollupType(opts *bind.WatchOpts, sink chan<- *MockpolygonrollupmanagerAddNewRollupType, rollupTypeID []uint32) (event.Subscription, error) { + + var rollupTypeIDRule []interface{} + for _, rollupTypeIDItem := range rollupTypeID { + rollupTypeIDRule = append(rollupTypeIDRule, rollupTypeIDItem) + } + + logs, sub, err := _Mockpolygonrollupmanager.contract.WatchLogs(opts, "AddNewRollupType", rollupTypeIDRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(MockpolygonrollupmanagerAddNewRollupType) + if err := _Mockpolygonrollupmanager.contract.UnpackLog(event, "AddNewRollupType", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseAddNewRollupType is a log parse operation binding the contract event 0xa2970448b3bd66ba7e524e7b2a5b9cf94fa29e32488fb942afdfe70dd4b77b52. +// +// Solidity: event AddNewRollupType(uint32 indexed rollupTypeID, address consensusImplementation, address verifier, uint64 forkID, uint8 rollupCompatibilityID, bytes32 genesis, string description) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) ParseAddNewRollupType(log types.Log) (*MockpolygonrollupmanagerAddNewRollupType, error) { + event := new(MockpolygonrollupmanagerAddNewRollupType) + if err := _Mockpolygonrollupmanager.contract.UnpackLog(event, "AddNewRollupType", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// MockpolygonrollupmanagerConsolidatePendingStateIterator is returned from FilterConsolidatePendingState and is used to iterate over the raw logs and unpacked data for ConsolidatePendingState events raised by the Mockpolygonrollupmanager contract. +type MockpolygonrollupmanagerConsolidatePendingStateIterator struct { + Event *MockpolygonrollupmanagerConsolidatePendingState // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *MockpolygonrollupmanagerConsolidatePendingStateIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(MockpolygonrollupmanagerConsolidatePendingState) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(MockpolygonrollupmanagerConsolidatePendingState) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *MockpolygonrollupmanagerConsolidatePendingStateIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *MockpolygonrollupmanagerConsolidatePendingStateIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// MockpolygonrollupmanagerConsolidatePendingState represents a ConsolidatePendingState event raised by the Mockpolygonrollupmanager contract. +type MockpolygonrollupmanagerConsolidatePendingState struct { + RollupID uint32 + NumBatch uint64 + StateRoot [32]byte + ExitRoot [32]byte + PendingStateNum uint64 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterConsolidatePendingState is a free log retrieval operation binding the contract event 0x581910eb7a27738945c2f00a91f2284b2d6de9d4e472b12f901c2b0df045e21b. +// +// Solidity: event ConsolidatePendingState(uint32 indexed rollupID, uint64 numBatch, bytes32 stateRoot, bytes32 exitRoot, uint64 pendingStateNum) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) FilterConsolidatePendingState(opts *bind.FilterOpts, rollupID []uint32) (*MockpolygonrollupmanagerConsolidatePendingStateIterator, error) { + + var rollupIDRule []interface{} + for _, rollupIDItem := range rollupID { + rollupIDRule = append(rollupIDRule, rollupIDItem) + } + + logs, sub, err := _Mockpolygonrollupmanager.contract.FilterLogs(opts, "ConsolidatePendingState", rollupIDRule) + if err != nil { + return nil, err + } + return &MockpolygonrollupmanagerConsolidatePendingStateIterator{contract: _Mockpolygonrollupmanager.contract, event: "ConsolidatePendingState", logs: logs, sub: sub}, nil +} + +// WatchConsolidatePendingState is a free log subscription operation binding the contract event 0x581910eb7a27738945c2f00a91f2284b2d6de9d4e472b12f901c2b0df045e21b. +// +// Solidity: event ConsolidatePendingState(uint32 indexed rollupID, uint64 numBatch, bytes32 stateRoot, bytes32 exitRoot, uint64 pendingStateNum) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) WatchConsolidatePendingState(opts *bind.WatchOpts, sink chan<- *MockpolygonrollupmanagerConsolidatePendingState, rollupID []uint32) (event.Subscription, error) { + + var rollupIDRule []interface{} + for _, rollupIDItem := range rollupID { + rollupIDRule = append(rollupIDRule, rollupIDItem) + } + + logs, sub, err := _Mockpolygonrollupmanager.contract.WatchLogs(opts, "ConsolidatePendingState", rollupIDRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(MockpolygonrollupmanagerConsolidatePendingState) + if err := _Mockpolygonrollupmanager.contract.UnpackLog(event, "ConsolidatePendingState", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseConsolidatePendingState is a log parse operation binding the contract event 0x581910eb7a27738945c2f00a91f2284b2d6de9d4e472b12f901c2b0df045e21b. +// +// Solidity: event ConsolidatePendingState(uint32 indexed rollupID, uint64 numBatch, bytes32 stateRoot, bytes32 exitRoot, uint64 pendingStateNum) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) ParseConsolidatePendingState(log types.Log) (*MockpolygonrollupmanagerConsolidatePendingState, error) { + event := new(MockpolygonrollupmanagerConsolidatePendingState) + if err := _Mockpolygonrollupmanager.contract.UnpackLog(event, "ConsolidatePendingState", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// MockpolygonrollupmanagerCreateNewRollupIterator is returned from FilterCreateNewRollup and is used to iterate over the raw logs and unpacked data for CreateNewRollup events raised by the Mockpolygonrollupmanager contract. +type MockpolygonrollupmanagerCreateNewRollupIterator struct { + Event *MockpolygonrollupmanagerCreateNewRollup // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *MockpolygonrollupmanagerCreateNewRollupIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(MockpolygonrollupmanagerCreateNewRollup) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(MockpolygonrollupmanagerCreateNewRollup) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *MockpolygonrollupmanagerCreateNewRollupIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *MockpolygonrollupmanagerCreateNewRollupIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// MockpolygonrollupmanagerCreateNewRollup represents a CreateNewRollup event raised by the Mockpolygonrollupmanager contract. +type MockpolygonrollupmanagerCreateNewRollup struct { + RollupID uint32 + RollupTypeID uint32 + RollupAddress common.Address + ChainID uint64 + GasTokenAddress common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterCreateNewRollup is a free log retrieval operation binding the contract event 0x194c983456df6701c6a50830b90fe80e72b823411d0d524970c9590dc277a641. +// +// Solidity: event CreateNewRollup(uint32 indexed rollupID, uint32 rollupTypeID, address rollupAddress, uint64 chainID, address gasTokenAddress) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) FilterCreateNewRollup(opts *bind.FilterOpts, rollupID []uint32) (*MockpolygonrollupmanagerCreateNewRollupIterator, error) { + + var rollupIDRule []interface{} + for _, rollupIDItem := range rollupID { + rollupIDRule = append(rollupIDRule, rollupIDItem) + } + + logs, sub, err := _Mockpolygonrollupmanager.contract.FilterLogs(opts, "CreateNewRollup", rollupIDRule) + if err != nil { + return nil, err + } + return &MockpolygonrollupmanagerCreateNewRollupIterator{contract: _Mockpolygonrollupmanager.contract, event: "CreateNewRollup", logs: logs, sub: sub}, nil +} + +// WatchCreateNewRollup is a free log subscription operation binding the contract event 0x194c983456df6701c6a50830b90fe80e72b823411d0d524970c9590dc277a641. +// +// Solidity: event CreateNewRollup(uint32 indexed rollupID, uint32 rollupTypeID, address rollupAddress, uint64 chainID, address gasTokenAddress) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) WatchCreateNewRollup(opts *bind.WatchOpts, sink chan<- *MockpolygonrollupmanagerCreateNewRollup, rollupID []uint32) (event.Subscription, error) { + + var rollupIDRule []interface{} + for _, rollupIDItem := range rollupID { + rollupIDRule = append(rollupIDRule, rollupIDItem) + } + + logs, sub, err := _Mockpolygonrollupmanager.contract.WatchLogs(opts, "CreateNewRollup", rollupIDRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(MockpolygonrollupmanagerCreateNewRollup) + if err := _Mockpolygonrollupmanager.contract.UnpackLog(event, "CreateNewRollup", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseCreateNewRollup is a log parse operation binding the contract event 0x194c983456df6701c6a50830b90fe80e72b823411d0d524970c9590dc277a641. +// +// Solidity: event CreateNewRollup(uint32 indexed rollupID, uint32 rollupTypeID, address rollupAddress, uint64 chainID, address gasTokenAddress) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) ParseCreateNewRollup(log types.Log) (*MockpolygonrollupmanagerCreateNewRollup, error) { + event := new(MockpolygonrollupmanagerCreateNewRollup) + if err := _Mockpolygonrollupmanager.contract.UnpackLog(event, "CreateNewRollup", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// MockpolygonrollupmanagerEmergencyStateActivatedIterator is returned from FilterEmergencyStateActivated and is used to iterate over the raw logs and unpacked data for EmergencyStateActivated events raised by the Mockpolygonrollupmanager contract. +type MockpolygonrollupmanagerEmergencyStateActivatedIterator struct { + Event *MockpolygonrollupmanagerEmergencyStateActivated // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *MockpolygonrollupmanagerEmergencyStateActivatedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(MockpolygonrollupmanagerEmergencyStateActivated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(MockpolygonrollupmanagerEmergencyStateActivated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *MockpolygonrollupmanagerEmergencyStateActivatedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *MockpolygonrollupmanagerEmergencyStateActivatedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// MockpolygonrollupmanagerEmergencyStateActivated represents a EmergencyStateActivated event raised by the Mockpolygonrollupmanager contract. +type MockpolygonrollupmanagerEmergencyStateActivated struct { + Raw types.Log // Blockchain specific contextual infos +} + +// FilterEmergencyStateActivated is a free log retrieval operation binding the contract event 0x2261efe5aef6fedc1fd1550b25facc9181745623049c7901287030b9ad1a5497. +// +// Solidity: event EmergencyStateActivated() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) FilterEmergencyStateActivated(opts *bind.FilterOpts) (*MockpolygonrollupmanagerEmergencyStateActivatedIterator, error) { + + logs, sub, err := _Mockpolygonrollupmanager.contract.FilterLogs(opts, "EmergencyStateActivated") + if err != nil { + return nil, err + } + return &MockpolygonrollupmanagerEmergencyStateActivatedIterator{contract: _Mockpolygonrollupmanager.contract, event: "EmergencyStateActivated", logs: logs, sub: sub}, nil +} + +// WatchEmergencyStateActivated is a free log subscription operation binding the contract event 0x2261efe5aef6fedc1fd1550b25facc9181745623049c7901287030b9ad1a5497. +// +// Solidity: event EmergencyStateActivated() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) WatchEmergencyStateActivated(opts *bind.WatchOpts, sink chan<- *MockpolygonrollupmanagerEmergencyStateActivated) (event.Subscription, error) { + + logs, sub, err := _Mockpolygonrollupmanager.contract.WatchLogs(opts, "EmergencyStateActivated") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(MockpolygonrollupmanagerEmergencyStateActivated) + if err := _Mockpolygonrollupmanager.contract.UnpackLog(event, "EmergencyStateActivated", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseEmergencyStateActivated is a log parse operation binding the contract event 0x2261efe5aef6fedc1fd1550b25facc9181745623049c7901287030b9ad1a5497. +// +// Solidity: event EmergencyStateActivated() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) ParseEmergencyStateActivated(log types.Log) (*MockpolygonrollupmanagerEmergencyStateActivated, error) { + event := new(MockpolygonrollupmanagerEmergencyStateActivated) + if err := _Mockpolygonrollupmanager.contract.UnpackLog(event, "EmergencyStateActivated", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// MockpolygonrollupmanagerEmergencyStateDeactivatedIterator is returned from FilterEmergencyStateDeactivated and is used to iterate over the raw logs and unpacked data for EmergencyStateDeactivated events raised by the Mockpolygonrollupmanager contract. +type MockpolygonrollupmanagerEmergencyStateDeactivatedIterator struct { + Event *MockpolygonrollupmanagerEmergencyStateDeactivated // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *MockpolygonrollupmanagerEmergencyStateDeactivatedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(MockpolygonrollupmanagerEmergencyStateDeactivated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(MockpolygonrollupmanagerEmergencyStateDeactivated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *MockpolygonrollupmanagerEmergencyStateDeactivatedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *MockpolygonrollupmanagerEmergencyStateDeactivatedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// MockpolygonrollupmanagerEmergencyStateDeactivated represents a EmergencyStateDeactivated event raised by the Mockpolygonrollupmanager contract. +type MockpolygonrollupmanagerEmergencyStateDeactivated struct { + Raw types.Log // Blockchain specific contextual infos +} + +// FilterEmergencyStateDeactivated is a free log retrieval operation binding the contract event 0x1e5e34eea33501aecf2ebec9fe0e884a40804275ea7fe10b2ba084c8374308b3. +// +// Solidity: event EmergencyStateDeactivated() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) FilterEmergencyStateDeactivated(opts *bind.FilterOpts) (*MockpolygonrollupmanagerEmergencyStateDeactivatedIterator, error) { + + logs, sub, err := _Mockpolygonrollupmanager.contract.FilterLogs(opts, "EmergencyStateDeactivated") + if err != nil { + return nil, err + } + return &MockpolygonrollupmanagerEmergencyStateDeactivatedIterator{contract: _Mockpolygonrollupmanager.contract, event: "EmergencyStateDeactivated", logs: logs, sub: sub}, nil +} + +// WatchEmergencyStateDeactivated is a free log subscription operation binding the contract event 0x1e5e34eea33501aecf2ebec9fe0e884a40804275ea7fe10b2ba084c8374308b3. +// +// Solidity: event EmergencyStateDeactivated() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) WatchEmergencyStateDeactivated(opts *bind.WatchOpts, sink chan<- *MockpolygonrollupmanagerEmergencyStateDeactivated) (event.Subscription, error) { + + logs, sub, err := _Mockpolygonrollupmanager.contract.WatchLogs(opts, "EmergencyStateDeactivated") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(MockpolygonrollupmanagerEmergencyStateDeactivated) + if err := _Mockpolygonrollupmanager.contract.UnpackLog(event, "EmergencyStateDeactivated", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseEmergencyStateDeactivated is a log parse operation binding the contract event 0x1e5e34eea33501aecf2ebec9fe0e884a40804275ea7fe10b2ba084c8374308b3. +// +// Solidity: event EmergencyStateDeactivated() +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) ParseEmergencyStateDeactivated(log types.Log) (*MockpolygonrollupmanagerEmergencyStateDeactivated, error) { + event := new(MockpolygonrollupmanagerEmergencyStateDeactivated) + if err := _Mockpolygonrollupmanager.contract.UnpackLog(event, "EmergencyStateDeactivated", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// MockpolygonrollupmanagerInitializedIterator is returned from FilterInitialized and is used to iterate over the raw logs and unpacked data for Initialized events raised by the Mockpolygonrollupmanager contract. +type MockpolygonrollupmanagerInitializedIterator struct { + Event *MockpolygonrollupmanagerInitialized // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *MockpolygonrollupmanagerInitializedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(MockpolygonrollupmanagerInitialized) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(MockpolygonrollupmanagerInitialized) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *MockpolygonrollupmanagerInitializedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *MockpolygonrollupmanagerInitializedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// MockpolygonrollupmanagerInitialized represents a Initialized event raised by the Mockpolygonrollupmanager contract. +type MockpolygonrollupmanagerInitialized struct { + Version uint8 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterInitialized is a free log retrieval operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) FilterInitialized(opts *bind.FilterOpts) (*MockpolygonrollupmanagerInitializedIterator, error) { + + logs, sub, err := _Mockpolygonrollupmanager.contract.FilterLogs(opts, "Initialized") + if err != nil { + return nil, err + } + return &MockpolygonrollupmanagerInitializedIterator{contract: _Mockpolygonrollupmanager.contract, event: "Initialized", logs: logs, sub: sub}, nil +} + +// WatchInitialized is a free log subscription operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *MockpolygonrollupmanagerInitialized) (event.Subscription, error) { + + logs, sub, err := _Mockpolygonrollupmanager.contract.WatchLogs(opts, "Initialized") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(MockpolygonrollupmanagerInitialized) + if err := _Mockpolygonrollupmanager.contract.UnpackLog(event, "Initialized", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseInitialized is a log parse operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) ParseInitialized(log types.Log) (*MockpolygonrollupmanagerInitialized, error) { + event := new(MockpolygonrollupmanagerInitialized) + if err := _Mockpolygonrollupmanager.contract.UnpackLog(event, "Initialized", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// MockpolygonrollupmanagerObsoleteRollupTypeIterator is returned from FilterObsoleteRollupType and is used to iterate over the raw logs and unpacked data for ObsoleteRollupType events raised by the Mockpolygonrollupmanager contract. +type MockpolygonrollupmanagerObsoleteRollupTypeIterator struct { + Event *MockpolygonrollupmanagerObsoleteRollupType // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *MockpolygonrollupmanagerObsoleteRollupTypeIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(MockpolygonrollupmanagerObsoleteRollupType) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(MockpolygonrollupmanagerObsoleteRollupType) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *MockpolygonrollupmanagerObsoleteRollupTypeIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *MockpolygonrollupmanagerObsoleteRollupTypeIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// MockpolygonrollupmanagerObsoleteRollupType represents a ObsoleteRollupType event raised by the Mockpolygonrollupmanager contract. +type MockpolygonrollupmanagerObsoleteRollupType struct { + RollupTypeID uint32 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterObsoleteRollupType is a free log retrieval operation binding the contract event 0x4710d2ee567ef1ed6eb2f651dde4589524bcf7cebc62147a99b281cc836e7e44. +// +// Solidity: event ObsoleteRollupType(uint32 indexed rollupTypeID) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) FilterObsoleteRollupType(opts *bind.FilterOpts, rollupTypeID []uint32) (*MockpolygonrollupmanagerObsoleteRollupTypeIterator, error) { + + var rollupTypeIDRule []interface{} + for _, rollupTypeIDItem := range rollupTypeID { + rollupTypeIDRule = append(rollupTypeIDRule, rollupTypeIDItem) + } + + logs, sub, err := _Mockpolygonrollupmanager.contract.FilterLogs(opts, "ObsoleteRollupType", rollupTypeIDRule) + if err != nil { + return nil, err + } + return &MockpolygonrollupmanagerObsoleteRollupTypeIterator{contract: _Mockpolygonrollupmanager.contract, event: "ObsoleteRollupType", logs: logs, sub: sub}, nil +} + +// WatchObsoleteRollupType is a free log subscription operation binding the contract event 0x4710d2ee567ef1ed6eb2f651dde4589524bcf7cebc62147a99b281cc836e7e44. +// +// Solidity: event ObsoleteRollupType(uint32 indexed rollupTypeID) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) WatchObsoleteRollupType(opts *bind.WatchOpts, sink chan<- *MockpolygonrollupmanagerObsoleteRollupType, rollupTypeID []uint32) (event.Subscription, error) { + + var rollupTypeIDRule []interface{} + for _, rollupTypeIDItem := range rollupTypeID { + rollupTypeIDRule = append(rollupTypeIDRule, rollupTypeIDItem) + } + + logs, sub, err := _Mockpolygonrollupmanager.contract.WatchLogs(opts, "ObsoleteRollupType", rollupTypeIDRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(MockpolygonrollupmanagerObsoleteRollupType) + if err := _Mockpolygonrollupmanager.contract.UnpackLog(event, "ObsoleteRollupType", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseObsoleteRollupType is a log parse operation binding the contract event 0x4710d2ee567ef1ed6eb2f651dde4589524bcf7cebc62147a99b281cc836e7e44. +// +// Solidity: event ObsoleteRollupType(uint32 indexed rollupTypeID) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) ParseObsoleteRollupType(log types.Log) (*MockpolygonrollupmanagerObsoleteRollupType, error) { + event := new(MockpolygonrollupmanagerObsoleteRollupType) + if err := _Mockpolygonrollupmanager.contract.UnpackLog(event, "ObsoleteRollupType", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// MockpolygonrollupmanagerOnSequenceBatchesIterator is returned from FilterOnSequenceBatches and is used to iterate over the raw logs and unpacked data for OnSequenceBatches events raised by the Mockpolygonrollupmanager contract. +type MockpolygonrollupmanagerOnSequenceBatchesIterator struct { + Event *MockpolygonrollupmanagerOnSequenceBatches // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *MockpolygonrollupmanagerOnSequenceBatchesIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(MockpolygonrollupmanagerOnSequenceBatches) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(MockpolygonrollupmanagerOnSequenceBatches) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *MockpolygonrollupmanagerOnSequenceBatchesIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *MockpolygonrollupmanagerOnSequenceBatchesIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// MockpolygonrollupmanagerOnSequenceBatches represents a OnSequenceBatches event raised by the Mockpolygonrollupmanager contract. +type MockpolygonrollupmanagerOnSequenceBatches struct { + RollupID uint32 + LastBatchSequenced uint64 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterOnSequenceBatches is a free log retrieval operation binding the contract event 0x1d9f30260051d51d70339da239ea7b080021adcaabfa71c9b0ea339a20cf9a25. +// +// Solidity: event OnSequenceBatches(uint32 indexed rollupID, uint64 lastBatchSequenced) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) FilterOnSequenceBatches(opts *bind.FilterOpts, rollupID []uint32) (*MockpolygonrollupmanagerOnSequenceBatchesIterator, error) { + + var rollupIDRule []interface{} + for _, rollupIDItem := range rollupID { + rollupIDRule = append(rollupIDRule, rollupIDItem) + } + + logs, sub, err := _Mockpolygonrollupmanager.contract.FilterLogs(opts, "OnSequenceBatches", rollupIDRule) + if err != nil { + return nil, err + } + return &MockpolygonrollupmanagerOnSequenceBatchesIterator{contract: _Mockpolygonrollupmanager.contract, event: "OnSequenceBatches", logs: logs, sub: sub}, nil +} + +// WatchOnSequenceBatches is a free log subscription operation binding the contract event 0x1d9f30260051d51d70339da239ea7b080021adcaabfa71c9b0ea339a20cf9a25. +// +// Solidity: event OnSequenceBatches(uint32 indexed rollupID, uint64 lastBatchSequenced) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) WatchOnSequenceBatches(opts *bind.WatchOpts, sink chan<- *MockpolygonrollupmanagerOnSequenceBatches, rollupID []uint32) (event.Subscription, error) { + + var rollupIDRule []interface{} + for _, rollupIDItem := range rollupID { + rollupIDRule = append(rollupIDRule, rollupIDItem) + } + + logs, sub, err := _Mockpolygonrollupmanager.contract.WatchLogs(opts, "OnSequenceBatches", rollupIDRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(MockpolygonrollupmanagerOnSequenceBatches) + if err := _Mockpolygonrollupmanager.contract.UnpackLog(event, "OnSequenceBatches", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseOnSequenceBatches is a log parse operation binding the contract event 0x1d9f30260051d51d70339da239ea7b080021adcaabfa71c9b0ea339a20cf9a25. +// +// Solidity: event OnSequenceBatches(uint32 indexed rollupID, uint64 lastBatchSequenced) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) ParseOnSequenceBatches(log types.Log) (*MockpolygonrollupmanagerOnSequenceBatches, error) { + event := new(MockpolygonrollupmanagerOnSequenceBatches) + if err := _Mockpolygonrollupmanager.contract.UnpackLog(event, "OnSequenceBatches", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// MockpolygonrollupmanagerOverridePendingStateIterator is returned from FilterOverridePendingState and is used to iterate over the raw logs and unpacked data for OverridePendingState events raised by the Mockpolygonrollupmanager contract. +type MockpolygonrollupmanagerOverridePendingStateIterator struct { + Event *MockpolygonrollupmanagerOverridePendingState // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *MockpolygonrollupmanagerOverridePendingStateIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(MockpolygonrollupmanagerOverridePendingState) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(MockpolygonrollupmanagerOverridePendingState) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *MockpolygonrollupmanagerOverridePendingStateIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *MockpolygonrollupmanagerOverridePendingStateIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// MockpolygonrollupmanagerOverridePendingState represents a OverridePendingState event raised by the Mockpolygonrollupmanager contract. +type MockpolygonrollupmanagerOverridePendingState struct { + RollupID uint32 + NumBatch uint64 + StateRoot [32]byte + ExitRoot [32]byte + Aggregator common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterOverridePendingState is a free log retrieval operation binding the contract event 0x3182bd6e6f74fc1fdc88b60f3a4f4c7f79db6ae6f5b88a1b3f5a1e28ec210d5e. +// +// Solidity: event OverridePendingState(uint32 indexed rollupID, uint64 numBatch, bytes32 stateRoot, bytes32 exitRoot, address aggregator) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) FilterOverridePendingState(opts *bind.FilterOpts, rollupID []uint32) (*MockpolygonrollupmanagerOverridePendingStateIterator, error) { + + var rollupIDRule []interface{} + for _, rollupIDItem := range rollupID { + rollupIDRule = append(rollupIDRule, rollupIDItem) + } + + logs, sub, err := _Mockpolygonrollupmanager.contract.FilterLogs(opts, "OverridePendingState", rollupIDRule) + if err != nil { + return nil, err + } + return &MockpolygonrollupmanagerOverridePendingStateIterator{contract: _Mockpolygonrollupmanager.contract, event: "OverridePendingState", logs: logs, sub: sub}, nil +} + +// WatchOverridePendingState is a free log subscription operation binding the contract event 0x3182bd6e6f74fc1fdc88b60f3a4f4c7f79db6ae6f5b88a1b3f5a1e28ec210d5e. +// +// Solidity: event OverridePendingState(uint32 indexed rollupID, uint64 numBatch, bytes32 stateRoot, bytes32 exitRoot, address aggregator) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) WatchOverridePendingState(opts *bind.WatchOpts, sink chan<- *MockpolygonrollupmanagerOverridePendingState, rollupID []uint32) (event.Subscription, error) { + + var rollupIDRule []interface{} + for _, rollupIDItem := range rollupID { + rollupIDRule = append(rollupIDRule, rollupIDItem) + } + + logs, sub, err := _Mockpolygonrollupmanager.contract.WatchLogs(opts, "OverridePendingState", rollupIDRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(MockpolygonrollupmanagerOverridePendingState) + if err := _Mockpolygonrollupmanager.contract.UnpackLog(event, "OverridePendingState", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseOverridePendingState is a log parse operation binding the contract event 0x3182bd6e6f74fc1fdc88b60f3a4f4c7f79db6ae6f5b88a1b3f5a1e28ec210d5e. +// +// Solidity: event OverridePendingState(uint32 indexed rollupID, uint64 numBatch, bytes32 stateRoot, bytes32 exitRoot, address aggregator) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) ParseOverridePendingState(log types.Log) (*MockpolygonrollupmanagerOverridePendingState, error) { + event := new(MockpolygonrollupmanagerOverridePendingState) + if err := _Mockpolygonrollupmanager.contract.UnpackLog(event, "OverridePendingState", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// MockpolygonrollupmanagerProveNonDeterministicPendingStateIterator is returned from FilterProveNonDeterministicPendingState and is used to iterate over the raw logs and unpacked data for ProveNonDeterministicPendingState events raised by the Mockpolygonrollupmanager contract. +type MockpolygonrollupmanagerProveNonDeterministicPendingStateIterator struct { + Event *MockpolygonrollupmanagerProveNonDeterministicPendingState // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *MockpolygonrollupmanagerProveNonDeterministicPendingStateIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(MockpolygonrollupmanagerProveNonDeterministicPendingState) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(MockpolygonrollupmanagerProveNonDeterministicPendingState) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *MockpolygonrollupmanagerProveNonDeterministicPendingStateIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *MockpolygonrollupmanagerProveNonDeterministicPendingStateIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// MockpolygonrollupmanagerProveNonDeterministicPendingState represents a ProveNonDeterministicPendingState event raised by the Mockpolygonrollupmanager contract. +type MockpolygonrollupmanagerProveNonDeterministicPendingState struct { + StoredStateRoot [32]byte + ProvedStateRoot [32]byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterProveNonDeterministicPendingState is a free log retrieval operation binding the contract event 0x1f44c21118c4603cfb4e1b621dbcfa2b73efcececee2b99b620b2953d33a7010. +// +// Solidity: event ProveNonDeterministicPendingState(bytes32 storedStateRoot, bytes32 provedStateRoot) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) FilterProveNonDeterministicPendingState(opts *bind.FilterOpts) (*MockpolygonrollupmanagerProveNonDeterministicPendingStateIterator, error) { + + logs, sub, err := _Mockpolygonrollupmanager.contract.FilterLogs(opts, "ProveNonDeterministicPendingState") + if err != nil { + return nil, err + } + return &MockpolygonrollupmanagerProveNonDeterministicPendingStateIterator{contract: _Mockpolygonrollupmanager.contract, event: "ProveNonDeterministicPendingState", logs: logs, sub: sub}, nil +} + +// WatchProveNonDeterministicPendingState is a free log subscription operation binding the contract event 0x1f44c21118c4603cfb4e1b621dbcfa2b73efcececee2b99b620b2953d33a7010. +// +// Solidity: event ProveNonDeterministicPendingState(bytes32 storedStateRoot, bytes32 provedStateRoot) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) WatchProveNonDeterministicPendingState(opts *bind.WatchOpts, sink chan<- *MockpolygonrollupmanagerProveNonDeterministicPendingState) (event.Subscription, error) { + + logs, sub, err := _Mockpolygonrollupmanager.contract.WatchLogs(opts, "ProveNonDeterministicPendingState") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(MockpolygonrollupmanagerProveNonDeterministicPendingState) + if err := _Mockpolygonrollupmanager.contract.UnpackLog(event, "ProveNonDeterministicPendingState", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseProveNonDeterministicPendingState is a log parse operation binding the contract event 0x1f44c21118c4603cfb4e1b621dbcfa2b73efcececee2b99b620b2953d33a7010. +// +// Solidity: event ProveNonDeterministicPendingState(bytes32 storedStateRoot, bytes32 provedStateRoot) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) ParseProveNonDeterministicPendingState(log types.Log) (*MockpolygonrollupmanagerProveNonDeterministicPendingState, error) { + event := new(MockpolygonrollupmanagerProveNonDeterministicPendingState) + if err := _Mockpolygonrollupmanager.contract.UnpackLog(event, "ProveNonDeterministicPendingState", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// MockpolygonrollupmanagerRoleAdminChangedIterator is returned from FilterRoleAdminChanged and is used to iterate over the raw logs and unpacked data for RoleAdminChanged events raised by the Mockpolygonrollupmanager contract. +type MockpolygonrollupmanagerRoleAdminChangedIterator struct { + Event *MockpolygonrollupmanagerRoleAdminChanged // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *MockpolygonrollupmanagerRoleAdminChangedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(MockpolygonrollupmanagerRoleAdminChanged) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(MockpolygonrollupmanagerRoleAdminChanged) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *MockpolygonrollupmanagerRoleAdminChangedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *MockpolygonrollupmanagerRoleAdminChangedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// MockpolygonrollupmanagerRoleAdminChanged represents a RoleAdminChanged event raised by the Mockpolygonrollupmanager contract. +type MockpolygonrollupmanagerRoleAdminChanged struct { + Role [32]byte + PreviousAdminRole [32]byte + NewAdminRole [32]byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterRoleAdminChanged is a free log retrieval operation binding the contract event 0xbd79b86ffe0ab8e8776151514217cd7cacd52c909f66475c3af44e129f0b00ff. +// +// Solidity: event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) FilterRoleAdminChanged(opts *bind.FilterOpts, role [][32]byte, previousAdminRole [][32]byte, newAdminRole [][32]byte) (*MockpolygonrollupmanagerRoleAdminChangedIterator, error) { + + var roleRule []interface{} + for _, roleItem := range role { + roleRule = append(roleRule, roleItem) + } + var previousAdminRoleRule []interface{} + for _, previousAdminRoleItem := range previousAdminRole { + previousAdminRoleRule = append(previousAdminRoleRule, previousAdminRoleItem) + } + var newAdminRoleRule []interface{} + for _, newAdminRoleItem := range newAdminRole { + newAdminRoleRule = append(newAdminRoleRule, newAdminRoleItem) + } + + logs, sub, err := _Mockpolygonrollupmanager.contract.FilterLogs(opts, "RoleAdminChanged", roleRule, previousAdminRoleRule, newAdminRoleRule) + if err != nil { + return nil, err + } + return &MockpolygonrollupmanagerRoleAdminChangedIterator{contract: _Mockpolygonrollupmanager.contract, event: "RoleAdminChanged", logs: logs, sub: sub}, nil +} + +// WatchRoleAdminChanged is a free log subscription operation binding the contract event 0xbd79b86ffe0ab8e8776151514217cd7cacd52c909f66475c3af44e129f0b00ff. +// +// Solidity: event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) WatchRoleAdminChanged(opts *bind.WatchOpts, sink chan<- *MockpolygonrollupmanagerRoleAdminChanged, role [][32]byte, previousAdminRole [][32]byte, newAdminRole [][32]byte) (event.Subscription, error) { + + var roleRule []interface{} + for _, roleItem := range role { + roleRule = append(roleRule, roleItem) + } + var previousAdminRoleRule []interface{} + for _, previousAdminRoleItem := range previousAdminRole { + previousAdminRoleRule = append(previousAdminRoleRule, previousAdminRoleItem) + } + var newAdminRoleRule []interface{} + for _, newAdminRoleItem := range newAdminRole { + newAdminRoleRule = append(newAdminRoleRule, newAdminRoleItem) + } + + logs, sub, err := _Mockpolygonrollupmanager.contract.WatchLogs(opts, "RoleAdminChanged", roleRule, previousAdminRoleRule, newAdminRoleRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(MockpolygonrollupmanagerRoleAdminChanged) + if err := _Mockpolygonrollupmanager.contract.UnpackLog(event, "RoleAdminChanged", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseRoleAdminChanged is a log parse operation binding the contract event 0xbd79b86ffe0ab8e8776151514217cd7cacd52c909f66475c3af44e129f0b00ff. +// +// Solidity: event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) ParseRoleAdminChanged(log types.Log) (*MockpolygonrollupmanagerRoleAdminChanged, error) { + event := new(MockpolygonrollupmanagerRoleAdminChanged) + if err := _Mockpolygonrollupmanager.contract.UnpackLog(event, "RoleAdminChanged", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// MockpolygonrollupmanagerRoleGrantedIterator is returned from FilterRoleGranted and is used to iterate over the raw logs and unpacked data for RoleGranted events raised by the Mockpolygonrollupmanager contract. +type MockpolygonrollupmanagerRoleGrantedIterator struct { + Event *MockpolygonrollupmanagerRoleGranted // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *MockpolygonrollupmanagerRoleGrantedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(MockpolygonrollupmanagerRoleGranted) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(MockpolygonrollupmanagerRoleGranted) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *MockpolygonrollupmanagerRoleGrantedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *MockpolygonrollupmanagerRoleGrantedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// MockpolygonrollupmanagerRoleGranted represents a RoleGranted event raised by the Mockpolygonrollupmanager contract. +type MockpolygonrollupmanagerRoleGranted struct { + Role [32]byte + Account common.Address + Sender common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterRoleGranted is a free log retrieval operation binding the contract event 0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d. +// +// Solidity: event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) FilterRoleGranted(opts *bind.FilterOpts, role [][32]byte, account []common.Address, sender []common.Address) (*MockpolygonrollupmanagerRoleGrantedIterator, error) { + + var roleRule []interface{} + for _, roleItem := range role { + roleRule = append(roleRule, roleItem) + } + var accountRule []interface{} + for _, accountItem := range account { + accountRule = append(accountRule, accountItem) + } + var senderRule []interface{} + for _, senderItem := range sender { + senderRule = append(senderRule, senderItem) + } + + logs, sub, err := _Mockpolygonrollupmanager.contract.FilterLogs(opts, "RoleGranted", roleRule, accountRule, senderRule) + if err != nil { + return nil, err + } + return &MockpolygonrollupmanagerRoleGrantedIterator{contract: _Mockpolygonrollupmanager.contract, event: "RoleGranted", logs: logs, sub: sub}, nil +} + +// WatchRoleGranted is a free log subscription operation binding the contract event 0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d. +// +// Solidity: event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) WatchRoleGranted(opts *bind.WatchOpts, sink chan<- *MockpolygonrollupmanagerRoleGranted, role [][32]byte, account []common.Address, sender []common.Address) (event.Subscription, error) { + + var roleRule []interface{} + for _, roleItem := range role { + roleRule = append(roleRule, roleItem) + } + var accountRule []interface{} + for _, accountItem := range account { + accountRule = append(accountRule, accountItem) + } + var senderRule []interface{} + for _, senderItem := range sender { + senderRule = append(senderRule, senderItem) + } + + logs, sub, err := _Mockpolygonrollupmanager.contract.WatchLogs(opts, "RoleGranted", roleRule, accountRule, senderRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(MockpolygonrollupmanagerRoleGranted) + if err := _Mockpolygonrollupmanager.contract.UnpackLog(event, "RoleGranted", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseRoleGranted is a log parse operation binding the contract event 0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d. +// +// Solidity: event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) ParseRoleGranted(log types.Log) (*MockpolygonrollupmanagerRoleGranted, error) { + event := new(MockpolygonrollupmanagerRoleGranted) + if err := _Mockpolygonrollupmanager.contract.UnpackLog(event, "RoleGranted", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// MockpolygonrollupmanagerRoleRevokedIterator is returned from FilterRoleRevoked and is used to iterate over the raw logs and unpacked data for RoleRevoked events raised by the Mockpolygonrollupmanager contract. +type MockpolygonrollupmanagerRoleRevokedIterator struct { + Event *MockpolygonrollupmanagerRoleRevoked // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *MockpolygonrollupmanagerRoleRevokedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(MockpolygonrollupmanagerRoleRevoked) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(MockpolygonrollupmanagerRoleRevoked) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *MockpolygonrollupmanagerRoleRevokedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *MockpolygonrollupmanagerRoleRevokedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// MockpolygonrollupmanagerRoleRevoked represents a RoleRevoked event raised by the Mockpolygonrollupmanager contract. +type MockpolygonrollupmanagerRoleRevoked struct { + Role [32]byte + Account common.Address + Sender common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterRoleRevoked is a free log retrieval operation binding the contract event 0xf6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b. +// +// Solidity: event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) FilterRoleRevoked(opts *bind.FilterOpts, role [][32]byte, account []common.Address, sender []common.Address) (*MockpolygonrollupmanagerRoleRevokedIterator, error) { + + var roleRule []interface{} + for _, roleItem := range role { + roleRule = append(roleRule, roleItem) + } + var accountRule []interface{} + for _, accountItem := range account { + accountRule = append(accountRule, accountItem) + } + var senderRule []interface{} + for _, senderItem := range sender { + senderRule = append(senderRule, senderItem) + } + + logs, sub, err := _Mockpolygonrollupmanager.contract.FilterLogs(opts, "RoleRevoked", roleRule, accountRule, senderRule) + if err != nil { + return nil, err + } + return &MockpolygonrollupmanagerRoleRevokedIterator{contract: _Mockpolygonrollupmanager.contract, event: "RoleRevoked", logs: logs, sub: sub}, nil +} + +// WatchRoleRevoked is a free log subscription operation binding the contract event 0xf6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b. +// +// Solidity: event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) WatchRoleRevoked(opts *bind.WatchOpts, sink chan<- *MockpolygonrollupmanagerRoleRevoked, role [][32]byte, account []common.Address, sender []common.Address) (event.Subscription, error) { + + var roleRule []interface{} + for _, roleItem := range role { + roleRule = append(roleRule, roleItem) + } + var accountRule []interface{} + for _, accountItem := range account { + accountRule = append(accountRule, accountItem) + } + var senderRule []interface{} + for _, senderItem := range sender { + senderRule = append(senderRule, senderItem) + } + + logs, sub, err := _Mockpolygonrollupmanager.contract.WatchLogs(opts, "RoleRevoked", roleRule, accountRule, senderRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(MockpolygonrollupmanagerRoleRevoked) + if err := _Mockpolygonrollupmanager.contract.UnpackLog(event, "RoleRevoked", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseRoleRevoked is a log parse operation binding the contract event 0xf6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b. +// +// Solidity: event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) ParseRoleRevoked(log types.Log) (*MockpolygonrollupmanagerRoleRevoked, error) { + event := new(MockpolygonrollupmanagerRoleRevoked) + if err := _Mockpolygonrollupmanager.contract.UnpackLog(event, "RoleRevoked", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// MockpolygonrollupmanagerSetBatchFeeIterator is returned from FilterSetBatchFee and is used to iterate over the raw logs and unpacked data for SetBatchFee events raised by the Mockpolygonrollupmanager contract. +type MockpolygonrollupmanagerSetBatchFeeIterator struct { + Event *MockpolygonrollupmanagerSetBatchFee // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *MockpolygonrollupmanagerSetBatchFeeIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(MockpolygonrollupmanagerSetBatchFee) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(MockpolygonrollupmanagerSetBatchFee) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *MockpolygonrollupmanagerSetBatchFeeIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *MockpolygonrollupmanagerSetBatchFeeIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// MockpolygonrollupmanagerSetBatchFee represents a SetBatchFee event raised by the Mockpolygonrollupmanager contract. +type MockpolygonrollupmanagerSetBatchFee struct { + NewBatchFee *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterSetBatchFee is a free log retrieval operation binding the contract event 0xfb383653f53ee079978d0c9aff7aeff04a10166ce244cca9c9f9d8d96bed45b2. +// +// Solidity: event SetBatchFee(uint256 newBatchFee) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) FilterSetBatchFee(opts *bind.FilterOpts) (*MockpolygonrollupmanagerSetBatchFeeIterator, error) { + + logs, sub, err := _Mockpolygonrollupmanager.contract.FilterLogs(opts, "SetBatchFee") + if err != nil { + return nil, err + } + return &MockpolygonrollupmanagerSetBatchFeeIterator{contract: _Mockpolygonrollupmanager.contract, event: "SetBatchFee", logs: logs, sub: sub}, nil +} + +// WatchSetBatchFee is a free log subscription operation binding the contract event 0xfb383653f53ee079978d0c9aff7aeff04a10166ce244cca9c9f9d8d96bed45b2. +// +// Solidity: event SetBatchFee(uint256 newBatchFee) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) WatchSetBatchFee(opts *bind.WatchOpts, sink chan<- *MockpolygonrollupmanagerSetBatchFee) (event.Subscription, error) { + + logs, sub, err := _Mockpolygonrollupmanager.contract.WatchLogs(opts, "SetBatchFee") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(MockpolygonrollupmanagerSetBatchFee) + if err := _Mockpolygonrollupmanager.contract.UnpackLog(event, "SetBatchFee", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseSetBatchFee is a log parse operation binding the contract event 0xfb383653f53ee079978d0c9aff7aeff04a10166ce244cca9c9f9d8d96bed45b2. +// +// Solidity: event SetBatchFee(uint256 newBatchFee) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) ParseSetBatchFee(log types.Log) (*MockpolygonrollupmanagerSetBatchFee, error) { + event := new(MockpolygonrollupmanagerSetBatchFee) + if err := _Mockpolygonrollupmanager.contract.UnpackLog(event, "SetBatchFee", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// MockpolygonrollupmanagerSetMultiplierBatchFeeIterator is returned from FilterSetMultiplierBatchFee and is used to iterate over the raw logs and unpacked data for SetMultiplierBatchFee events raised by the Mockpolygonrollupmanager contract. +type MockpolygonrollupmanagerSetMultiplierBatchFeeIterator struct { + Event *MockpolygonrollupmanagerSetMultiplierBatchFee // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *MockpolygonrollupmanagerSetMultiplierBatchFeeIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(MockpolygonrollupmanagerSetMultiplierBatchFee) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(MockpolygonrollupmanagerSetMultiplierBatchFee) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *MockpolygonrollupmanagerSetMultiplierBatchFeeIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *MockpolygonrollupmanagerSetMultiplierBatchFeeIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// MockpolygonrollupmanagerSetMultiplierBatchFee represents a SetMultiplierBatchFee event raised by the Mockpolygonrollupmanager contract. +type MockpolygonrollupmanagerSetMultiplierBatchFee struct { + NewMultiplierBatchFee uint16 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterSetMultiplierBatchFee is a free log retrieval operation binding the contract event 0x7019933d795eba185c180209e8ae8bffbaa25bcef293364687702c31f4d302c5. +// +// Solidity: event SetMultiplierBatchFee(uint16 newMultiplierBatchFee) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) FilterSetMultiplierBatchFee(opts *bind.FilterOpts) (*MockpolygonrollupmanagerSetMultiplierBatchFeeIterator, error) { + + logs, sub, err := _Mockpolygonrollupmanager.contract.FilterLogs(opts, "SetMultiplierBatchFee") + if err != nil { + return nil, err + } + return &MockpolygonrollupmanagerSetMultiplierBatchFeeIterator{contract: _Mockpolygonrollupmanager.contract, event: "SetMultiplierBatchFee", logs: logs, sub: sub}, nil +} + +// WatchSetMultiplierBatchFee is a free log subscription operation binding the contract event 0x7019933d795eba185c180209e8ae8bffbaa25bcef293364687702c31f4d302c5. +// +// Solidity: event SetMultiplierBatchFee(uint16 newMultiplierBatchFee) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) WatchSetMultiplierBatchFee(opts *bind.WatchOpts, sink chan<- *MockpolygonrollupmanagerSetMultiplierBatchFee) (event.Subscription, error) { + + logs, sub, err := _Mockpolygonrollupmanager.contract.WatchLogs(opts, "SetMultiplierBatchFee") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(MockpolygonrollupmanagerSetMultiplierBatchFee) + if err := _Mockpolygonrollupmanager.contract.UnpackLog(event, "SetMultiplierBatchFee", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseSetMultiplierBatchFee is a log parse operation binding the contract event 0x7019933d795eba185c180209e8ae8bffbaa25bcef293364687702c31f4d302c5. +// +// Solidity: event SetMultiplierBatchFee(uint16 newMultiplierBatchFee) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) ParseSetMultiplierBatchFee(log types.Log) (*MockpolygonrollupmanagerSetMultiplierBatchFee, error) { + event := new(MockpolygonrollupmanagerSetMultiplierBatchFee) + if err := _Mockpolygonrollupmanager.contract.UnpackLog(event, "SetMultiplierBatchFee", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// MockpolygonrollupmanagerSetPendingStateTimeoutIterator is returned from FilterSetPendingStateTimeout and is used to iterate over the raw logs and unpacked data for SetPendingStateTimeout events raised by the Mockpolygonrollupmanager contract. +type MockpolygonrollupmanagerSetPendingStateTimeoutIterator struct { + Event *MockpolygonrollupmanagerSetPendingStateTimeout // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *MockpolygonrollupmanagerSetPendingStateTimeoutIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(MockpolygonrollupmanagerSetPendingStateTimeout) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(MockpolygonrollupmanagerSetPendingStateTimeout) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *MockpolygonrollupmanagerSetPendingStateTimeoutIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *MockpolygonrollupmanagerSetPendingStateTimeoutIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// MockpolygonrollupmanagerSetPendingStateTimeout represents a SetPendingStateTimeout event raised by the Mockpolygonrollupmanager contract. +type MockpolygonrollupmanagerSetPendingStateTimeout struct { + NewPendingStateTimeout uint64 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterSetPendingStateTimeout is a free log retrieval operation binding the contract event 0xc4121f4e22c69632ebb7cf1f462be0511dc034f999b52013eddfb24aab765c75. +// +// Solidity: event SetPendingStateTimeout(uint64 newPendingStateTimeout) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) FilterSetPendingStateTimeout(opts *bind.FilterOpts) (*MockpolygonrollupmanagerSetPendingStateTimeoutIterator, error) { + + logs, sub, err := _Mockpolygonrollupmanager.contract.FilterLogs(opts, "SetPendingStateTimeout") + if err != nil { + return nil, err + } + return &MockpolygonrollupmanagerSetPendingStateTimeoutIterator{contract: _Mockpolygonrollupmanager.contract, event: "SetPendingStateTimeout", logs: logs, sub: sub}, nil +} + +// WatchSetPendingStateTimeout is a free log subscription operation binding the contract event 0xc4121f4e22c69632ebb7cf1f462be0511dc034f999b52013eddfb24aab765c75. +// +// Solidity: event SetPendingStateTimeout(uint64 newPendingStateTimeout) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) WatchSetPendingStateTimeout(opts *bind.WatchOpts, sink chan<- *MockpolygonrollupmanagerSetPendingStateTimeout) (event.Subscription, error) { + + logs, sub, err := _Mockpolygonrollupmanager.contract.WatchLogs(opts, "SetPendingStateTimeout") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(MockpolygonrollupmanagerSetPendingStateTimeout) + if err := _Mockpolygonrollupmanager.contract.UnpackLog(event, "SetPendingStateTimeout", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseSetPendingStateTimeout is a log parse operation binding the contract event 0xc4121f4e22c69632ebb7cf1f462be0511dc034f999b52013eddfb24aab765c75. +// +// Solidity: event SetPendingStateTimeout(uint64 newPendingStateTimeout) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) ParseSetPendingStateTimeout(log types.Log) (*MockpolygonrollupmanagerSetPendingStateTimeout, error) { + event := new(MockpolygonrollupmanagerSetPendingStateTimeout) + if err := _Mockpolygonrollupmanager.contract.UnpackLog(event, "SetPendingStateTimeout", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// MockpolygonrollupmanagerSetTrustedAggregatorIterator is returned from FilterSetTrustedAggregator and is used to iterate over the raw logs and unpacked data for SetTrustedAggregator events raised by the Mockpolygonrollupmanager contract. +type MockpolygonrollupmanagerSetTrustedAggregatorIterator struct { + Event *MockpolygonrollupmanagerSetTrustedAggregator // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *MockpolygonrollupmanagerSetTrustedAggregatorIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(MockpolygonrollupmanagerSetTrustedAggregator) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(MockpolygonrollupmanagerSetTrustedAggregator) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *MockpolygonrollupmanagerSetTrustedAggregatorIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *MockpolygonrollupmanagerSetTrustedAggregatorIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// MockpolygonrollupmanagerSetTrustedAggregator represents a SetTrustedAggregator event raised by the Mockpolygonrollupmanager contract. +type MockpolygonrollupmanagerSetTrustedAggregator struct { + NewTrustedAggregator common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterSetTrustedAggregator is a free log retrieval operation binding the contract event 0x61f8fec29495a3078e9271456f05fb0707fd4e41f7661865f80fc437d06681ca. +// +// Solidity: event SetTrustedAggregator(address newTrustedAggregator) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) FilterSetTrustedAggregator(opts *bind.FilterOpts) (*MockpolygonrollupmanagerSetTrustedAggregatorIterator, error) { + + logs, sub, err := _Mockpolygonrollupmanager.contract.FilterLogs(opts, "SetTrustedAggregator") + if err != nil { + return nil, err + } + return &MockpolygonrollupmanagerSetTrustedAggregatorIterator{contract: _Mockpolygonrollupmanager.contract, event: "SetTrustedAggregator", logs: logs, sub: sub}, nil +} + +// WatchSetTrustedAggregator is a free log subscription operation binding the contract event 0x61f8fec29495a3078e9271456f05fb0707fd4e41f7661865f80fc437d06681ca. +// +// Solidity: event SetTrustedAggregator(address newTrustedAggregator) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) WatchSetTrustedAggregator(opts *bind.WatchOpts, sink chan<- *MockpolygonrollupmanagerSetTrustedAggregator) (event.Subscription, error) { + + logs, sub, err := _Mockpolygonrollupmanager.contract.WatchLogs(opts, "SetTrustedAggregator") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(MockpolygonrollupmanagerSetTrustedAggregator) + if err := _Mockpolygonrollupmanager.contract.UnpackLog(event, "SetTrustedAggregator", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseSetTrustedAggregator is a log parse operation binding the contract event 0x61f8fec29495a3078e9271456f05fb0707fd4e41f7661865f80fc437d06681ca. +// +// Solidity: event SetTrustedAggregator(address newTrustedAggregator) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) ParseSetTrustedAggregator(log types.Log) (*MockpolygonrollupmanagerSetTrustedAggregator, error) { + event := new(MockpolygonrollupmanagerSetTrustedAggregator) + if err := _Mockpolygonrollupmanager.contract.UnpackLog(event, "SetTrustedAggregator", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// MockpolygonrollupmanagerSetTrustedAggregatorTimeoutIterator is returned from FilterSetTrustedAggregatorTimeout and is used to iterate over the raw logs and unpacked data for SetTrustedAggregatorTimeout events raised by the Mockpolygonrollupmanager contract. +type MockpolygonrollupmanagerSetTrustedAggregatorTimeoutIterator struct { + Event *MockpolygonrollupmanagerSetTrustedAggregatorTimeout // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *MockpolygonrollupmanagerSetTrustedAggregatorTimeoutIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(MockpolygonrollupmanagerSetTrustedAggregatorTimeout) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(MockpolygonrollupmanagerSetTrustedAggregatorTimeout) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *MockpolygonrollupmanagerSetTrustedAggregatorTimeoutIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *MockpolygonrollupmanagerSetTrustedAggregatorTimeoutIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// MockpolygonrollupmanagerSetTrustedAggregatorTimeout represents a SetTrustedAggregatorTimeout event raised by the Mockpolygonrollupmanager contract. +type MockpolygonrollupmanagerSetTrustedAggregatorTimeout struct { + NewTrustedAggregatorTimeout uint64 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterSetTrustedAggregatorTimeout is a free log retrieval operation binding the contract event 0x1f4fa24c2e4bad19a7f3ec5c5485f70d46c798461c2e684f55bbd0fc661373a1. +// +// Solidity: event SetTrustedAggregatorTimeout(uint64 newTrustedAggregatorTimeout) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) FilterSetTrustedAggregatorTimeout(opts *bind.FilterOpts) (*MockpolygonrollupmanagerSetTrustedAggregatorTimeoutIterator, error) { + + logs, sub, err := _Mockpolygonrollupmanager.contract.FilterLogs(opts, "SetTrustedAggregatorTimeout") + if err != nil { + return nil, err + } + return &MockpolygonrollupmanagerSetTrustedAggregatorTimeoutIterator{contract: _Mockpolygonrollupmanager.contract, event: "SetTrustedAggregatorTimeout", logs: logs, sub: sub}, nil +} + +// WatchSetTrustedAggregatorTimeout is a free log subscription operation binding the contract event 0x1f4fa24c2e4bad19a7f3ec5c5485f70d46c798461c2e684f55bbd0fc661373a1. +// +// Solidity: event SetTrustedAggregatorTimeout(uint64 newTrustedAggregatorTimeout) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) WatchSetTrustedAggregatorTimeout(opts *bind.WatchOpts, sink chan<- *MockpolygonrollupmanagerSetTrustedAggregatorTimeout) (event.Subscription, error) { + + logs, sub, err := _Mockpolygonrollupmanager.contract.WatchLogs(opts, "SetTrustedAggregatorTimeout") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(MockpolygonrollupmanagerSetTrustedAggregatorTimeout) + if err := _Mockpolygonrollupmanager.contract.UnpackLog(event, "SetTrustedAggregatorTimeout", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseSetTrustedAggregatorTimeout is a log parse operation binding the contract event 0x1f4fa24c2e4bad19a7f3ec5c5485f70d46c798461c2e684f55bbd0fc661373a1. +// +// Solidity: event SetTrustedAggregatorTimeout(uint64 newTrustedAggregatorTimeout) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) ParseSetTrustedAggregatorTimeout(log types.Log) (*MockpolygonrollupmanagerSetTrustedAggregatorTimeout, error) { + event := new(MockpolygonrollupmanagerSetTrustedAggregatorTimeout) + if err := _Mockpolygonrollupmanager.contract.UnpackLog(event, "SetTrustedAggregatorTimeout", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// MockpolygonrollupmanagerSetVerifyBatchTimeTargetIterator is returned from FilterSetVerifyBatchTimeTarget and is used to iterate over the raw logs and unpacked data for SetVerifyBatchTimeTarget events raised by the Mockpolygonrollupmanager contract. +type MockpolygonrollupmanagerSetVerifyBatchTimeTargetIterator struct { + Event *MockpolygonrollupmanagerSetVerifyBatchTimeTarget // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *MockpolygonrollupmanagerSetVerifyBatchTimeTargetIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(MockpolygonrollupmanagerSetVerifyBatchTimeTarget) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(MockpolygonrollupmanagerSetVerifyBatchTimeTarget) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *MockpolygonrollupmanagerSetVerifyBatchTimeTargetIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *MockpolygonrollupmanagerSetVerifyBatchTimeTargetIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// MockpolygonrollupmanagerSetVerifyBatchTimeTarget represents a SetVerifyBatchTimeTarget event raised by the Mockpolygonrollupmanager contract. +type MockpolygonrollupmanagerSetVerifyBatchTimeTarget struct { + NewVerifyBatchTimeTarget uint64 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterSetVerifyBatchTimeTarget is a free log retrieval operation binding the contract event 0x1b023231a1ab6b5d93992f168fb44498e1a7e64cef58daff6f1c216de6a68c28. +// +// Solidity: event SetVerifyBatchTimeTarget(uint64 newVerifyBatchTimeTarget) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) FilterSetVerifyBatchTimeTarget(opts *bind.FilterOpts) (*MockpolygonrollupmanagerSetVerifyBatchTimeTargetIterator, error) { + + logs, sub, err := _Mockpolygonrollupmanager.contract.FilterLogs(opts, "SetVerifyBatchTimeTarget") + if err != nil { + return nil, err + } + return &MockpolygonrollupmanagerSetVerifyBatchTimeTargetIterator{contract: _Mockpolygonrollupmanager.contract, event: "SetVerifyBatchTimeTarget", logs: logs, sub: sub}, nil +} + +// WatchSetVerifyBatchTimeTarget is a free log subscription operation binding the contract event 0x1b023231a1ab6b5d93992f168fb44498e1a7e64cef58daff6f1c216de6a68c28. +// +// Solidity: event SetVerifyBatchTimeTarget(uint64 newVerifyBatchTimeTarget) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) WatchSetVerifyBatchTimeTarget(opts *bind.WatchOpts, sink chan<- *MockpolygonrollupmanagerSetVerifyBatchTimeTarget) (event.Subscription, error) { + + logs, sub, err := _Mockpolygonrollupmanager.contract.WatchLogs(opts, "SetVerifyBatchTimeTarget") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(MockpolygonrollupmanagerSetVerifyBatchTimeTarget) + if err := _Mockpolygonrollupmanager.contract.UnpackLog(event, "SetVerifyBatchTimeTarget", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseSetVerifyBatchTimeTarget is a log parse operation binding the contract event 0x1b023231a1ab6b5d93992f168fb44498e1a7e64cef58daff6f1c216de6a68c28. +// +// Solidity: event SetVerifyBatchTimeTarget(uint64 newVerifyBatchTimeTarget) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) ParseSetVerifyBatchTimeTarget(log types.Log) (*MockpolygonrollupmanagerSetVerifyBatchTimeTarget, error) { + event := new(MockpolygonrollupmanagerSetVerifyBatchTimeTarget) + if err := _Mockpolygonrollupmanager.contract.UnpackLog(event, "SetVerifyBatchTimeTarget", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// MockpolygonrollupmanagerUpdateRollupIterator is returned from FilterUpdateRollup and is used to iterate over the raw logs and unpacked data for UpdateRollup events raised by the Mockpolygonrollupmanager contract. +type MockpolygonrollupmanagerUpdateRollupIterator struct { + Event *MockpolygonrollupmanagerUpdateRollup // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *MockpolygonrollupmanagerUpdateRollupIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(MockpolygonrollupmanagerUpdateRollup) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(MockpolygonrollupmanagerUpdateRollup) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *MockpolygonrollupmanagerUpdateRollupIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *MockpolygonrollupmanagerUpdateRollupIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// MockpolygonrollupmanagerUpdateRollup represents a UpdateRollup event raised by the Mockpolygonrollupmanager contract. +type MockpolygonrollupmanagerUpdateRollup struct { + RollupID uint32 + NewRollupTypeID uint32 + LastVerifiedBatchBeforeUpgrade uint64 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterUpdateRollup is a free log retrieval operation binding the contract event 0xf585e04c05d396901170247783d3e5f0ee9c1df23072985b50af089f5e48b19d. +// +// Solidity: event UpdateRollup(uint32 indexed rollupID, uint32 newRollupTypeID, uint64 lastVerifiedBatchBeforeUpgrade) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) FilterUpdateRollup(opts *bind.FilterOpts, rollupID []uint32) (*MockpolygonrollupmanagerUpdateRollupIterator, error) { + + var rollupIDRule []interface{} + for _, rollupIDItem := range rollupID { + rollupIDRule = append(rollupIDRule, rollupIDItem) + } + + logs, sub, err := _Mockpolygonrollupmanager.contract.FilterLogs(opts, "UpdateRollup", rollupIDRule) + if err != nil { + return nil, err + } + return &MockpolygonrollupmanagerUpdateRollupIterator{contract: _Mockpolygonrollupmanager.contract, event: "UpdateRollup", logs: logs, sub: sub}, nil +} + +// WatchUpdateRollup is a free log subscription operation binding the contract event 0xf585e04c05d396901170247783d3e5f0ee9c1df23072985b50af089f5e48b19d. +// +// Solidity: event UpdateRollup(uint32 indexed rollupID, uint32 newRollupTypeID, uint64 lastVerifiedBatchBeforeUpgrade) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) WatchUpdateRollup(opts *bind.WatchOpts, sink chan<- *MockpolygonrollupmanagerUpdateRollup, rollupID []uint32) (event.Subscription, error) { + + var rollupIDRule []interface{} + for _, rollupIDItem := range rollupID { + rollupIDRule = append(rollupIDRule, rollupIDItem) + } + + logs, sub, err := _Mockpolygonrollupmanager.contract.WatchLogs(opts, "UpdateRollup", rollupIDRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(MockpolygonrollupmanagerUpdateRollup) + if err := _Mockpolygonrollupmanager.contract.UnpackLog(event, "UpdateRollup", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseUpdateRollup is a log parse operation binding the contract event 0xf585e04c05d396901170247783d3e5f0ee9c1df23072985b50af089f5e48b19d. +// +// Solidity: event UpdateRollup(uint32 indexed rollupID, uint32 newRollupTypeID, uint64 lastVerifiedBatchBeforeUpgrade) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) ParseUpdateRollup(log types.Log) (*MockpolygonrollupmanagerUpdateRollup, error) { + event := new(MockpolygonrollupmanagerUpdateRollup) + if err := _Mockpolygonrollupmanager.contract.UnpackLog(event, "UpdateRollup", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// MockpolygonrollupmanagerVerifyBatchesIterator is returned from FilterVerifyBatches and is used to iterate over the raw logs and unpacked data for VerifyBatches events raised by the Mockpolygonrollupmanager contract. +type MockpolygonrollupmanagerVerifyBatchesIterator struct { + Event *MockpolygonrollupmanagerVerifyBatches // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *MockpolygonrollupmanagerVerifyBatchesIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(MockpolygonrollupmanagerVerifyBatches) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(MockpolygonrollupmanagerVerifyBatches) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *MockpolygonrollupmanagerVerifyBatchesIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *MockpolygonrollupmanagerVerifyBatchesIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// MockpolygonrollupmanagerVerifyBatches represents a VerifyBatches event raised by the Mockpolygonrollupmanager contract. +type MockpolygonrollupmanagerVerifyBatches struct { + RollupID uint32 + NumBatch uint64 + StateRoot [32]byte + ExitRoot [32]byte + Aggregator common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterVerifyBatches is a free log retrieval operation binding the contract event 0xaac1e7a157b259544ebacd6e8a82ae5d6c8f174e12aa48696277bcc9a661f0b4. +// +// Solidity: event VerifyBatches(uint32 indexed rollupID, uint64 numBatch, bytes32 stateRoot, bytes32 exitRoot, address indexed aggregator) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) FilterVerifyBatches(opts *bind.FilterOpts, rollupID []uint32, aggregator []common.Address) (*MockpolygonrollupmanagerVerifyBatchesIterator, error) { + + var rollupIDRule []interface{} + for _, rollupIDItem := range rollupID { + rollupIDRule = append(rollupIDRule, rollupIDItem) + } + + var aggregatorRule []interface{} + for _, aggregatorItem := range aggregator { + aggregatorRule = append(aggregatorRule, aggregatorItem) + } + + logs, sub, err := _Mockpolygonrollupmanager.contract.FilterLogs(opts, "VerifyBatches", rollupIDRule, aggregatorRule) + if err != nil { + return nil, err + } + return &MockpolygonrollupmanagerVerifyBatchesIterator{contract: _Mockpolygonrollupmanager.contract, event: "VerifyBatches", logs: logs, sub: sub}, nil +} + +// WatchVerifyBatches is a free log subscription operation binding the contract event 0xaac1e7a157b259544ebacd6e8a82ae5d6c8f174e12aa48696277bcc9a661f0b4. +// +// Solidity: event VerifyBatches(uint32 indexed rollupID, uint64 numBatch, bytes32 stateRoot, bytes32 exitRoot, address indexed aggregator) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) WatchVerifyBatches(opts *bind.WatchOpts, sink chan<- *MockpolygonrollupmanagerVerifyBatches, rollupID []uint32, aggregator []common.Address) (event.Subscription, error) { + + var rollupIDRule []interface{} + for _, rollupIDItem := range rollupID { + rollupIDRule = append(rollupIDRule, rollupIDItem) + } + + var aggregatorRule []interface{} + for _, aggregatorItem := range aggregator { + aggregatorRule = append(aggregatorRule, aggregatorItem) + } + + logs, sub, err := _Mockpolygonrollupmanager.contract.WatchLogs(opts, "VerifyBatches", rollupIDRule, aggregatorRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(MockpolygonrollupmanagerVerifyBatches) + if err := _Mockpolygonrollupmanager.contract.UnpackLog(event, "VerifyBatches", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseVerifyBatches is a log parse operation binding the contract event 0xaac1e7a157b259544ebacd6e8a82ae5d6c8f174e12aa48696277bcc9a661f0b4. +// +// Solidity: event VerifyBatches(uint32 indexed rollupID, uint64 numBatch, bytes32 stateRoot, bytes32 exitRoot, address indexed aggregator) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) ParseVerifyBatches(log types.Log) (*MockpolygonrollupmanagerVerifyBatches, error) { + event := new(MockpolygonrollupmanagerVerifyBatches) + if err := _Mockpolygonrollupmanager.contract.UnpackLog(event, "VerifyBatches", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// MockpolygonrollupmanagerVerifyBatchesTrustedAggregatorIterator is returned from FilterVerifyBatchesTrustedAggregator and is used to iterate over the raw logs and unpacked data for VerifyBatchesTrustedAggregator events raised by the Mockpolygonrollupmanager contract. +type MockpolygonrollupmanagerVerifyBatchesTrustedAggregatorIterator struct { + Event *MockpolygonrollupmanagerVerifyBatchesTrustedAggregator // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *MockpolygonrollupmanagerVerifyBatchesTrustedAggregatorIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(MockpolygonrollupmanagerVerifyBatchesTrustedAggregator) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(MockpolygonrollupmanagerVerifyBatchesTrustedAggregator) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *MockpolygonrollupmanagerVerifyBatchesTrustedAggregatorIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *MockpolygonrollupmanagerVerifyBatchesTrustedAggregatorIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// MockpolygonrollupmanagerVerifyBatchesTrustedAggregator represents a VerifyBatchesTrustedAggregator event raised by the Mockpolygonrollupmanager contract. +type MockpolygonrollupmanagerVerifyBatchesTrustedAggregator struct { + RollupID uint32 + NumBatch uint64 + StateRoot [32]byte + ExitRoot [32]byte + Aggregator common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterVerifyBatchesTrustedAggregator is a free log retrieval operation binding the contract event 0xd1ec3a1216f08b6eff72e169ceb548b782db18a6614852618d86bb19f3f9b0d3. +// +// Solidity: event VerifyBatchesTrustedAggregator(uint32 indexed rollupID, uint64 numBatch, bytes32 stateRoot, bytes32 exitRoot, address indexed aggregator) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) FilterVerifyBatchesTrustedAggregator(opts *bind.FilterOpts, rollupID []uint32, aggregator []common.Address) (*MockpolygonrollupmanagerVerifyBatchesTrustedAggregatorIterator, error) { + + var rollupIDRule []interface{} + for _, rollupIDItem := range rollupID { + rollupIDRule = append(rollupIDRule, rollupIDItem) + } + + var aggregatorRule []interface{} + for _, aggregatorItem := range aggregator { + aggregatorRule = append(aggregatorRule, aggregatorItem) + } + + logs, sub, err := _Mockpolygonrollupmanager.contract.FilterLogs(opts, "VerifyBatchesTrustedAggregator", rollupIDRule, aggregatorRule) + if err != nil { + return nil, err + } + return &MockpolygonrollupmanagerVerifyBatchesTrustedAggregatorIterator{contract: _Mockpolygonrollupmanager.contract, event: "VerifyBatchesTrustedAggregator", logs: logs, sub: sub}, nil +} + +// WatchVerifyBatchesTrustedAggregator is a free log subscription operation binding the contract event 0xd1ec3a1216f08b6eff72e169ceb548b782db18a6614852618d86bb19f3f9b0d3. +// +// Solidity: event VerifyBatchesTrustedAggregator(uint32 indexed rollupID, uint64 numBatch, bytes32 stateRoot, bytes32 exitRoot, address indexed aggregator) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) WatchVerifyBatchesTrustedAggregator(opts *bind.WatchOpts, sink chan<- *MockpolygonrollupmanagerVerifyBatchesTrustedAggregator, rollupID []uint32, aggregator []common.Address) (event.Subscription, error) { + + var rollupIDRule []interface{} + for _, rollupIDItem := range rollupID { + rollupIDRule = append(rollupIDRule, rollupIDItem) + } + + var aggregatorRule []interface{} + for _, aggregatorItem := range aggregator { + aggregatorRule = append(aggregatorRule, aggregatorItem) + } + + logs, sub, err := _Mockpolygonrollupmanager.contract.WatchLogs(opts, "VerifyBatchesTrustedAggregator", rollupIDRule, aggregatorRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(MockpolygonrollupmanagerVerifyBatchesTrustedAggregator) + if err := _Mockpolygonrollupmanager.contract.UnpackLog(event, "VerifyBatchesTrustedAggregator", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseVerifyBatchesTrustedAggregator is a log parse operation binding the contract event 0xd1ec3a1216f08b6eff72e169ceb548b782db18a6614852618d86bb19f3f9b0d3. +// +// Solidity: event VerifyBatchesTrustedAggregator(uint32 indexed rollupID, uint64 numBatch, bytes32 stateRoot, bytes32 exitRoot, address indexed aggregator) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerFilterer) ParseVerifyBatchesTrustedAggregator(log types.Log) (*MockpolygonrollupmanagerVerifyBatchesTrustedAggregator, error) { + event := new(MockpolygonrollupmanagerVerifyBatchesTrustedAggregator) + if err := _Mockpolygonrollupmanager.contract.UnpackLog(event, "VerifyBatchesTrustedAggregator", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/etherman/smartcontracts/mockverifier/mockverifier.go b/etherman/smartcontracts/mockverifier/mockverifier.go new file mode 100644 index 0000000..48b4fca --- /dev/null +++ b/etherman/smartcontracts/mockverifier/mockverifier.go @@ -0,0 +1,234 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package mockverifier + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// MockverifierMetaData contains all meta data concerning the Mockverifier contract. +var MockverifierMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[{\"internalType\":\"bytes32[24]\",\"name\":\"proof\",\"type\":\"bytes32[24]\"},{\"internalType\":\"uint256[1]\",\"name\":\"pubSignals\",\"type\":\"uint256[1]\"}],\"name\":\"verifyProof\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}]", + Bin: "0x608060405234801561001057600080fd5b50610158806100206000396000f3fe608060405234801561001057600080fd5b506004361061002b5760003560e01c80639121da8a14610030575b600080fd5b61004661003e366004610089565b600192915050565b604051901515815260200160405180910390f35b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b60008061032080848603121561009e57600080fd5b6103008401858111156100b057600080fd5b8493508561031f8601126100c357600080fd5b604051602080820182811067ffffffffffffffff821117156100e7576100e761005a565b6040529286019281888511156100fc57600080fd5b5b8484101561011457833581529281019281016100fd565b50949790965094505050505056fea264697066735822122061fd8311ce6da82f24c0874a992ea14a8aaf711e353693cae56066e3223abc5a64736f6c63430008140033", +} + +// MockverifierABI is the input ABI used to generate the binding from. +// Deprecated: Use MockverifierMetaData.ABI instead. +var MockverifierABI = MockverifierMetaData.ABI + +// MockverifierBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use MockverifierMetaData.Bin instead. +var MockverifierBin = MockverifierMetaData.Bin + +// DeployMockverifier deploys a new Ethereum contract, binding an instance of Mockverifier to it. +func DeployMockverifier(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Mockverifier, error) { + parsed, err := MockverifierMetaData.GetAbi() + if err != nil { + return common.Address{}, nil, nil, err + } + if parsed == nil { + return common.Address{}, nil, nil, errors.New("GetABI returned nil") + } + + address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex(MockverifierBin), backend) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &Mockverifier{MockverifierCaller: MockverifierCaller{contract: contract}, MockverifierTransactor: MockverifierTransactor{contract: contract}, MockverifierFilterer: MockverifierFilterer{contract: contract}}, nil +} + +// Mockverifier is an auto generated Go binding around an Ethereum contract. +type Mockverifier struct { + MockverifierCaller // Read-only binding to the contract + MockverifierTransactor // Write-only binding to the contract + MockverifierFilterer // Log filterer for contract events +} + +// MockverifierCaller is an auto generated read-only Go binding around an Ethereum contract. +type MockverifierCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// MockverifierTransactor is an auto generated write-only Go binding around an Ethereum contract. +type MockverifierTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// MockverifierFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type MockverifierFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// MockverifierSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type MockverifierSession struct { + Contract *Mockverifier // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// MockverifierCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type MockverifierCallerSession struct { + Contract *MockverifierCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// MockverifierTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type MockverifierTransactorSession struct { + Contract *MockverifierTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// MockverifierRaw is an auto generated low-level Go binding around an Ethereum contract. +type MockverifierRaw struct { + Contract *Mockverifier // Generic contract binding to access the raw methods on +} + +// MockverifierCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type MockverifierCallerRaw struct { + Contract *MockverifierCaller // Generic read-only contract binding to access the raw methods on +} + +// MockverifierTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type MockverifierTransactorRaw struct { + Contract *MockverifierTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewMockverifier creates a new instance of Mockverifier, bound to a specific deployed contract. +func NewMockverifier(address common.Address, backend bind.ContractBackend) (*Mockverifier, error) { + contract, err := bindMockverifier(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &Mockverifier{MockverifierCaller: MockverifierCaller{contract: contract}, MockverifierTransactor: MockverifierTransactor{contract: contract}, MockverifierFilterer: MockverifierFilterer{contract: contract}}, nil +} + +// NewMockverifierCaller creates a new read-only instance of Mockverifier, bound to a specific deployed contract. +func NewMockverifierCaller(address common.Address, caller bind.ContractCaller) (*MockverifierCaller, error) { + contract, err := bindMockverifier(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &MockverifierCaller{contract: contract}, nil +} + +// NewMockverifierTransactor creates a new write-only instance of Mockverifier, bound to a specific deployed contract. +func NewMockverifierTransactor(address common.Address, transactor bind.ContractTransactor) (*MockverifierTransactor, error) { + contract, err := bindMockverifier(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &MockverifierTransactor{contract: contract}, nil +} + +// NewMockverifierFilterer creates a new log filterer instance of Mockverifier, bound to a specific deployed contract. +func NewMockverifierFilterer(address common.Address, filterer bind.ContractFilterer) (*MockverifierFilterer, error) { + contract, err := bindMockverifier(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &MockverifierFilterer{contract: contract}, nil +} + +// bindMockverifier binds a generic wrapper to an already deployed contract. +func bindMockverifier(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := MockverifierMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Mockverifier *MockverifierRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Mockverifier.Contract.MockverifierCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Mockverifier *MockverifierRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Mockverifier.Contract.MockverifierTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Mockverifier *MockverifierRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Mockverifier.Contract.MockverifierTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Mockverifier *MockverifierCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Mockverifier.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Mockverifier *MockverifierTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Mockverifier.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Mockverifier *MockverifierTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Mockverifier.Contract.contract.Transact(opts, method, params...) +} + +// VerifyProof is a free data retrieval call binding the contract method 0x9121da8a. +// +// Solidity: function verifyProof(bytes32[24] proof, uint256[1] pubSignals) pure returns(bool) +func (_Mockverifier *MockverifierCaller) VerifyProof(opts *bind.CallOpts, proof [24][32]byte, pubSignals [1]*big.Int) (bool, error) { + var out []interface{} + err := _Mockverifier.contract.Call(opts, &out, "verifyProof", proof, pubSignals) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// VerifyProof is a free data retrieval call binding the contract method 0x9121da8a. +// +// Solidity: function verifyProof(bytes32[24] proof, uint256[1] pubSignals) pure returns(bool) +func (_Mockverifier *MockverifierSession) VerifyProof(proof [24][32]byte, pubSignals [1]*big.Int) (bool, error) { + return _Mockverifier.Contract.VerifyProof(&_Mockverifier.CallOpts, proof, pubSignals) +} + +// VerifyProof is a free data retrieval call binding the contract method 0x9121da8a. +// +// Solidity: function verifyProof(bytes32[24] proof, uint256[1] pubSignals) pure returns(bool) +func (_Mockverifier *MockverifierCallerSession) VerifyProof(proof [24][32]byte, pubSignals [1]*big.Int) (bool, error) { + return _Mockverifier.Contract.VerifyProof(&_Mockverifier.CallOpts, proof, pubSignals) +} diff --git a/etherman/smartcontracts/oldpolygonzkevm/oldpolygonzkevm.go b/etherman/smartcontracts/oldpolygonzkevm/oldpolygonzkevm.go new file mode 100644 index 0000000..3750d00 --- /dev/null +++ b/etherman/smartcontracts/oldpolygonzkevm/oldpolygonzkevm.go @@ -0,0 +1,5308 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package oldpolygonzkevm + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// PolygonZkEVMBatchData is an auto generated low-level Go binding around an user-defined struct. +type PolygonZkEVMBatchData struct { + Transactions []byte + GlobalExitRoot [32]byte + Timestamp uint64 + MinForcedTimestamp uint64 +} + +// PolygonZkEVMForcedBatchData is an auto generated low-level Go binding around an user-defined struct. +type PolygonZkEVMForcedBatchData struct { + Transactions []byte + GlobalExitRoot [32]byte + MinForcedTimestamp uint64 +} + +// PolygonZkEVMInitializePackedParameters is an auto generated low-level Go binding around an user-defined struct. +type PolygonZkEVMInitializePackedParameters struct { + Admin common.Address + TrustedSequencer common.Address + PendingStateTimeout uint64 + TrustedAggregator common.Address + TrustedAggregatorTimeout uint64 +} + +// OldpolygonzkevmMetaData contains all meta data concerning the Oldpolygonzkevm contract. +var OldpolygonzkevmMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[{\"internalType\":\"contractIPolygonZkEVMGlobalExitRoot\",\"name\":\"_globalExitRootManager\",\"type\":\"address\"},{\"internalType\":\"contractIERC20Upgradeable\",\"name\":\"_matic\",\"type\":\"address\"},{\"internalType\":\"contractIVerifierRollup\",\"name\":\"_rollupVerifier\",\"type\":\"address\"},{\"internalType\":\"contractIPolygonZkEVMBridge\",\"name\":\"_bridgeAddress\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"_chainID\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"_forkID\",\"type\":\"uint64\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"BatchAlreadyVerified\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"BatchNotSequencedOrNotSequenceEnd\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ExceedMaxVerifyBatches\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FinalNumBatchBelowLastVerifiedBatch\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FinalNumBatchDoesNotMatchPendingState\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FinalPendingStateNumInvalid\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ForceBatchNotAllowed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ForceBatchTimeoutNotExpired\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ForceBatchesAlreadyActive\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ForceBatchesOverflow\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ForcedDataDoesNotMatch\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"GlobalExitRootNotExist\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"HaltTimeoutNotExpired\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InitNumBatchAboveLastVerifiedBatch\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InitNumBatchDoesNotMatchPendingState\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidProof\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidRangeBatchTimeTarget\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidRangeForceBatchTimeout\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidRangeMultiplierBatchFee\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NewAccInputHashDoesNotExist\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NewPendingStateTimeoutMustBeLower\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NewStateRootNotInsidePrime\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NewTrustedAggregatorTimeoutMustBeLower\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotEnoughMaticAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OldAccInputHashDoesNotExist\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OldStateRootDoesNotExist\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OnlyAdmin\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OnlyEmergencyState\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OnlyNotEmergencyState\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OnlyPendingAdmin\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OnlyTrustedAggregator\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OnlyTrustedSequencer\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"PendingStateDoesNotExist\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"PendingStateInvalid\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"PendingStateNotConsolidable\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"PendingStateTimeoutExceedHaltAggregationTimeout\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SequenceZeroBatches\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SequencedTimestampBelowForcedTimestamp\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SequencedTimestampInvalid\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"StoredRootMustBeDifferentThanNewRoot\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TransactionsLengthAboveMax\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TrustedAggregatorTimeoutExceedHaltAggregationTimeout\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TrustedAggregatorTimeoutNotExpired\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AcceptAdminRole\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[],\"name\":\"ActivateForceBatches\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint64\",\"name\":\"numBatch\",\"type\":\"uint64\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"stateRoot\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"uint64\",\"name\":\"pendingStateNum\",\"type\":\"uint64\"}],\"name\":\"ConsolidatePendingState\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[],\"name\":\"EmergencyStateActivated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[],\"name\":\"EmergencyStateDeactivated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint64\",\"name\":\"forceBatchNum\",\"type\":\"uint64\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"lastGlobalExitRoot\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sequencer\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"transactions\",\"type\":\"bytes\"}],\"name\":\"ForceBatch\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint64\",\"name\":\"numBatch\",\"type\":\"uint64\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"stateRoot\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"aggregator\",\"type\":\"address\"}],\"name\":\"OverridePendingState\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"storedStateRoot\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"provedStateRoot\",\"type\":\"bytes32\"}],\"name\":\"ProveNonDeterministicPendingState\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint64\",\"name\":\"numBatch\",\"type\":\"uint64\"}],\"name\":\"SequenceBatches\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint64\",\"name\":\"numBatch\",\"type\":\"uint64\"}],\"name\":\"SequenceForceBatches\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"newforceBatchTimeout\",\"type\":\"uint64\"}],\"name\":\"SetForceBatchTimeout\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint16\",\"name\":\"newMultiplierBatchFee\",\"type\":\"uint16\"}],\"name\":\"SetMultiplierBatchFee\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"newPendingStateTimeout\",\"type\":\"uint64\"}],\"name\":\"SetPendingStateTimeout\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newTrustedAggregator\",\"type\":\"address\"}],\"name\":\"SetTrustedAggregator\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"newTrustedAggregatorTimeout\",\"type\":\"uint64\"}],\"name\":\"SetTrustedAggregatorTimeout\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newTrustedSequencer\",\"type\":\"address\"}],\"name\":\"SetTrustedSequencer\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"newTrustedSequencerURL\",\"type\":\"string\"}],\"name\":\"SetTrustedSequencerURL\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"newVerifyBatchTimeTarget\",\"type\":\"uint64\"}],\"name\":\"SetVerifyBatchTimeTarget\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newPendingAdmin\",\"type\":\"address\"}],\"name\":\"TransferAdminRole\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"numBatch\",\"type\":\"uint64\"},{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"forkID\",\"type\":\"uint64\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"version\",\"type\":\"string\"}],\"name\":\"UpdateZkEVMVersion\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint64\",\"name\":\"numBatch\",\"type\":\"uint64\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"stateRoot\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"aggregator\",\"type\":\"address\"}],\"name\":\"VerifyBatches\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint64\",\"name\":\"numBatch\",\"type\":\"uint64\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"stateRoot\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"aggregator\",\"type\":\"address\"}],\"name\":\"VerifyBatchesTrustedAggregator\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"acceptAdminRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint64\",\"name\":\"sequencedBatchNum\",\"type\":\"uint64\"}],\"name\":\"activateEmergencyState\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"activateForceBatches\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"admin\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"batchFee\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"name\":\"batchNumToStateRoot\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"bridgeAddress\",\"outputs\":[{\"internalType\":\"contractIPolygonZkEVMBridge\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"calculateRewardPerBatch\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"chainID\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"newStateRoot\",\"type\":\"uint256\"}],\"name\":\"checkStateRootInsidePrime\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint64\",\"name\":\"pendingStateNum\",\"type\":\"uint64\"}],\"name\":\"consolidatePendingState\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"deactivateEmergencyState\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"transactions\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"maticAmount\",\"type\":\"uint256\"}],\"name\":\"forceBatch\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"forceBatchTimeout\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"name\":\"forcedBatches\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"forkID\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getForcedBatchFee\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint64\",\"name\":\"initNumBatch\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"finalNewBatch\",\"type\":\"uint64\"},{\"internalType\":\"bytes32\",\"name\":\"newLocalExitRoot\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"oldStateRoot\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"newStateRoot\",\"type\":\"bytes32\"}],\"name\":\"getInputSnarkBytes\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getLastVerifiedBatch\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"globalExitRootManager\",\"outputs\":[{\"internalType\":\"contractIPolygonZkEVMGlobalExitRoot\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"admin\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"trustedSequencer\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"pendingStateTimeout\",\"type\":\"uint64\"},{\"internalType\":\"address\",\"name\":\"trustedAggregator\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"trustedAggregatorTimeout\",\"type\":\"uint64\"}],\"internalType\":\"structPolygonZkEVM.InitializePackedParameters\",\"name\":\"initializePackedParameters\",\"type\":\"tuple\"},{\"internalType\":\"bytes32\",\"name\":\"genesisRoot\",\"type\":\"bytes32\"},{\"internalType\":\"string\",\"name\":\"_trustedSequencerURL\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"_networkName\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"_version\",\"type\":\"string\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"isEmergencyState\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"isForcedBatchDisallowed\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint64\",\"name\":\"pendingStateNum\",\"type\":\"uint64\"}],\"name\":\"isPendingStateConsolidable\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"lastBatchSequenced\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"lastForceBatch\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"lastForceBatchSequenced\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"lastPendingState\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"lastPendingStateConsolidated\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"lastTimestamp\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"lastVerifiedBatch\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"matic\",\"outputs\":[{\"internalType\":\"contractIERC20Upgradeable\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"multiplierBatchFee\",\"outputs\":[{\"internalType\":\"uint16\",\"name\":\"\",\"type\":\"uint16\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"networkName\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint64\",\"name\":\"initPendingStateNum\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"finalPendingStateNum\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"initNumBatch\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"finalNewBatch\",\"type\":\"uint64\"},{\"internalType\":\"bytes32\",\"name\":\"newLocalExitRoot\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"newStateRoot\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32[24]\",\"name\":\"proof\",\"type\":\"bytes32[24]\"}],\"name\":\"overridePendingState\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pendingAdmin\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pendingStateTimeout\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"pendingStateTransitions\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"timestamp\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"lastVerifiedBatch\",\"type\":\"uint64\"},{\"internalType\":\"bytes32\",\"name\":\"exitRoot\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"stateRoot\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint64\",\"name\":\"initPendingStateNum\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"finalPendingStateNum\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"initNumBatch\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"finalNewBatch\",\"type\":\"uint64\"},{\"internalType\":\"bytes32\",\"name\":\"newLocalExitRoot\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"newStateRoot\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32[24]\",\"name\":\"proof\",\"type\":\"bytes32[24]\"}],\"name\":\"proveNonDeterministicPendingState\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"rollupVerifier\",\"outputs\":[{\"internalType\":\"contractIVerifierRollup\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"transactions\",\"type\":\"bytes\"},{\"internalType\":\"bytes32\",\"name\":\"globalExitRoot\",\"type\":\"bytes32\"},{\"internalType\":\"uint64\",\"name\":\"timestamp\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"minForcedTimestamp\",\"type\":\"uint64\"}],\"internalType\":\"structPolygonZkEVM.BatchData[]\",\"name\":\"batches\",\"type\":\"tuple[]\"},{\"internalType\":\"address\",\"name\":\"l2Coinbase\",\"type\":\"address\"}],\"name\":\"sequenceBatches\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"transactions\",\"type\":\"bytes\"},{\"internalType\":\"bytes32\",\"name\":\"globalExitRoot\",\"type\":\"bytes32\"},{\"internalType\":\"uint64\",\"name\":\"minForcedTimestamp\",\"type\":\"uint64\"}],\"internalType\":\"structPolygonZkEVM.ForcedBatchData[]\",\"name\":\"batches\",\"type\":\"tuple[]\"}],\"name\":\"sequenceForceBatches\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"name\":\"sequencedBatches\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"accInputHash\",\"type\":\"bytes32\"},{\"internalType\":\"uint64\",\"name\":\"sequencedTimestamp\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"previousLastBatchSequenced\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint64\",\"name\":\"newforceBatchTimeout\",\"type\":\"uint64\"}],\"name\":\"setForceBatchTimeout\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint16\",\"name\":\"newMultiplierBatchFee\",\"type\":\"uint16\"}],\"name\":\"setMultiplierBatchFee\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint64\",\"name\":\"newPendingStateTimeout\",\"type\":\"uint64\"}],\"name\":\"setPendingStateTimeout\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newTrustedAggregator\",\"type\":\"address\"}],\"name\":\"setTrustedAggregator\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint64\",\"name\":\"newTrustedAggregatorTimeout\",\"type\":\"uint64\"}],\"name\":\"setTrustedAggregatorTimeout\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newTrustedSequencer\",\"type\":\"address\"}],\"name\":\"setTrustedSequencer\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"newTrustedSequencerURL\",\"type\":\"string\"}],\"name\":\"setTrustedSequencerURL\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint64\",\"name\":\"newVerifyBatchTimeTarget\",\"type\":\"uint64\"}],\"name\":\"setVerifyBatchTimeTarget\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newPendingAdmin\",\"type\":\"address\"}],\"name\":\"transferAdminRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"trustedAggregator\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"trustedAggregatorTimeout\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"trustedSequencer\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"trustedSequencerURL\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"verifyBatchTimeTarget\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint64\",\"name\":\"pendingStateNum\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"initNumBatch\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"finalNewBatch\",\"type\":\"uint64\"},{\"internalType\":\"bytes32\",\"name\":\"newLocalExitRoot\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"newStateRoot\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32[24]\",\"name\":\"proof\",\"type\":\"bytes32[24]\"}],\"name\":\"verifyBatches\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint64\",\"name\":\"pendingStateNum\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"initNumBatch\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"finalNewBatch\",\"type\":\"uint64\"},{\"internalType\":\"bytes32\",\"name\":\"newLocalExitRoot\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"newStateRoot\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32[24]\",\"name\":\"proof\",\"type\":\"bytes32[24]\"}],\"name\":\"verifyBatchesTrustedAggregator\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", + Bin: "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", +} + +// OldpolygonzkevmABI is the input ABI used to generate the binding from. +// Deprecated: Use OldpolygonzkevmMetaData.ABI instead. +var OldpolygonzkevmABI = OldpolygonzkevmMetaData.ABI + +// OldpolygonzkevmBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use OldpolygonzkevmMetaData.Bin instead. +var OldpolygonzkevmBin = OldpolygonzkevmMetaData.Bin + +// DeployOldpolygonzkevm deploys a new Ethereum contract, binding an instance of Oldpolygonzkevm to it. +func DeployOldpolygonzkevm(auth *bind.TransactOpts, backend bind.ContractBackend, _globalExitRootManager common.Address, _matic common.Address, _rollupVerifier common.Address, _bridgeAddress common.Address, _chainID uint64, _forkID uint64) (common.Address, *types.Transaction, *Oldpolygonzkevm, error) { + parsed, err := OldpolygonzkevmMetaData.GetAbi() + if err != nil { + return common.Address{}, nil, nil, err + } + if parsed == nil { + return common.Address{}, nil, nil, errors.New("GetABI returned nil") + } + + address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex(OldpolygonzkevmBin), backend, _globalExitRootManager, _matic, _rollupVerifier, _bridgeAddress, _chainID, _forkID) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &Oldpolygonzkevm{OldpolygonzkevmCaller: OldpolygonzkevmCaller{contract: contract}, OldpolygonzkevmTransactor: OldpolygonzkevmTransactor{contract: contract}, OldpolygonzkevmFilterer: OldpolygonzkevmFilterer{contract: contract}}, nil +} + +// Oldpolygonzkevm is an auto generated Go binding around an Ethereum contract. +type Oldpolygonzkevm struct { + OldpolygonzkevmCaller // Read-only binding to the contract + OldpolygonzkevmTransactor // Write-only binding to the contract + OldpolygonzkevmFilterer // Log filterer for contract events +} + +// OldpolygonzkevmCaller is an auto generated read-only Go binding around an Ethereum contract. +type OldpolygonzkevmCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// OldpolygonzkevmTransactor is an auto generated write-only Go binding around an Ethereum contract. +type OldpolygonzkevmTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// OldpolygonzkevmFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type OldpolygonzkevmFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// OldpolygonzkevmSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type OldpolygonzkevmSession struct { + Contract *Oldpolygonzkevm // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// OldpolygonzkevmCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type OldpolygonzkevmCallerSession struct { + Contract *OldpolygonzkevmCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// OldpolygonzkevmTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type OldpolygonzkevmTransactorSession struct { + Contract *OldpolygonzkevmTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// OldpolygonzkevmRaw is an auto generated low-level Go binding around an Ethereum contract. +type OldpolygonzkevmRaw struct { + Contract *Oldpolygonzkevm // Generic contract binding to access the raw methods on +} + +// OldpolygonzkevmCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type OldpolygonzkevmCallerRaw struct { + Contract *OldpolygonzkevmCaller // Generic read-only contract binding to access the raw methods on +} + +// OldpolygonzkevmTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type OldpolygonzkevmTransactorRaw struct { + Contract *OldpolygonzkevmTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewOldpolygonzkevm creates a new instance of Oldpolygonzkevm, bound to a specific deployed contract. +func NewOldpolygonzkevm(address common.Address, backend bind.ContractBackend) (*Oldpolygonzkevm, error) { + contract, err := bindOldpolygonzkevm(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &Oldpolygonzkevm{OldpolygonzkevmCaller: OldpolygonzkevmCaller{contract: contract}, OldpolygonzkevmTransactor: OldpolygonzkevmTransactor{contract: contract}, OldpolygonzkevmFilterer: OldpolygonzkevmFilterer{contract: contract}}, nil +} + +// NewOldpolygonzkevmCaller creates a new read-only instance of Oldpolygonzkevm, bound to a specific deployed contract. +func NewOldpolygonzkevmCaller(address common.Address, caller bind.ContractCaller) (*OldpolygonzkevmCaller, error) { + contract, err := bindOldpolygonzkevm(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &OldpolygonzkevmCaller{contract: contract}, nil +} + +// NewOldpolygonzkevmTransactor creates a new write-only instance of Oldpolygonzkevm, bound to a specific deployed contract. +func NewOldpolygonzkevmTransactor(address common.Address, transactor bind.ContractTransactor) (*OldpolygonzkevmTransactor, error) { + contract, err := bindOldpolygonzkevm(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &OldpolygonzkevmTransactor{contract: contract}, nil +} + +// NewOldpolygonzkevmFilterer creates a new log filterer instance of Oldpolygonzkevm, bound to a specific deployed contract. +func NewOldpolygonzkevmFilterer(address common.Address, filterer bind.ContractFilterer) (*OldpolygonzkevmFilterer, error) { + contract, err := bindOldpolygonzkevm(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &OldpolygonzkevmFilterer{contract: contract}, nil +} + +// bindOldpolygonzkevm binds a generic wrapper to an already deployed contract. +func bindOldpolygonzkevm(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := OldpolygonzkevmMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Oldpolygonzkevm *OldpolygonzkevmRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Oldpolygonzkevm.Contract.OldpolygonzkevmCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Oldpolygonzkevm *OldpolygonzkevmRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.OldpolygonzkevmTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Oldpolygonzkevm *OldpolygonzkevmRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.OldpolygonzkevmTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Oldpolygonzkevm *OldpolygonzkevmCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Oldpolygonzkevm.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Oldpolygonzkevm *OldpolygonzkevmTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Oldpolygonzkevm *OldpolygonzkevmTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.contract.Transact(opts, method, params...) +} + +// Admin is a free data retrieval call binding the contract method 0xf851a440. +// +// Solidity: function admin() view returns(address) +func (_Oldpolygonzkevm *OldpolygonzkevmCaller) Admin(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Oldpolygonzkevm.contract.Call(opts, &out, "admin") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// Admin is a free data retrieval call binding the contract method 0xf851a440. +// +// Solidity: function admin() view returns(address) +func (_Oldpolygonzkevm *OldpolygonzkevmSession) Admin() (common.Address, error) { + return _Oldpolygonzkevm.Contract.Admin(&_Oldpolygonzkevm.CallOpts) +} + +// Admin is a free data retrieval call binding the contract method 0xf851a440. +// +// Solidity: function admin() view returns(address) +func (_Oldpolygonzkevm *OldpolygonzkevmCallerSession) Admin() (common.Address, error) { + return _Oldpolygonzkevm.Contract.Admin(&_Oldpolygonzkevm.CallOpts) +} + +// BatchFee is a free data retrieval call binding the contract method 0xf8b823e4. +// +// Solidity: function batchFee() view returns(uint256) +func (_Oldpolygonzkevm *OldpolygonzkevmCaller) BatchFee(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _Oldpolygonzkevm.contract.Call(opts, &out, "batchFee") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// BatchFee is a free data retrieval call binding the contract method 0xf8b823e4. +// +// Solidity: function batchFee() view returns(uint256) +func (_Oldpolygonzkevm *OldpolygonzkevmSession) BatchFee() (*big.Int, error) { + return _Oldpolygonzkevm.Contract.BatchFee(&_Oldpolygonzkevm.CallOpts) +} + +// BatchFee is a free data retrieval call binding the contract method 0xf8b823e4. +// +// Solidity: function batchFee() view returns(uint256) +func (_Oldpolygonzkevm *OldpolygonzkevmCallerSession) BatchFee() (*big.Int, error) { + return _Oldpolygonzkevm.Contract.BatchFee(&_Oldpolygonzkevm.CallOpts) +} + +// BatchNumToStateRoot is a free data retrieval call binding the contract method 0x5392c5e0. +// +// Solidity: function batchNumToStateRoot(uint64 ) view returns(bytes32) +func (_Oldpolygonzkevm *OldpolygonzkevmCaller) BatchNumToStateRoot(opts *bind.CallOpts, arg0 uint64) ([32]byte, error) { + var out []interface{} + err := _Oldpolygonzkevm.contract.Call(opts, &out, "batchNumToStateRoot", arg0) + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// BatchNumToStateRoot is a free data retrieval call binding the contract method 0x5392c5e0. +// +// Solidity: function batchNumToStateRoot(uint64 ) view returns(bytes32) +func (_Oldpolygonzkevm *OldpolygonzkevmSession) BatchNumToStateRoot(arg0 uint64) ([32]byte, error) { + return _Oldpolygonzkevm.Contract.BatchNumToStateRoot(&_Oldpolygonzkevm.CallOpts, arg0) +} + +// BatchNumToStateRoot is a free data retrieval call binding the contract method 0x5392c5e0. +// +// Solidity: function batchNumToStateRoot(uint64 ) view returns(bytes32) +func (_Oldpolygonzkevm *OldpolygonzkevmCallerSession) BatchNumToStateRoot(arg0 uint64) ([32]byte, error) { + return _Oldpolygonzkevm.Contract.BatchNumToStateRoot(&_Oldpolygonzkevm.CallOpts, arg0) +} + +// BridgeAddress is a free data retrieval call binding the contract method 0xa3c573eb. +// +// Solidity: function bridgeAddress() view returns(address) +func (_Oldpolygonzkevm *OldpolygonzkevmCaller) BridgeAddress(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Oldpolygonzkevm.contract.Call(opts, &out, "bridgeAddress") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// BridgeAddress is a free data retrieval call binding the contract method 0xa3c573eb. +// +// Solidity: function bridgeAddress() view returns(address) +func (_Oldpolygonzkevm *OldpolygonzkevmSession) BridgeAddress() (common.Address, error) { + return _Oldpolygonzkevm.Contract.BridgeAddress(&_Oldpolygonzkevm.CallOpts) +} + +// BridgeAddress is a free data retrieval call binding the contract method 0xa3c573eb. +// +// Solidity: function bridgeAddress() view returns(address) +func (_Oldpolygonzkevm *OldpolygonzkevmCallerSession) BridgeAddress() (common.Address, error) { + return _Oldpolygonzkevm.Contract.BridgeAddress(&_Oldpolygonzkevm.CallOpts) +} + +// CalculateRewardPerBatch is a free data retrieval call binding the contract method 0x99f5634e. +// +// Solidity: function calculateRewardPerBatch() view returns(uint256) +func (_Oldpolygonzkevm *OldpolygonzkevmCaller) CalculateRewardPerBatch(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _Oldpolygonzkevm.contract.Call(opts, &out, "calculateRewardPerBatch") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// CalculateRewardPerBatch is a free data retrieval call binding the contract method 0x99f5634e. +// +// Solidity: function calculateRewardPerBatch() view returns(uint256) +func (_Oldpolygonzkevm *OldpolygonzkevmSession) CalculateRewardPerBatch() (*big.Int, error) { + return _Oldpolygonzkevm.Contract.CalculateRewardPerBatch(&_Oldpolygonzkevm.CallOpts) +} + +// CalculateRewardPerBatch is a free data retrieval call binding the contract method 0x99f5634e. +// +// Solidity: function calculateRewardPerBatch() view returns(uint256) +func (_Oldpolygonzkevm *OldpolygonzkevmCallerSession) CalculateRewardPerBatch() (*big.Int, error) { + return _Oldpolygonzkevm.Contract.CalculateRewardPerBatch(&_Oldpolygonzkevm.CallOpts) +} + +// ChainID is a free data retrieval call binding the contract method 0xadc879e9. +// +// Solidity: function chainID() view returns(uint64) +func (_Oldpolygonzkevm *OldpolygonzkevmCaller) ChainID(opts *bind.CallOpts) (uint64, error) { + var out []interface{} + err := _Oldpolygonzkevm.contract.Call(opts, &out, "chainID") + + if err != nil { + return *new(uint64), err + } + + out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64) + + return out0, err + +} + +// ChainID is a free data retrieval call binding the contract method 0xadc879e9. +// +// Solidity: function chainID() view returns(uint64) +func (_Oldpolygonzkevm *OldpolygonzkevmSession) ChainID() (uint64, error) { + return _Oldpolygonzkevm.Contract.ChainID(&_Oldpolygonzkevm.CallOpts) +} + +// ChainID is a free data retrieval call binding the contract method 0xadc879e9. +// +// Solidity: function chainID() view returns(uint64) +func (_Oldpolygonzkevm *OldpolygonzkevmCallerSession) ChainID() (uint64, error) { + return _Oldpolygonzkevm.Contract.ChainID(&_Oldpolygonzkevm.CallOpts) +} + +// CheckStateRootInsidePrime is a free data retrieval call binding the contract method 0xba58ae39. +// +// Solidity: function checkStateRootInsidePrime(uint256 newStateRoot) pure returns(bool) +func (_Oldpolygonzkevm *OldpolygonzkevmCaller) CheckStateRootInsidePrime(opts *bind.CallOpts, newStateRoot *big.Int) (bool, error) { + var out []interface{} + err := _Oldpolygonzkevm.contract.Call(opts, &out, "checkStateRootInsidePrime", newStateRoot) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// CheckStateRootInsidePrime is a free data retrieval call binding the contract method 0xba58ae39. +// +// Solidity: function checkStateRootInsidePrime(uint256 newStateRoot) pure returns(bool) +func (_Oldpolygonzkevm *OldpolygonzkevmSession) CheckStateRootInsidePrime(newStateRoot *big.Int) (bool, error) { + return _Oldpolygonzkevm.Contract.CheckStateRootInsidePrime(&_Oldpolygonzkevm.CallOpts, newStateRoot) +} + +// CheckStateRootInsidePrime is a free data retrieval call binding the contract method 0xba58ae39. +// +// Solidity: function checkStateRootInsidePrime(uint256 newStateRoot) pure returns(bool) +func (_Oldpolygonzkevm *OldpolygonzkevmCallerSession) CheckStateRootInsidePrime(newStateRoot *big.Int) (bool, error) { + return _Oldpolygonzkevm.Contract.CheckStateRootInsidePrime(&_Oldpolygonzkevm.CallOpts, newStateRoot) +} + +// ForceBatchTimeout is a free data retrieval call binding the contract method 0xc754c7ed. +// +// Solidity: function forceBatchTimeout() view returns(uint64) +func (_Oldpolygonzkevm *OldpolygonzkevmCaller) ForceBatchTimeout(opts *bind.CallOpts) (uint64, error) { + var out []interface{} + err := _Oldpolygonzkevm.contract.Call(opts, &out, "forceBatchTimeout") + + if err != nil { + return *new(uint64), err + } + + out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64) + + return out0, err + +} + +// ForceBatchTimeout is a free data retrieval call binding the contract method 0xc754c7ed. +// +// Solidity: function forceBatchTimeout() view returns(uint64) +func (_Oldpolygonzkevm *OldpolygonzkevmSession) ForceBatchTimeout() (uint64, error) { + return _Oldpolygonzkevm.Contract.ForceBatchTimeout(&_Oldpolygonzkevm.CallOpts) +} + +// ForceBatchTimeout is a free data retrieval call binding the contract method 0xc754c7ed. +// +// Solidity: function forceBatchTimeout() view returns(uint64) +func (_Oldpolygonzkevm *OldpolygonzkevmCallerSession) ForceBatchTimeout() (uint64, error) { + return _Oldpolygonzkevm.Contract.ForceBatchTimeout(&_Oldpolygonzkevm.CallOpts) +} + +// ForcedBatches is a free data retrieval call binding the contract method 0x6b8616ce. +// +// Solidity: function forcedBatches(uint64 ) view returns(bytes32) +func (_Oldpolygonzkevm *OldpolygonzkevmCaller) ForcedBatches(opts *bind.CallOpts, arg0 uint64) ([32]byte, error) { + var out []interface{} + err := _Oldpolygonzkevm.contract.Call(opts, &out, "forcedBatches", arg0) + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// ForcedBatches is a free data retrieval call binding the contract method 0x6b8616ce. +// +// Solidity: function forcedBatches(uint64 ) view returns(bytes32) +func (_Oldpolygonzkevm *OldpolygonzkevmSession) ForcedBatches(arg0 uint64) ([32]byte, error) { + return _Oldpolygonzkevm.Contract.ForcedBatches(&_Oldpolygonzkevm.CallOpts, arg0) +} + +// ForcedBatches is a free data retrieval call binding the contract method 0x6b8616ce. +// +// Solidity: function forcedBatches(uint64 ) view returns(bytes32) +func (_Oldpolygonzkevm *OldpolygonzkevmCallerSession) ForcedBatches(arg0 uint64) ([32]byte, error) { + return _Oldpolygonzkevm.Contract.ForcedBatches(&_Oldpolygonzkevm.CallOpts, arg0) +} + +// ForkID is a free data retrieval call binding the contract method 0x831c7ead. +// +// Solidity: function forkID() view returns(uint64) +func (_Oldpolygonzkevm *OldpolygonzkevmCaller) ForkID(opts *bind.CallOpts) (uint64, error) { + var out []interface{} + err := _Oldpolygonzkevm.contract.Call(opts, &out, "forkID") + + if err != nil { + return *new(uint64), err + } + + out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64) + + return out0, err + +} + +// ForkID is a free data retrieval call binding the contract method 0x831c7ead. +// +// Solidity: function forkID() view returns(uint64) +func (_Oldpolygonzkevm *OldpolygonzkevmSession) ForkID() (uint64, error) { + return _Oldpolygonzkevm.Contract.ForkID(&_Oldpolygonzkevm.CallOpts) +} + +// ForkID is a free data retrieval call binding the contract method 0x831c7ead. +// +// Solidity: function forkID() view returns(uint64) +func (_Oldpolygonzkevm *OldpolygonzkevmCallerSession) ForkID() (uint64, error) { + return _Oldpolygonzkevm.Contract.ForkID(&_Oldpolygonzkevm.CallOpts) +} + +// GetForcedBatchFee is a free data retrieval call binding the contract method 0x60469169. +// +// Solidity: function getForcedBatchFee() view returns(uint256) +func (_Oldpolygonzkevm *OldpolygonzkevmCaller) GetForcedBatchFee(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _Oldpolygonzkevm.contract.Call(opts, &out, "getForcedBatchFee") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// GetForcedBatchFee is a free data retrieval call binding the contract method 0x60469169. +// +// Solidity: function getForcedBatchFee() view returns(uint256) +func (_Oldpolygonzkevm *OldpolygonzkevmSession) GetForcedBatchFee() (*big.Int, error) { + return _Oldpolygonzkevm.Contract.GetForcedBatchFee(&_Oldpolygonzkevm.CallOpts) +} + +// GetForcedBatchFee is a free data retrieval call binding the contract method 0x60469169. +// +// Solidity: function getForcedBatchFee() view returns(uint256) +func (_Oldpolygonzkevm *OldpolygonzkevmCallerSession) GetForcedBatchFee() (*big.Int, error) { + return _Oldpolygonzkevm.Contract.GetForcedBatchFee(&_Oldpolygonzkevm.CallOpts) +} + +// GetInputSnarkBytes is a free data retrieval call binding the contract method 0x220d7899. +// +// Solidity: function getInputSnarkBytes(uint64 initNumBatch, uint64 finalNewBatch, bytes32 newLocalExitRoot, bytes32 oldStateRoot, bytes32 newStateRoot) view returns(bytes) +func (_Oldpolygonzkevm *OldpolygonzkevmCaller) GetInputSnarkBytes(opts *bind.CallOpts, initNumBatch uint64, finalNewBatch uint64, newLocalExitRoot [32]byte, oldStateRoot [32]byte, newStateRoot [32]byte) ([]byte, error) { + var out []interface{} + err := _Oldpolygonzkevm.contract.Call(opts, &out, "getInputSnarkBytes", initNumBatch, finalNewBatch, newLocalExitRoot, oldStateRoot, newStateRoot) + + if err != nil { + return *new([]byte), err + } + + out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte) + + return out0, err + +} + +// GetInputSnarkBytes is a free data retrieval call binding the contract method 0x220d7899. +// +// Solidity: function getInputSnarkBytes(uint64 initNumBatch, uint64 finalNewBatch, bytes32 newLocalExitRoot, bytes32 oldStateRoot, bytes32 newStateRoot) view returns(bytes) +func (_Oldpolygonzkevm *OldpolygonzkevmSession) GetInputSnarkBytes(initNumBatch uint64, finalNewBatch uint64, newLocalExitRoot [32]byte, oldStateRoot [32]byte, newStateRoot [32]byte) ([]byte, error) { + return _Oldpolygonzkevm.Contract.GetInputSnarkBytes(&_Oldpolygonzkevm.CallOpts, initNumBatch, finalNewBatch, newLocalExitRoot, oldStateRoot, newStateRoot) +} + +// GetInputSnarkBytes is a free data retrieval call binding the contract method 0x220d7899. +// +// Solidity: function getInputSnarkBytes(uint64 initNumBatch, uint64 finalNewBatch, bytes32 newLocalExitRoot, bytes32 oldStateRoot, bytes32 newStateRoot) view returns(bytes) +func (_Oldpolygonzkevm *OldpolygonzkevmCallerSession) GetInputSnarkBytes(initNumBatch uint64, finalNewBatch uint64, newLocalExitRoot [32]byte, oldStateRoot [32]byte, newStateRoot [32]byte) ([]byte, error) { + return _Oldpolygonzkevm.Contract.GetInputSnarkBytes(&_Oldpolygonzkevm.CallOpts, initNumBatch, finalNewBatch, newLocalExitRoot, oldStateRoot, newStateRoot) +} + +// GetLastVerifiedBatch is a free data retrieval call binding the contract method 0xc0ed84e0. +// +// Solidity: function getLastVerifiedBatch() view returns(uint64) +func (_Oldpolygonzkevm *OldpolygonzkevmCaller) GetLastVerifiedBatch(opts *bind.CallOpts) (uint64, error) { + var out []interface{} + err := _Oldpolygonzkevm.contract.Call(opts, &out, "getLastVerifiedBatch") + + if err != nil { + return *new(uint64), err + } + + out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64) + + return out0, err + +} + +// GetLastVerifiedBatch is a free data retrieval call binding the contract method 0xc0ed84e0. +// +// Solidity: function getLastVerifiedBatch() view returns(uint64) +func (_Oldpolygonzkevm *OldpolygonzkevmSession) GetLastVerifiedBatch() (uint64, error) { + return _Oldpolygonzkevm.Contract.GetLastVerifiedBatch(&_Oldpolygonzkevm.CallOpts) +} + +// GetLastVerifiedBatch is a free data retrieval call binding the contract method 0xc0ed84e0. +// +// Solidity: function getLastVerifiedBatch() view returns(uint64) +func (_Oldpolygonzkevm *OldpolygonzkevmCallerSession) GetLastVerifiedBatch() (uint64, error) { + return _Oldpolygonzkevm.Contract.GetLastVerifiedBatch(&_Oldpolygonzkevm.CallOpts) +} + +// GlobalExitRootManager is a free data retrieval call binding the contract method 0xd02103ca. +// +// Solidity: function globalExitRootManager() view returns(address) +func (_Oldpolygonzkevm *OldpolygonzkevmCaller) GlobalExitRootManager(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Oldpolygonzkevm.contract.Call(opts, &out, "globalExitRootManager") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// GlobalExitRootManager is a free data retrieval call binding the contract method 0xd02103ca. +// +// Solidity: function globalExitRootManager() view returns(address) +func (_Oldpolygonzkevm *OldpolygonzkevmSession) GlobalExitRootManager() (common.Address, error) { + return _Oldpolygonzkevm.Contract.GlobalExitRootManager(&_Oldpolygonzkevm.CallOpts) +} + +// GlobalExitRootManager is a free data retrieval call binding the contract method 0xd02103ca. +// +// Solidity: function globalExitRootManager() view returns(address) +func (_Oldpolygonzkevm *OldpolygonzkevmCallerSession) GlobalExitRootManager() (common.Address, error) { + return _Oldpolygonzkevm.Contract.GlobalExitRootManager(&_Oldpolygonzkevm.CallOpts) +} + +// IsEmergencyState is a free data retrieval call binding the contract method 0x15064c96. +// +// Solidity: function isEmergencyState() view returns(bool) +func (_Oldpolygonzkevm *OldpolygonzkevmCaller) IsEmergencyState(opts *bind.CallOpts) (bool, error) { + var out []interface{} + err := _Oldpolygonzkevm.contract.Call(opts, &out, "isEmergencyState") + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// IsEmergencyState is a free data retrieval call binding the contract method 0x15064c96. +// +// Solidity: function isEmergencyState() view returns(bool) +func (_Oldpolygonzkevm *OldpolygonzkevmSession) IsEmergencyState() (bool, error) { + return _Oldpolygonzkevm.Contract.IsEmergencyState(&_Oldpolygonzkevm.CallOpts) +} + +// IsEmergencyState is a free data retrieval call binding the contract method 0x15064c96. +// +// Solidity: function isEmergencyState() view returns(bool) +func (_Oldpolygonzkevm *OldpolygonzkevmCallerSession) IsEmergencyState() (bool, error) { + return _Oldpolygonzkevm.Contract.IsEmergencyState(&_Oldpolygonzkevm.CallOpts) +} + +// IsForcedBatchDisallowed is a free data retrieval call binding the contract method 0xed6b0104. +// +// Solidity: function isForcedBatchDisallowed() view returns(bool) +func (_Oldpolygonzkevm *OldpolygonzkevmCaller) IsForcedBatchDisallowed(opts *bind.CallOpts) (bool, error) { + var out []interface{} + err := _Oldpolygonzkevm.contract.Call(opts, &out, "isForcedBatchDisallowed") + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// IsForcedBatchDisallowed is a free data retrieval call binding the contract method 0xed6b0104. +// +// Solidity: function isForcedBatchDisallowed() view returns(bool) +func (_Oldpolygonzkevm *OldpolygonzkevmSession) IsForcedBatchDisallowed() (bool, error) { + return _Oldpolygonzkevm.Contract.IsForcedBatchDisallowed(&_Oldpolygonzkevm.CallOpts) +} + +// IsForcedBatchDisallowed is a free data retrieval call binding the contract method 0xed6b0104. +// +// Solidity: function isForcedBatchDisallowed() view returns(bool) +func (_Oldpolygonzkevm *OldpolygonzkevmCallerSession) IsForcedBatchDisallowed() (bool, error) { + return _Oldpolygonzkevm.Contract.IsForcedBatchDisallowed(&_Oldpolygonzkevm.CallOpts) +} + +// IsPendingStateConsolidable is a free data retrieval call binding the contract method 0x383b3be8. +// +// Solidity: function isPendingStateConsolidable(uint64 pendingStateNum) view returns(bool) +func (_Oldpolygonzkevm *OldpolygonzkevmCaller) IsPendingStateConsolidable(opts *bind.CallOpts, pendingStateNum uint64) (bool, error) { + var out []interface{} + err := _Oldpolygonzkevm.contract.Call(opts, &out, "isPendingStateConsolidable", pendingStateNum) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// IsPendingStateConsolidable is a free data retrieval call binding the contract method 0x383b3be8. +// +// Solidity: function isPendingStateConsolidable(uint64 pendingStateNum) view returns(bool) +func (_Oldpolygonzkevm *OldpolygonzkevmSession) IsPendingStateConsolidable(pendingStateNum uint64) (bool, error) { + return _Oldpolygonzkevm.Contract.IsPendingStateConsolidable(&_Oldpolygonzkevm.CallOpts, pendingStateNum) +} + +// IsPendingStateConsolidable is a free data retrieval call binding the contract method 0x383b3be8. +// +// Solidity: function isPendingStateConsolidable(uint64 pendingStateNum) view returns(bool) +func (_Oldpolygonzkevm *OldpolygonzkevmCallerSession) IsPendingStateConsolidable(pendingStateNum uint64) (bool, error) { + return _Oldpolygonzkevm.Contract.IsPendingStateConsolidable(&_Oldpolygonzkevm.CallOpts, pendingStateNum) +} + +// LastBatchSequenced is a free data retrieval call binding the contract method 0x423fa856. +// +// Solidity: function lastBatchSequenced() view returns(uint64) +func (_Oldpolygonzkevm *OldpolygonzkevmCaller) LastBatchSequenced(opts *bind.CallOpts) (uint64, error) { + var out []interface{} + err := _Oldpolygonzkevm.contract.Call(opts, &out, "lastBatchSequenced") + + if err != nil { + return *new(uint64), err + } + + out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64) + + return out0, err + +} + +// LastBatchSequenced is a free data retrieval call binding the contract method 0x423fa856. +// +// Solidity: function lastBatchSequenced() view returns(uint64) +func (_Oldpolygonzkevm *OldpolygonzkevmSession) LastBatchSequenced() (uint64, error) { + return _Oldpolygonzkevm.Contract.LastBatchSequenced(&_Oldpolygonzkevm.CallOpts) +} + +// LastBatchSequenced is a free data retrieval call binding the contract method 0x423fa856. +// +// Solidity: function lastBatchSequenced() view returns(uint64) +func (_Oldpolygonzkevm *OldpolygonzkevmCallerSession) LastBatchSequenced() (uint64, error) { + return _Oldpolygonzkevm.Contract.LastBatchSequenced(&_Oldpolygonzkevm.CallOpts) +} + +// LastForceBatch is a free data retrieval call binding the contract method 0xe7a7ed02. +// +// Solidity: function lastForceBatch() view returns(uint64) +func (_Oldpolygonzkevm *OldpolygonzkevmCaller) LastForceBatch(opts *bind.CallOpts) (uint64, error) { + var out []interface{} + err := _Oldpolygonzkevm.contract.Call(opts, &out, "lastForceBatch") + + if err != nil { + return *new(uint64), err + } + + out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64) + + return out0, err + +} + +// LastForceBatch is a free data retrieval call binding the contract method 0xe7a7ed02. +// +// Solidity: function lastForceBatch() view returns(uint64) +func (_Oldpolygonzkevm *OldpolygonzkevmSession) LastForceBatch() (uint64, error) { + return _Oldpolygonzkevm.Contract.LastForceBatch(&_Oldpolygonzkevm.CallOpts) +} + +// LastForceBatch is a free data retrieval call binding the contract method 0xe7a7ed02. +// +// Solidity: function lastForceBatch() view returns(uint64) +func (_Oldpolygonzkevm *OldpolygonzkevmCallerSession) LastForceBatch() (uint64, error) { + return _Oldpolygonzkevm.Contract.LastForceBatch(&_Oldpolygonzkevm.CallOpts) +} + +// LastForceBatchSequenced is a free data retrieval call binding the contract method 0x45605267. +// +// Solidity: function lastForceBatchSequenced() view returns(uint64) +func (_Oldpolygonzkevm *OldpolygonzkevmCaller) LastForceBatchSequenced(opts *bind.CallOpts) (uint64, error) { + var out []interface{} + err := _Oldpolygonzkevm.contract.Call(opts, &out, "lastForceBatchSequenced") + + if err != nil { + return *new(uint64), err + } + + out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64) + + return out0, err + +} + +// LastForceBatchSequenced is a free data retrieval call binding the contract method 0x45605267. +// +// Solidity: function lastForceBatchSequenced() view returns(uint64) +func (_Oldpolygonzkevm *OldpolygonzkevmSession) LastForceBatchSequenced() (uint64, error) { + return _Oldpolygonzkevm.Contract.LastForceBatchSequenced(&_Oldpolygonzkevm.CallOpts) +} + +// LastForceBatchSequenced is a free data retrieval call binding the contract method 0x45605267. +// +// Solidity: function lastForceBatchSequenced() view returns(uint64) +func (_Oldpolygonzkevm *OldpolygonzkevmCallerSession) LastForceBatchSequenced() (uint64, error) { + return _Oldpolygonzkevm.Contract.LastForceBatchSequenced(&_Oldpolygonzkevm.CallOpts) +} + +// LastPendingState is a free data retrieval call binding the contract method 0x458c0477. +// +// Solidity: function lastPendingState() view returns(uint64) +func (_Oldpolygonzkevm *OldpolygonzkevmCaller) LastPendingState(opts *bind.CallOpts) (uint64, error) { + var out []interface{} + err := _Oldpolygonzkevm.contract.Call(opts, &out, "lastPendingState") + + if err != nil { + return *new(uint64), err + } + + out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64) + + return out0, err + +} + +// LastPendingState is a free data retrieval call binding the contract method 0x458c0477. +// +// Solidity: function lastPendingState() view returns(uint64) +func (_Oldpolygonzkevm *OldpolygonzkevmSession) LastPendingState() (uint64, error) { + return _Oldpolygonzkevm.Contract.LastPendingState(&_Oldpolygonzkevm.CallOpts) +} + +// LastPendingState is a free data retrieval call binding the contract method 0x458c0477. +// +// Solidity: function lastPendingState() view returns(uint64) +func (_Oldpolygonzkevm *OldpolygonzkevmCallerSession) LastPendingState() (uint64, error) { + return _Oldpolygonzkevm.Contract.LastPendingState(&_Oldpolygonzkevm.CallOpts) +} + +// LastPendingStateConsolidated is a free data retrieval call binding the contract method 0x4a1a89a7. +// +// Solidity: function lastPendingStateConsolidated() view returns(uint64) +func (_Oldpolygonzkevm *OldpolygonzkevmCaller) LastPendingStateConsolidated(opts *bind.CallOpts) (uint64, error) { + var out []interface{} + err := _Oldpolygonzkevm.contract.Call(opts, &out, "lastPendingStateConsolidated") + + if err != nil { + return *new(uint64), err + } + + out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64) + + return out0, err + +} + +// LastPendingStateConsolidated is a free data retrieval call binding the contract method 0x4a1a89a7. +// +// Solidity: function lastPendingStateConsolidated() view returns(uint64) +func (_Oldpolygonzkevm *OldpolygonzkevmSession) LastPendingStateConsolidated() (uint64, error) { + return _Oldpolygonzkevm.Contract.LastPendingStateConsolidated(&_Oldpolygonzkevm.CallOpts) +} + +// LastPendingStateConsolidated is a free data retrieval call binding the contract method 0x4a1a89a7. +// +// Solidity: function lastPendingStateConsolidated() view returns(uint64) +func (_Oldpolygonzkevm *OldpolygonzkevmCallerSession) LastPendingStateConsolidated() (uint64, error) { + return _Oldpolygonzkevm.Contract.LastPendingStateConsolidated(&_Oldpolygonzkevm.CallOpts) +} + +// LastTimestamp is a free data retrieval call binding the contract method 0x19d8ac61. +// +// Solidity: function lastTimestamp() view returns(uint64) +func (_Oldpolygonzkevm *OldpolygonzkevmCaller) LastTimestamp(opts *bind.CallOpts) (uint64, error) { + var out []interface{} + err := _Oldpolygonzkevm.contract.Call(opts, &out, "lastTimestamp") + + if err != nil { + return *new(uint64), err + } + + out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64) + + return out0, err + +} + +// LastTimestamp is a free data retrieval call binding the contract method 0x19d8ac61. +// +// Solidity: function lastTimestamp() view returns(uint64) +func (_Oldpolygonzkevm *OldpolygonzkevmSession) LastTimestamp() (uint64, error) { + return _Oldpolygonzkevm.Contract.LastTimestamp(&_Oldpolygonzkevm.CallOpts) +} + +// LastTimestamp is a free data retrieval call binding the contract method 0x19d8ac61. +// +// Solidity: function lastTimestamp() view returns(uint64) +func (_Oldpolygonzkevm *OldpolygonzkevmCallerSession) LastTimestamp() (uint64, error) { + return _Oldpolygonzkevm.Contract.LastTimestamp(&_Oldpolygonzkevm.CallOpts) +} + +// LastVerifiedBatch is a free data retrieval call binding the contract method 0x7fcb3653. +// +// Solidity: function lastVerifiedBatch() view returns(uint64) +func (_Oldpolygonzkevm *OldpolygonzkevmCaller) LastVerifiedBatch(opts *bind.CallOpts) (uint64, error) { + var out []interface{} + err := _Oldpolygonzkevm.contract.Call(opts, &out, "lastVerifiedBatch") + + if err != nil { + return *new(uint64), err + } + + out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64) + + return out0, err + +} + +// LastVerifiedBatch is a free data retrieval call binding the contract method 0x7fcb3653. +// +// Solidity: function lastVerifiedBatch() view returns(uint64) +func (_Oldpolygonzkevm *OldpolygonzkevmSession) LastVerifiedBatch() (uint64, error) { + return _Oldpolygonzkevm.Contract.LastVerifiedBatch(&_Oldpolygonzkevm.CallOpts) +} + +// LastVerifiedBatch is a free data retrieval call binding the contract method 0x7fcb3653. +// +// Solidity: function lastVerifiedBatch() view returns(uint64) +func (_Oldpolygonzkevm *OldpolygonzkevmCallerSession) LastVerifiedBatch() (uint64, error) { + return _Oldpolygonzkevm.Contract.LastVerifiedBatch(&_Oldpolygonzkevm.CallOpts) +} + +// Matic is a free data retrieval call binding the contract method 0xb6b0b097. +// +// Solidity: function matic() view returns(address) +func (_Oldpolygonzkevm *OldpolygonzkevmCaller) Matic(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Oldpolygonzkevm.contract.Call(opts, &out, "matic") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// Matic is a free data retrieval call binding the contract method 0xb6b0b097. +// +// Solidity: function matic() view returns(address) +func (_Oldpolygonzkevm *OldpolygonzkevmSession) Matic() (common.Address, error) { + return _Oldpolygonzkevm.Contract.Matic(&_Oldpolygonzkevm.CallOpts) +} + +// Matic is a free data retrieval call binding the contract method 0xb6b0b097. +// +// Solidity: function matic() view returns(address) +func (_Oldpolygonzkevm *OldpolygonzkevmCallerSession) Matic() (common.Address, error) { + return _Oldpolygonzkevm.Contract.Matic(&_Oldpolygonzkevm.CallOpts) +} + +// MultiplierBatchFee is a free data retrieval call binding the contract method 0xafd23cbe. +// +// Solidity: function multiplierBatchFee() view returns(uint16) +func (_Oldpolygonzkevm *OldpolygonzkevmCaller) MultiplierBatchFee(opts *bind.CallOpts) (uint16, error) { + var out []interface{} + err := _Oldpolygonzkevm.contract.Call(opts, &out, "multiplierBatchFee") + + if err != nil { + return *new(uint16), err + } + + out0 := *abi.ConvertType(out[0], new(uint16)).(*uint16) + + return out0, err + +} + +// MultiplierBatchFee is a free data retrieval call binding the contract method 0xafd23cbe. +// +// Solidity: function multiplierBatchFee() view returns(uint16) +func (_Oldpolygonzkevm *OldpolygonzkevmSession) MultiplierBatchFee() (uint16, error) { + return _Oldpolygonzkevm.Contract.MultiplierBatchFee(&_Oldpolygonzkevm.CallOpts) +} + +// MultiplierBatchFee is a free data retrieval call binding the contract method 0xafd23cbe. +// +// Solidity: function multiplierBatchFee() view returns(uint16) +func (_Oldpolygonzkevm *OldpolygonzkevmCallerSession) MultiplierBatchFee() (uint16, error) { + return _Oldpolygonzkevm.Contract.MultiplierBatchFee(&_Oldpolygonzkevm.CallOpts) +} + +// NetworkName is a free data retrieval call binding the contract method 0x107bf28c. +// +// Solidity: function networkName() view returns(string) +func (_Oldpolygonzkevm *OldpolygonzkevmCaller) NetworkName(opts *bind.CallOpts) (string, error) { + var out []interface{} + err := _Oldpolygonzkevm.contract.Call(opts, &out, "networkName") + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// NetworkName is a free data retrieval call binding the contract method 0x107bf28c. +// +// Solidity: function networkName() view returns(string) +func (_Oldpolygonzkevm *OldpolygonzkevmSession) NetworkName() (string, error) { + return _Oldpolygonzkevm.Contract.NetworkName(&_Oldpolygonzkevm.CallOpts) +} + +// NetworkName is a free data retrieval call binding the contract method 0x107bf28c. +// +// Solidity: function networkName() view returns(string) +func (_Oldpolygonzkevm *OldpolygonzkevmCallerSession) NetworkName() (string, error) { + return _Oldpolygonzkevm.Contract.NetworkName(&_Oldpolygonzkevm.CallOpts) +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_Oldpolygonzkevm *OldpolygonzkevmCaller) Owner(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Oldpolygonzkevm.contract.Call(opts, &out, "owner") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_Oldpolygonzkevm *OldpolygonzkevmSession) Owner() (common.Address, error) { + return _Oldpolygonzkevm.Contract.Owner(&_Oldpolygonzkevm.CallOpts) +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_Oldpolygonzkevm *OldpolygonzkevmCallerSession) Owner() (common.Address, error) { + return _Oldpolygonzkevm.Contract.Owner(&_Oldpolygonzkevm.CallOpts) +} + +// PendingAdmin is a free data retrieval call binding the contract method 0x26782247. +// +// Solidity: function pendingAdmin() view returns(address) +func (_Oldpolygonzkevm *OldpolygonzkevmCaller) PendingAdmin(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Oldpolygonzkevm.contract.Call(opts, &out, "pendingAdmin") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// PendingAdmin is a free data retrieval call binding the contract method 0x26782247. +// +// Solidity: function pendingAdmin() view returns(address) +func (_Oldpolygonzkevm *OldpolygonzkevmSession) PendingAdmin() (common.Address, error) { + return _Oldpolygonzkevm.Contract.PendingAdmin(&_Oldpolygonzkevm.CallOpts) +} + +// PendingAdmin is a free data retrieval call binding the contract method 0x26782247. +// +// Solidity: function pendingAdmin() view returns(address) +func (_Oldpolygonzkevm *OldpolygonzkevmCallerSession) PendingAdmin() (common.Address, error) { + return _Oldpolygonzkevm.Contract.PendingAdmin(&_Oldpolygonzkevm.CallOpts) +} + +// PendingStateTimeout is a free data retrieval call binding the contract method 0xd939b315. +// +// Solidity: function pendingStateTimeout() view returns(uint64) +func (_Oldpolygonzkevm *OldpolygonzkevmCaller) PendingStateTimeout(opts *bind.CallOpts) (uint64, error) { + var out []interface{} + err := _Oldpolygonzkevm.contract.Call(opts, &out, "pendingStateTimeout") + + if err != nil { + return *new(uint64), err + } + + out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64) + + return out0, err + +} + +// PendingStateTimeout is a free data retrieval call binding the contract method 0xd939b315. +// +// Solidity: function pendingStateTimeout() view returns(uint64) +func (_Oldpolygonzkevm *OldpolygonzkevmSession) PendingStateTimeout() (uint64, error) { + return _Oldpolygonzkevm.Contract.PendingStateTimeout(&_Oldpolygonzkevm.CallOpts) +} + +// PendingStateTimeout is a free data retrieval call binding the contract method 0xd939b315. +// +// Solidity: function pendingStateTimeout() view returns(uint64) +func (_Oldpolygonzkevm *OldpolygonzkevmCallerSession) PendingStateTimeout() (uint64, error) { + return _Oldpolygonzkevm.Contract.PendingStateTimeout(&_Oldpolygonzkevm.CallOpts) +} + +// PendingStateTransitions is a free data retrieval call binding the contract method 0x837a4738. +// +// Solidity: function pendingStateTransitions(uint256 ) view returns(uint64 timestamp, uint64 lastVerifiedBatch, bytes32 exitRoot, bytes32 stateRoot) +func (_Oldpolygonzkevm *OldpolygonzkevmCaller) PendingStateTransitions(opts *bind.CallOpts, arg0 *big.Int) (struct { + Timestamp uint64 + LastVerifiedBatch uint64 + ExitRoot [32]byte + StateRoot [32]byte +}, error) { + var out []interface{} + err := _Oldpolygonzkevm.contract.Call(opts, &out, "pendingStateTransitions", arg0) + + outstruct := new(struct { + Timestamp uint64 + LastVerifiedBatch uint64 + ExitRoot [32]byte + StateRoot [32]byte + }) + if err != nil { + return *outstruct, err + } + + outstruct.Timestamp = *abi.ConvertType(out[0], new(uint64)).(*uint64) + outstruct.LastVerifiedBatch = *abi.ConvertType(out[1], new(uint64)).(*uint64) + outstruct.ExitRoot = *abi.ConvertType(out[2], new([32]byte)).(*[32]byte) + outstruct.StateRoot = *abi.ConvertType(out[3], new([32]byte)).(*[32]byte) + + return *outstruct, err + +} + +// PendingStateTransitions is a free data retrieval call binding the contract method 0x837a4738. +// +// Solidity: function pendingStateTransitions(uint256 ) view returns(uint64 timestamp, uint64 lastVerifiedBatch, bytes32 exitRoot, bytes32 stateRoot) +func (_Oldpolygonzkevm *OldpolygonzkevmSession) PendingStateTransitions(arg0 *big.Int) (struct { + Timestamp uint64 + LastVerifiedBatch uint64 + ExitRoot [32]byte + StateRoot [32]byte +}, error) { + return _Oldpolygonzkevm.Contract.PendingStateTransitions(&_Oldpolygonzkevm.CallOpts, arg0) +} + +// PendingStateTransitions is a free data retrieval call binding the contract method 0x837a4738. +// +// Solidity: function pendingStateTransitions(uint256 ) view returns(uint64 timestamp, uint64 lastVerifiedBatch, bytes32 exitRoot, bytes32 stateRoot) +func (_Oldpolygonzkevm *OldpolygonzkevmCallerSession) PendingStateTransitions(arg0 *big.Int) (struct { + Timestamp uint64 + LastVerifiedBatch uint64 + ExitRoot [32]byte + StateRoot [32]byte +}, error) { + return _Oldpolygonzkevm.Contract.PendingStateTransitions(&_Oldpolygonzkevm.CallOpts, arg0) +} + +// RollupVerifier is a free data retrieval call binding the contract method 0xe8bf92ed. +// +// Solidity: function rollupVerifier() view returns(address) +func (_Oldpolygonzkevm *OldpolygonzkevmCaller) RollupVerifier(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Oldpolygonzkevm.contract.Call(opts, &out, "rollupVerifier") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// RollupVerifier is a free data retrieval call binding the contract method 0xe8bf92ed. +// +// Solidity: function rollupVerifier() view returns(address) +func (_Oldpolygonzkevm *OldpolygonzkevmSession) RollupVerifier() (common.Address, error) { + return _Oldpolygonzkevm.Contract.RollupVerifier(&_Oldpolygonzkevm.CallOpts) +} + +// RollupVerifier is a free data retrieval call binding the contract method 0xe8bf92ed. +// +// Solidity: function rollupVerifier() view returns(address) +func (_Oldpolygonzkevm *OldpolygonzkevmCallerSession) RollupVerifier() (common.Address, error) { + return _Oldpolygonzkevm.Contract.RollupVerifier(&_Oldpolygonzkevm.CallOpts) +} + +// SequencedBatches is a free data retrieval call binding the contract method 0xb4d63f58. +// +// Solidity: function sequencedBatches(uint64 ) view returns(bytes32 accInputHash, uint64 sequencedTimestamp, uint64 previousLastBatchSequenced) +func (_Oldpolygonzkevm *OldpolygonzkevmCaller) SequencedBatches(opts *bind.CallOpts, arg0 uint64) (struct { + AccInputHash [32]byte + SequencedTimestamp uint64 + PreviousLastBatchSequenced uint64 +}, error) { + var out []interface{} + err := _Oldpolygonzkevm.contract.Call(opts, &out, "sequencedBatches", arg0) + + outstruct := new(struct { + AccInputHash [32]byte + SequencedTimestamp uint64 + PreviousLastBatchSequenced uint64 + }) + if err != nil { + return *outstruct, err + } + + outstruct.AccInputHash = *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + outstruct.SequencedTimestamp = *abi.ConvertType(out[1], new(uint64)).(*uint64) + outstruct.PreviousLastBatchSequenced = *abi.ConvertType(out[2], new(uint64)).(*uint64) + + return *outstruct, err + +} + +// SequencedBatches is a free data retrieval call binding the contract method 0xb4d63f58. +// +// Solidity: function sequencedBatches(uint64 ) view returns(bytes32 accInputHash, uint64 sequencedTimestamp, uint64 previousLastBatchSequenced) +func (_Oldpolygonzkevm *OldpolygonzkevmSession) SequencedBatches(arg0 uint64) (struct { + AccInputHash [32]byte + SequencedTimestamp uint64 + PreviousLastBatchSequenced uint64 +}, error) { + return _Oldpolygonzkevm.Contract.SequencedBatches(&_Oldpolygonzkevm.CallOpts, arg0) +} + +// SequencedBatches is a free data retrieval call binding the contract method 0xb4d63f58. +// +// Solidity: function sequencedBatches(uint64 ) view returns(bytes32 accInputHash, uint64 sequencedTimestamp, uint64 previousLastBatchSequenced) +func (_Oldpolygonzkevm *OldpolygonzkevmCallerSession) SequencedBatches(arg0 uint64) (struct { + AccInputHash [32]byte + SequencedTimestamp uint64 + PreviousLastBatchSequenced uint64 +}, error) { + return _Oldpolygonzkevm.Contract.SequencedBatches(&_Oldpolygonzkevm.CallOpts, arg0) +} + +// TrustedAggregator is a free data retrieval call binding the contract method 0x29878983. +// +// Solidity: function trustedAggregator() view returns(address) +func (_Oldpolygonzkevm *OldpolygonzkevmCaller) TrustedAggregator(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Oldpolygonzkevm.contract.Call(opts, &out, "trustedAggregator") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// TrustedAggregator is a free data retrieval call binding the contract method 0x29878983. +// +// Solidity: function trustedAggregator() view returns(address) +func (_Oldpolygonzkevm *OldpolygonzkevmSession) TrustedAggregator() (common.Address, error) { + return _Oldpolygonzkevm.Contract.TrustedAggregator(&_Oldpolygonzkevm.CallOpts) +} + +// TrustedAggregator is a free data retrieval call binding the contract method 0x29878983. +// +// Solidity: function trustedAggregator() view returns(address) +func (_Oldpolygonzkevm *OldpolygonzkevmCallerSession) TrustedAggregator() (common.Address, error) { + return _Oldpolygonzkevm.Contract.TrustedAggregator(&_Oldpolygonzkevm.CallOpts) +} + +// TrustedAggregatorTimeout is a free data retrieval call binding the contract method 0x841b24d7. +// +// Solidity: function trustedAggregatorTimeout() view returns(uint64) +func (_Oldpolygonzkevm *OldpolygonzkevmCaller) TrustedAggregatorTimeout(opts *bind.CallOpts) (uint64, error) { + var out []interface{} + err := _Oldpolygonzkevm.contract.Call(opts, &out, "trustedAggregatorTimeout") + + if err != nil { + return *new(uint64), err + } + + out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64) + + return out0, err + +} + +// TrustedAggregatorTimeout is a free data retrieval call binding the contract method 0x841b24d7. +// +// Solidity: function trustedAggregatorTimeout() view returns(uint64) +func (_Oldpolygonzkevm *OldpolygonzkevmSession) TrustedAggregatorTimeout() (uint64, error) { + return _Oldpolygonzkevm.Contract.TrustedAggregatorTimeout(&_Oldpolygonzkevm.CallOpts) +} + +// TrustedAggregatorTimeout is a free data retrieval call binding the contract method 0x841b24d7. +// +// Solidity: function trustedAggregatorTimeout() view returns(uint64) +func (_Oldpolygonzkevm *OldpolygonzkevmCallerSession) TrustedAggregatorTimeout() (uint64, error) { + return _Oldpolygonzkevm.Contract.TrustedAggregatorTimeout(&_Oldpolygonzkevm.CallOpts) +} + +// TrustedSequencer is a free data retrieval call binding the contract method 0xcfa8ed47. +// +// Solidity: function trustedSequencer() view returns(address) +func (_Oldpolygonzkevm *OldpolygonzkevmCaller) TrustedSequencer(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Oldpolygonzkevm.contract.Call(opts, &out, "trustedSequencer") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// TrustedSequencer is a free data retrieval call binding the contract method 0xcfa8ed47. +// +// Solidity: function trustedSequencer() view returns(address) +func (_Oldpolygonzkevm *OldpolygonzkevmSession) TrustedSequencer() (common.Address, error) { + return _Oldpolygonzkevm.Contract.TrustedSequencer(&_Oldpolygonzkevm.CallOpts) +} + +// TrustedSequencer is a free data retrieval call binding the contract method 0xcfa8ed47. +// +// Solidity: function trustedSequencer() view returns(address) +func (_Oldpolygonzkevm *OldpolygonzkevmCallerSession) TrustedSequencer() (common.Address, error) { + return _Oldpolygonzkevm.Contract.TrustedSequencer(&_Oldpolygonzkevm.CallOpts) +} + +// TrustedSequencerURL is a free data retrieval call binding the contract method 0x542028d5. +// +// Solidity: function trustedSequencerURL() view returns(string) +func (_Oldpolygonzkevm *OldpolygonzkevmCaller) TrustedSequencerURL(opts *bind.CallOpts) (string, error) { + var out []interface{} + err := _Oldpolygonzkevm.contract.Call(opts, &out, "trustedSequencerURL") + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// TrustedSequencerURL is a free data retrieval call binding the contract method 0x542028d5. +// +// Solidity: function trustedSequencerURL() view returns(string) +func (_Oldpolygonzkevm *OldpolygonzkevmSession) TrustedSequencerURL() (string, error) { + return _Oldpolygonzkevm.Contract.TrustedSequencerURL(&_Oldpolygonzkevm.CallOpts) +} + +// TrustedSequencerURL is a free data retrieval call binding the contract method 0x542028d5. +// +// Solidity: function trustedSequencerURL() view returns(string) +func (_Oldpolygonzkevm *OldpolygonzkevmCallerSession) TrustedSequencerURL() (string, error) { + return _Oldpolygonzkevm.Contract.TrustedSequencerURL(&_Oldpolygonzkevm.CallOpts) +} + +// VerifyBatchTimeTarget is a free data retrieval call binding the contract method 0x0a0d9fbe. +// +// Solidity: function verifyBatchTimeTarget() view returns(uint64) +func (_Oldpolygonzkevm *OldpolygonzkevmCaller) VerifyBatchTimeTarget(opts *bind.CallOpts) (uint64, error) { + var out []interface{} + err := _Oldpolygonzkevm.contract.Call(opts, &out, "verifyBatchTimeTarget") + + if err != nil { + return *new(uint64), err + } + + out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64) + + return out0, err + +} + +// VerifyBatchTimeTarget is a free data retrieval call binding the contract method 0x0a0d9fbe. +// +// Solidity: function verifyBatchTimeTarget() view returns(uint64) +func (_Oldpolygonzkevm *OldpolygonzkevmSession) VerifyBatchTimeTarget() (uint64, error) { + return _Oldpolygonzkevm.Contract.VerifyBatchTimeTarget(&_Oldpolygonzkevm.CallOpts) +} + +// VerifyBatchTimeTarget is a free data retrieval call binding the contract method 0x0a0d9fbe. +// +// Solidity: function verifyBatchTimeTarget() view returns(uint64) +func (_Oldpolygonzkevm *OldpolygonzkevmCallerSession) VerifyBatchTimeTarget() (uint64, error) { + return _Oldpolygonzkevm.Contract.VerifyBatchTimeTarget(&_Oldpolygonzkevm.CallOpts) +} + +// AcceptAdminRole is a paid mutator transaction binding the contract method 0x8c3d7301. +// +// Solidity: function acceptAdminRole() returns() +func (_Oldpolygonzkevm *OldpolygonzkevmTransactor) AcceptAdminRole(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Oldpolygonzkevm.contract.Transact(opts, "acceptAdminRole") +} + +// AcceptAdminRole is a paid mutator transaction binding the contract method 0x8c3d7301. +// +// Solidity: function acceptAdminRole() returns() +func (_Oldpolygonzkevm *OldpolygonzkevmSession) AcceptAdminRole() (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.AcceptAdminRole(&_Oldpolygonzkevm.TransactOpts) +} + +// AcceptAdminRole is a paid mutator transaction binding the contract method 0x8c3d7301. +// +// Solidity: function acceptAdminRole() returns() +func (_Oldpolygonzkevm *OldpolygonzkevmTransactorSession) AcceptAdminRole() (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.AcceptAdminRole(&_Oldpolygonzkevm.TransactOpts) +} + +// ActivateEmergencyState is a paid mutator transaction binding the contract method 0x7215541a. +// +// Solidity: function activateEmergencyState(uint64 sequencedBatchNum) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmTransactor) ActivateEmergencyState(opts *bind.TransactOpts, sequencedBatchNum uint64) (*types.Transaction, error) { + return _Oldpolygonzkevm.contract.Transact(opts, "activateEmergencyState", sequencedBatchNum) +} + +// ActivateEmergencyState is a paid mutator transaction binding the contract method 0x7215541a. +// +// Solidity: function activateEmergencyState(uint64 sequencedBatchNum) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmSession) ActivateEmergencyState(sequencedBatchNum uint64) (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.ActivateEmergencyState(&_Oldpolygonzkevm.TransactOpts, sequencedBatchNum) +} + +// ActivateEmergencyState is a paid mutator transaction binding the contract method 0x7215541a. +// +// Solidity: function activateEmergencyState(uint64 sequencedBatchNum) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmTransactorSession) ActivateEmergencyState(sequencedBatchNum uint64) (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.ActivateEmergencyState(&_Oldpolygonzkevm.TransactOpts, sequencedBatchNum) +} + +// ActivateForceBatches is a paid mutator transaction binding the contract method 0x5ec91958. +// +// Solidity: function activateForceBatches() returns() +func (_Oldpolygonzkevm *OldpolygonzkevmTransactor) ActivateForceBatches(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Oldpolygonzkevm.contract.Transact(opts, "activateForceBatches") +} + +// ActivateForceBatches is a paid mutator transaction binding the contract method 0x5ec91958. +// +// Solidity: function activateForceBatches() returns() +func (_Oldpolygonzkevm *OldpolygonzkevmSession) ActivateForceBatches() (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.ActivateForceBatches(&_Oldpolygonzkevm.TransactOpts) +} + +// ActivateForceBatches is a paid mutator transaction binding the contract method 0x5ec91958. +// +// Solidity: function activateForceBatches() returns() +func (_Oldpolygonzkevm *OldpolygonzkevmTransactorSession) ActivateForceBatches() (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.ActivateForceBatches(&_Oldpolygonzkevm.TransactOpts) +} + +// ConsolidatePendingState is a paid mutator transaction binding the contract method 0x4a910e6a. +// +// Solidity: function consolidatePendingState(uint64 pendingStateNum) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmTransactor) ConsolidatePendingState(opts *bind.TransactOpts, pendingStateNum uint64) (*types.Transaction, error) { + return _Oldpolygonzkevm.contract.Transact(opts, "consolidatePendingState", pendingStateNum) +} + +// ConsolidatePendingState is a paid mutator transaction binding the contract method 0x4a910e6a. +// +// Solidity: function consolidatePendingState(uint64 pendingStateNum) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmSession) ConsolidatePendingState(pendingStateNum uint64) (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.ConsolidatePendingState(&_Oldpolygonzkevm.TransactOpts, pendingStateNum) +} + +// ConsolidatePendingState is a paid mutator transaction binding the contract method 0x4a910e6a. +// +// Solidity: function consolidatePendingState(uint64 pendingStateNum) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmTransactorSession) ConsolidatePendingState(pendingStateNum uint64) (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.ConsolidatePendingState(&_Oldpolygonzkevm.TransactOpts, pendingStateNum) +} + +// DeactivateEmergencyState is a paid mutator transaction binding the contract method 0xdbc16976. +// +// Solidity: function deactivateEmergencyState() returns() +func (_Oldpolygonzkevm *OldpolygonzkevmTransactor) DeactivateEmergencyState(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Oldpolygonzkevm.contract.Transact(opts, "deactivateEmergencyState") +} + +// DeactivateEmergencyState is a paid mutator transaction binding the contract method 0xdbc16976. +// +// Solidity: function deactivateEmergencyState() returns() +func (_Oldpolygonzkevm *OldpolygonzkevmSession) DeactivateEmergencyState() (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.DeactivateEmergencyState(&_Oldpolygonzkevm.TransactOpts) +} + +// DeactivateEmergencyState is a paid mutator transaction binding the contract method 0xdbc16976. +// +// Solidity: function deactivateEmergencyState() returns() +func (_Oldpolygonzkevm *OldpolygonzkevmTransactorSession) DeactivateEmergencyState() (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.DeactivateEmergencyState(&_Oldpolygonzkevm.TransactOpts) +} + +// ForceBatch is a paid mutator transaction binding the contract method 0xeaeb077b. +// +// Solidity: function forceBatch(bytes transactions, uint256 maticAmount) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmTransactor) ForceBatch(opts *bind.TransactOpts, transactions []byte, maticAmount *big.Int) (*types.Transaction, error) { + return _Oldpolygonzkevm.contract.Transact(opts, "forceBatch", transactions, maticAmount) +} + +// ForceBatch is a paid mutator transaction binding the contract method 0xeaeb077b. +// +// Solidity: function forceBatch(bytes transactions, uint256 maticAmount) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmSession) ForceBatch(transactions []byte, maticAmount *big.Int) (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.ForceBatch(&_Oldpolygonzkevm.TransactOpts, transactions, maticAmount) +} + +// ForceBatch is a paid mutator transaction binding the contract method 0xeaeb077b. +// +// Solidity: function forceBatch(bytes transactions, uint256 maticAmount) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmTransactorSession) ForceBatch(transactions []byte, maticAmount *big.Int) (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.ForceBatch(&_Oldpolygonzkevm.TransactOpts, transactions, maticAmount) +} + +// Initialize is a paid mutator transaction binding the contract method 0xd2e129f9. +// +// Solidity: function initialize((address,address,uint64,address,uint64) initializePackedParameters, bytes32 genesisRoot, string _trustedSequencerURL, string _networkName, string _version) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmTransactor) Initialize(opts *bind.TransactOpts, initializePackedParameters PolygonZkEVMInitializePackedParameters, genesisRoot [32]byte, _trustedSequencerURL string, _networkName string, _version string) (*types.Transaction, error) { + return _Oldpolygonzkevm.contract.Transact(opts, "initialize", initializePackedParameters, genesisRoot, _trustedSequencerURL, _networkName, _version) +} + +// Initialize is a paid mutator transaction binding the contract method 0xd2e129f9. +// +// Solidity: function initialize((address,address,uint64,address,uint64) initializePackedParameters, bytes32 genesisRoot, string _trustedSequencerURL, string _networkName, string _version) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmSession) Initialize(initializePackedParameters PolygonZkEVMInitializePackedParameters, genesisRoot [32]byte, _trustedSequencerURL string, _networkName string, _version string) (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.Initialize(&_Oldpolygonzkevm.TransactOpts, initializePackedParameters, genesisRoot, _trustedSequencerURL, _networkName, _version) +} + +// Initialize is a paid mutator transaction binding the contract method 0xd2e129f9. +// +// Solidity: function initialize((address,address,uint64,address,uint64) initializePackedParameters, bytes32 genesisRoot, string _trustedSequencerURL, string _networkName, string _version) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmTransactorSession) Initialize(initializePackedParameters PolygonZkEVMInitializePackedParameters, genesisRoot [32]byte, _trustedSequencerURL string, _networkName string, _version string) (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.Initialize(&_Oldpolygonzkevm.TransactOpts, initializePackedParameters, genesisRoot, _trustedSequencerURL, _networkName, _version) +} + +// OverridePendingState is a paid mutator transaction binding the contract method 0x2c1f816a. +// +// Solidity: function overridePendingState(uint64 initPendingStateNum, uint64 finalPendingStateNum, uint64 initNumBatch, uint64 finalNewBatch, bytes32 newLocalExitRoot, bytes32 newStateRoot, bytes32[24] proof) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmTransactor) OverridePendingState(opts *bind.TransactOpts, initPendingStateNum uint64, finalPendingStateNum uint64, initNumBatch uint64, finalNewBatch uint64, newLocalExitRoot [32]byte, newStateRoot [32]byte, proof [24][32]byte) (*types.Transaction, error) { + return _Oldpolygonzkevm.contract.Transact(opts, "overridePendingState", initPendingStateNum, finalPendingStateNum, initNumBatch, finalNewBatch, newLocalExitRoot, newStateRoot, proof) +} + +// OverridePendingState is a paid mutator transaction binding the contract method 0x2c1f816a. +// +// Solidity: function overridePendingState(uint64 initPendingStateNum, uint64 finalPendingStateNum, uint64 initNumBatch, uint64 finalNewBatch, bytes32 newLocalExitRoot, bytes32 newStateRoot, bytes32[24] proof) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmSession) OverridePendingState(initPendingStateNum uint64, finalPendingStateNum uint64, initNumBatch uint64, finalNewBatch uint64, newLocalExitRoot [32]byte, newStateRoot [32]byte, proof [24][32]byte) (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.OverridePendingState(&_Oldpolygonzkevm.TransactOpts, initPendingStateNum, finalPendingStateNum, initNumBatch, finalNewBatch, newLocalExitRoot, newStateRoot, proof) +} + +// OverridePendingState is a paid mutator transaction binding the contract method 0x2c1f816a. +// +// Solidity: function overridePendingState(uint64 initPendingStateNum, uint64 finalPendingStateNum, uint64 initNumBatch, uint64 finalNewBatch, bytes32 newLocalExitRoot, bytes32 newStateRoot, bytes32[24] proof) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmTransactorSession) OverridePendingState(initPendingStateNum uint64, finalPendingStateNum uint64, initNumBatch uint64, finalNewBatch uint64, newLocalExitRoot [32]byte, newStateRoot [32]byte, proof [24][32]byte) (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.OverridePendingState(&_Oldpolygonzkevm.TransactOpts, initPendingStateNum, finalPendingStateNum, initNumBatch, finalNewBatch, newLocalExitRoot, newStateRoot, proof) +} + +// ProveNonDeterministicPendingState is a paid mutator transaction binding the contract method 0x9aa972a3. +// +// Solidity: function proveNonDeterministicPendingState(uint64 initPendingStateNum, uint64 finalPendingStateNum, uint64 initNumBatch, uint64 finalNewBatch, bytes32 newLocalExitRoot, bytes32 newStateRoot, bytes32[24] proof) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmTransactor) ProveNonDeterministicPendingState(opts *bind.TransactOpts, initPendingStateNum uint64, finalPendingStateNum uint64, initNumBatch uint64, finalNewBatch uint64, newLocalExitRoot [32]byte, newStateRoot [32]byte, proof [24][32]byte) (*types.Transaction, error) { + return _Oldpolygonzkevm.contract.Transact(opts, "proveNonDeterministicPendingState", initPendingStateNum, finalPendingStateNum, initNumBatch, finalNewBatch, newLocalExitRoot, newStateRoot, proof) +} + +// ProveNonDeterministicPendingState is a paid mutator transaction binding the contract method 0x9aa972a3. +// +// Solidity: function proveNonDeterministicPendingState(uint64 initPendingStateNum, uint64 finalPendingStateNum, uint64 initNumBatch, uint64 finalNewBatch, bytes32 newLocalExitRoot, bytes32 newStateRoot, bytes32[24] proof) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmSession) ProveNonDeterministicPendingState(initPendingStateNum uint64, finalPendingStateNum uint64, initNumBatch uint64, finalNewBatch uint64, newLocalExitRoot [32]byte, newStateRoot [32]byte, proof [24][32]byte) (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.ProveNonDeterministicPendingState(&_Oldpolygonzkevm.TransactOpts, initPendingStateNum, finalPendingStateNum, initNumBatch, finalNewBatch, newLocalExitRoot, newStateRoot, proof) +} + +// ProveNonDeterministicPendingState is a paid mutator transaction binding the contract method 0x9aa972a3. +// +// Solidity: function proveNonDeterministicPendingState(uint64 initPendingStateNum, uint64 finalPendingStateNum, uint64 initNumBatch, uint64 finalNewBatch, bytes32 newLocalExitRoot, bytes32 newStateRoot, bytes32[24] proof) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmTransactorSession) ProveNonDeterministicPendingState(initPendingStateNum uint64, finalPendingStateNum uint64, initNumBatch uint64, finalNewBatch uint64, newLocalExitRoot [32]byte, newStateRoot [32]byte, proof [24][32]byte) (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.ProveNonDeterministicPendingState(&_Oldpolygonzkevm.TransactOpts, initPendingStateNum, finalPendingStateNum, initNumBatch, finalNewBatch, newLocalExitRoot, newStateRoot, proof) +} + +// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. +// +// Solidity: function renounceOwnership() returns() +func (_Oldpolygonzkevm *OldpolygonzkevmTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Oldpolygonzkevm.contract.Transact(opts, "renounceOwnership") +} + +// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. +// +// Solidity: function renounceOwnership() returns() +func (_Oldpolygonzkevm *OldpolygonzkevmSession) RenounceOwnership() (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.RenounceOwnership(&_Oldpolygonzkevm.TransactOpts) +} + +// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. +// +// Solidity: function renounceOwnership() returns() +func (_Oldpolygonzkevm *OldpolygonzkevmTransactorSession) RenounceOwnership() (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.RenounceOwnership(&_Oldpolygonzkevm.TransactOpts) +} + +// SequenceBatches is a paid mutator transaction binding the contract method 0x5e9145c9. +// +// Solidity: function sequenceBatches((bytes,bytes32,uint64,uint64)[] batches, address l2Coinbase) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmTransactor) SequenceBatches(opts *bind.TransactOpts, batches []PolygonZkEVMBatchData, l2Coinbase common.Address) (*types.Transaction, error) { + return _Oldpolygonzkevm.contract.Transact(opts, "sequenceBatches", batches, l2Coinbase) +} + +// SequenceBatches is a paid mutator transaction binding the contract method 0x5e9145c9. +// +// Solidity: function sequenceBatches((bytes,bytes32,uint64,uint64)[] batches, address l2Coinbase) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmSession) SequenceBatches(batches []PolygonZkEVMBatchData, l2Coinbase common.Address) (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.SequenceBatches(&_Oldpolygonzkevm.TransactOpts, batches, l2Coinbase) +} + +// SequenceBatches is a paid mutator transaction binding the contract method 0x5e9145c9. +// +// Solidity: function sequenceBatches((bytes,bytes32,uint64,uint64)[] batches, address l2Coinbase) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmTransactorSession) SequenceBatches(batches []PolygonZkEVMBatchData, l2Coinbase common.Address) (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.SequenceBatches(&_Oldpolygonzkevm.TransactOpts, batches, l2Coinbase) +} + +// SequenceForceBatches is a paid mutator transaction binding the contract method 0xd8d1091b. +// +// Solidity: function sequenceForceBatches((bytes,bytes32,uint64)[] batches) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmTransactor) SequenceForceBatches(opts *bind.TransactOpts, batches []PolygonZkEVMForcedBatchData) (*types.Transaction, error) { + return _Oldpolygonzkevm.contract.Transact(opts, "sequenceForceBatches", batches) +} + +// SequenceForceBatches is a paid mutator transaction binding the contract method 0xd8d1091b. +// +// Solidity: function sequenceForceBatches((bytes,bytes32,uint64)[] batches) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmSession) SequenceForceBatches(batches []PolygonZkEVMForcedBatchData) (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.SequenceForceBatches(&_Oldpolygonzkevm.TransactOpts, batches) +} + +// SequenceForceBatches is a paid mutator transaction binding the contract method 0xd8d1091b. +// +// Solidity: function sequenceForceBatches((bytes,bytes32,uint64)[] batches) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmTransactorSession) SequenceForceBatches(batches []PolygonZkEVMForcedBatchData) (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.SequenceForceBatches(&_Oldpolygonzkevm.TransactOpts, batches) +} + +// SetForceBatchTimeout is a paid mutator transaction binding the contract method 0x4e487706. +// +// Solidity: function setForceBatchTimeout(uint64 newforceBatchTimeout) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmTransactor) SetForceBatchTimeout(opts *bind.TransactOpts, newforceBatchTimeout uint64) (*types.Transaction, error) { + return _Oldpolygonzkevm.contract.Transact(opts, "setForceBatchTimeout", newforceBatchTimeout) +} + +// SetForceBatchTimeout is a paid mutator transaction binding the contract method 0x4e487706. +// +// Solidity: function setForceBatchTimeout(uint64 newforceBatchTimeout) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmSession) SetForceBatchTimeout(newforceBatchTimeout uint64) (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.SetForceBatchTimeout(&_Oldpolygonzkevm.TransactOpts, newforceBatchTimeout) +} + +// SetForceBatchTimeout is a paid mutator transaction binding the contract method 0x4e487706. +// +// Solidity: function setForceBatchTimeout(uint64 newforceBatchTimeout) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmTransactorSession) SetForceBatchTimeout(newforceBatchTimeout uint64) (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.SetForceBatchTimeout(&_Oldpolygonzkevm.TransactOpts, newforceBatchTimeout) +} + +// SetMultiplierBatchFee is a paid mutator transaction binding the contract method 0x1816b7e5. +// +// Solidity: function setMultiplierBatchFee(uint16 newMultiplierBatchFee) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmTransactor) SetMultiplierBatchFee(opts *bind.TransactOpts, newMultiplierBatchFee uint16) (*types.Transaction, error) { + return _Oldpolygonzkevm.contract.Transact(opts, "setMultiplierBatchFee", newMultiplierBatchFee) +} + +// SetMultiplierBatchFee is a paid mutator transaction binding the contract method 0x1816b7e5. +// +// Solidity: function setMultiplierBatchFee(uint16 newMultiplierBatchFee) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmSession) SetMultiplierBatchFee(newMultiplierBatchFee uint16) (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.SetMultiplierBatchFee(&_Oldpolygonzkevm.TransactOpts, newMultiplierBatchFee) +} + +// SetMultiplierBatchFee is a paid mutator transaction binding the contract method 0x1816b7e5. +// +// Solidity: function setMultiplierBatchFee(uint16 newMultiplierBatchFee) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmTransactorSession) SetMultiplierBatchFee(newMultiplierBatchFee uint16) (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.SetMultiplierBatchFee(&_Oldpolygonzkevm.TransactOpts, newMultiplierBatchFee) +} + +// SetPendingStateTimeout is a paid mutator transaction binding the contract method 0x9c9f3dfe. +// +// Solidity: function setPendingStateTimeout(uint64 newPendingStateTimeout) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmTransactor) SetPendingStateTimeout(opts *bind.TransactOpts, newPendingStateTimeout uint64) (*types.Transaction, error) { + return _Oldpolygonzkevm.contract.Transact(opts, "setPendingStateTimeout", newPendingStateTimeout) +} + +// SetPendingStateTimeout is a paid mutator transaction binding the contract method 0x9c9f3dfe. +// +// Solidity: function setPendingStateTimeout(uint64 newPendingStateTimeout) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmSession) SetPendingStateTimeout(newPendingStateTimeout uint64) (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.SetPendingStateTimeout(&_Oldpolygonzkevm.TransactOpts, newPendingStateTimeout) +} + +// SetPendingStateTimeout is a paid mutator transaction binding the contract method 0x9c9f3dfe. +// +// Solidity: function setPendingStateTimeout(uint64 newPendingStateTimeout) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmTransactorSession) SetPendingStateTimeout(newPendingStateTimeout uint64) (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.SetPendingStateTimeout(&_Oldpolygonzkevm.TransactOpts, newPendingStateTimeout) +} + +// SetTrustedAggregator is a paid mutator transaction binding the contract method 0xf14916d6. +// +// Solidity: function setTrustedAggregator(address newTrustedAggregator) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmTransactor) SetTrustedAggregator(opts *bind.TransactOpts, newTrustedAggregator common.Address) (*types.Transaction, error) { + return _Oldpolygonzkevm.contract.Transact(opts, "setTrustedAggregator", newTrustedAggregator) +} + +// SetTrustedAggregator is a paid mutator transaction binding the contract method 0xf14916d6. +// +// Solidity: function setTrustedAggregator(address newTrustedAggregator) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmSession) SetTrustedAggregator(newTrustedAggregator common.Address) (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.SetTrustedAggregator(&_Oldpolygonzkevm.TransactOpts, newTrustedAggregator) +} + +// SetTrustedAggregator is a paid mutator transaction binding the contract method 0xf14916d6. +// +// Solidity: function setTrustedAggregator(address newTrustedAggregator) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmTransactorSession) SetTrustedAggregator(newTrustedAggregator common.Address) (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.SetTrustedAggregator(&_Oldpolygonzkevm.TransactOpts, newTrustedAggregator) +} + +// SetTrustedAggregatorTimeout is a paid mutator transaction binding the contract method 0x394218e9. +// +// Solidity: function setTrustedAggregatorTimeout(uint64 newTrustedAggregatorTimeout) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmTransactor) SetTrustedAggregatorTimeout(opts *bind.TransactOpts, newTrustedAggregatorTimeout uint64) (*types.Transaction, error) { + return _Oldpolygonzkevm.contract.Transact(opts, "setTrustedAggregatorTimeout", newTrustedAggregatorTimeout) +} + +// SetTrustedAggregatorTimeout is a paid mutator transaction binding the contract method 0x394218e9. +// +// Solidity: function setTrustedAggregatorTimeout(uint64 newTrustedAggregatorTimeout) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmSession) SetTrustedAggregatorTimeout(newTrustedAggregatorTimeout uint64) (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.SetTrustedAggregatorTimeout(&_Oldpolygonzkevm.TransactOpts, newTrustedAggregatorTimeout) +} + +// SetTrustedAggregatorTimeout is a paid mutator transaction binding the contract method 0x394218e9. +// +// Solidity: function setTrustedAggregatorTimeout(uint64 newTrustedAggregatorTimeout) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmTransactorSession) SetTrustedAggregatorTimeout(newTrustedAggregatorTimeout uint64) (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.SetTrustedAggregatorTimeout(&_Oldpolygonzkevm.TransactOpts, newTrustedAggregatorTimeout) +} + +// SetTrustedSequencer is a paid mutator transaction binding the contract method 0x6ff512cc. +// +// Solidity: function setTrustedSequencer(address newTrustedSequencer) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmTransactor) SetTrustedSequencer(opts *bind.TransactOpts, newTrustedSequencer common.Address) (*types.Transaction, error) { + return _Oldpolygonzkevm.contract.Transact(opts, "setTrustedSequencer", newTrustedSequencer) +} + +// SetTrustedSequencer is a paid mutator transaction binding the contract method 0x6ff512cc. +// +// Solidity: function setTrustedSequencer(address newTrustedSequencer) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmSession) SetTrustedSequencer(newTrustedSequencer common.Address) (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.SetTrustedSequencer(&_Oldpolygonzkevm.TransactOpts, newTrustedSequencer) +} + +// SetTrustedSequencer is a paid mutator transaction binding the contract method 0x6ff512cc. +// +// Solidity: function setTrustedSequencer(address newTrustedSequencer) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmTransactorSession) SetTrustedSequencer(newTrustedSequencer common.Address) (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.SetTrustedSequencer(&_Oldpolygonzkevm.TransactOpts, newTrustedSequencer) +} + +// SetTrustedSequencerURL is a paid mutator transaction binding the contract method 0xc89e42df. +// +// Solidity: function setTrustedSequencerURL(string newTrustedSequencerURL) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmTransactor) SetTrustedSequencerURL(opts *bind.TransactOpts, newTrustedSequencerURL string) (*types.Transaction, error) { + return _Oldpolygonzkevm.contract.Transact(opts, "setTrustedSequencerURL", newTrustedSequencerURL) +} + +// SetTrustedSequencerURL is a paid mutator transaction binding the contract method 0xc89e42df. +// +// Solidity: function setTrustedSequencerURL(string newTrustedSequencerURL) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmSession) SetTrustedSequencerURL(newTrustedSequencerURL string) (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.SetTrustedSequencerURL(&_Oldpolygonzkevm.TransactOpts, newTrustedSequencerURL) +} + +// SetTrustedSequencerURL is a paid mutator transaction binding the contract method 0xc89e42df. +// +// Solidity: function setTrustedSequencerURL(string newTrustedSequencerURL) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmTransactorSession) SetTrustedSequencerURL(newTrustedSequencerURL string) (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.SetTrustedSequencerURL(&_Oldpolygonzkevm.TransactOpts, newTrustedSequencerURL) +} + +// SetVerifyBatchTimeTarget is a paid mutator transaction binding the contract method 0xa066215c. +// +// Solidity: function setVerifyBatchTimeTarget(uint64 newVerifyBatchTimeTarget) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmTransactor) SetVerifyBatchTimeTarget(opts *bind.TransactOpts, newVerifyBatchTimeTarget uint64) (*types.Transaction, error) { + return _Oldpolygonzkevm.contract.Transact(opts, "setVerifyBatchTimeTarget", newVerifyBatchTimeTarget) +} + +// SetVerifyBatchTimeTarget is a paid mutator transaction binding the contract method 0xa066215c. +// +// Solidity: function setVerifyBatchTimeTarget(uint64 newVerifyBatchTimeTarget) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmSession) SetVerifyBatchTimeTarget(newVerifyBatchTimeTarget uint64) (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.SetVerifyBatchTimeTarget(&_Oldpolygonzkevm.TransactOpts, newVerifyBatchTimeTarget) +} + +// SetVerifyBatchTimeTarget is a paid mutator transaction binding the contract method 0xa066215c. +// +// Solidity: function setVerifyBatchTimeTarget(uint64 newVerifyBatchTimeTarget) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmTransactorSession) SetVerifyBatchTimeTarget(newVerifyBatchTimeTarget uint64) (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.SetVerifyBatchTimeTarget(&_Oldpolygonzkevm.TransactOpts, newVerifyBatchTimeTarget) +} + +// TransferAdminRole is a paid mutator transaction binding the contract method 0xada8f919. +// +// Solidity: function transferAdminRole(address newPendingAdmin) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmTransactor) TransferAdminRole(opts *bind.TransactOpts, newPendingAdmin common.Address) (*types.Transaction, error) { + return _Oldpolygonzkevm.contract.Transact(opts, "transferAdminRole", newPendingAdmin) +} + +// TransferAdminRole is a paid mutator transaction binding the contract method 0xada8f919. +// +// Solidity: function transferAdminRole(address newPendingAdmin) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmSession) TransferAdminRole(newPendingAdmin common.Address) (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.TransferAdminRole(&_Oldpolygonzkevm.TransactOpts, newPendingAdmin) +} + +// TransferAdminRole is a paid mutator transaction binding the contract method 0xada8f919. +// +// Solidity: function transferAdminRole(address newPendingAdmin) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmTransactorSession) TransferAdminRole(newPendingAdmin common.Address) (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.TransferAdminRole(&_Oldpolygonzkevm.TransactOpts, newPendingAdmin) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { + return _Oldpolygonzkevm.contract.Transact(opts, "transferOwnership", newOwner) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.TransferOwnership(&_Oldpolygonzkevm.TransactOpts, newOwner) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.TransferOwnership(&_Oldpolygonzkevm.TransactOpts, newOwner) +} + +// VerifyBatches is a paid mutator transaction binding the contract method 0x621dd411. +// +// Solidity: function verifyBatches(uint64 pendingStateNum, uint64 initNumBatch, uint64 finalNewBatch, bytes32 newLocalExitRoot, bytes32 newStateRoot, bytes32[24] proof) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmTransactor) VerifyBatches(opts *bind.TransactOpts, pendingStateNum uint64, initNumBatch uint64, finalNewBatch uint64, newLocalExitRoot [32]byte, newStateRoot [32]byte, proof [24][32]byte) (*types.Transaction, error) { + return _Oldpolygonzkevm.contract.Transact(opts, "verifyBatches", pendingStateNum, initNumBatch, finalNewBatch, newLocalExitRoot, newStateRoot, proof) +} + +// VerifyBatches is a paid mutator transaction binding the contract method 0x621dd411. +// +// Solidity: function verifyBatches(uint64 pendingStateNum, uint64 initNumBatch, uint64 finalNewBatch, bytes32 newLocalExitRoot, bytes32 newStateRoot, bytes32[24] proof) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmSession) VerifyBatches(pendingStateNum uint64, initNumBatch uint64, finalNewBatch uint64, newLocalExitRoot [32]byte, newStateRoot [32]byte, proof [24][32]byte) (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.VerifyBatches(&_Oldpolygonzkevm.TransactOpts, pendingStateNum, initNumBatch, finalNewBatch, newLocalExitRoot, newStateRoot, proof) +} + +// VerifyBatches is a paid mutator transaction binding the contract method 0x621dd411. +// +// Solidity: function verifyBatches(uint64 pendingStateNum, uint64 initNumBatch, uint64 finalNewBatch, bytes32 newLocalExitRoot, bytes32 newStateRoot, bytes32[24] proof) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmTransactorSession) VerifyBatches(pendingStateNum uint64, initNumBatch uint64, finalNewBatch uint64, newLocalExitRoot [32]byte, newStateRoot [32]byte, proof [24][32]byte) (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.VerifyBatches(&_Oldpolygonzkevm.TransactOpts, pendingStateNum, initNumBatch, finalNewBatch, newLocalExitRoot, newStateRoot, proof) +} + +// VerifyBatchesTrustedAggregator is a paid mutator transaction binding the contract method 0x2b0006fa. +// +// Solidity: function verifyBatchesTrustedAggregator(uint64 pendingStateNum, uint64 initNumBatch, uint64 finalNewBatch, bytes32 newLocalExitRoot, bytes32 newStateRoot, bytes32[24] proof) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmTransactor) VerifyBatchesTrustedAggregator(opts *bind.TransactOpts, pendingStateNum uint64, initNumBatch uint64, finalNewBatch uint64, newLocalExitRoot [32]byte, newStateRoot [32]byte, proof [24][32]byte) (*types.Transaction, error) { + return _Oldpolygonzkevm.contract.Transact(opts, "verifyBatchesTrustedAggregator", pendingStateNum, initNumBatch, finalNewBatch, newLocalExitRoot, newStateRoot, proof) +} + +// VerifyBatchesTrustedAggregator is a paid mutator transaction binding the contract method 0x2b0006fa. +// +// Solidity: function verifyBatchesTrustedAggregator(uint64 pendingStateNum, uint64 initNumBatch, uint64 finalNewBatch, bytes32 newLocalExitRoot, bytes32 newStateRoot, bytes32[24] proof) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmSession) VerifyBatchesTrustedAggregator(pendingStateNum uint64, initNumBatch uint64, finalNewBatch uint64, newLocalExitRoot [32]byte, newStateRoot [32]byte, proof [24][32]byte) (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.VerifyBatchesTrustedAggregator(&_Oldpolygonzkevm.TransactOpts, pendingStateNum, initNumBatch, finalNewBatch, newLocalExitRoot, newStateRoot, proof) +} + +// VerifyBatchesTrustedAggregator is a paid mutator transaction binding the contract method 0x2b0006fa. +// +// Solidity: function verifyBatchesTrustedAggregator(uint64 pendingStateNum, uint64 initNumBatch, uint64 finalNewBatch, bytes32 newLocalExitRoot, bytes32 newStateRoot, bytes32[24] proof) returns() +func (_Oldpolygonzkevm *OldpolygonzkevmTransactorSession) VerifyBatchesTrustedAggregator(pendingStateNum uint64, initNumBatch uint64, finalNewBatch uint64, newLocalExitRoot [32]byte, newStateRoot [32]byte, proof [24][32]byte) (*types.Transaction, error) { + return _Oldpolygonzkevm.Contract.VerifyBatchesTrustedAggregator(&_Oldpolygonzkevm.TransactOpts, pendingStateNum, initNumBatch, finalNewBatch, newLocalExitRoot, newStateRoot, proof) +} + +// OldpolygonzkevmAcceptAdminRoleIterator is returned from FilterAcceptAdminRole and is used to iterate over the raw logs and unpacked data for AcceptAdminRole events raised by the Oldpolygonzkevm contract. +type OldpolygonzkevmAcceptAdminRoleIterator struct { + Event *OldpolygonzkevmAcceptAdminRole // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *OldpolygonzkevmAcceptAdminRoleIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmAcceptAdminRole) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmAcceptAdminRole) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *OldpolygonzkevmAcceptAdminRoleIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *OldpolygonzkevmAcceptAdminRoleIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// OldpolygonzkevmAcceptAdminRole represents a AcceptAdminRole event raised by the Oldpolygonzkevm contract. +type OldpolygonzkevmAcceptAdminRole struct { + NewAdmin common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterAcceptAdminRole is a free log retrieval operation binding the contract event 0x056dc487bbf0795d0bbb1b4f0af523a855503cff740bfb4d5475f7a90c091e8e. +// +// Solidity: event AcceptAdminRole(address newAdmin) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) FilterAcceptAdminRole(opts *bind.FilterOpts) (*OldpolygonzkevmAcceptAdminRoleIterator, error) { + + logs, sub, err := _Oldpolygonzkevm.contract.FilterLogs(opts, "AcceptAdminRole") + if err != nil { + return nil, err + } + return &OldpolygonzkevmAcceptAdminRoleIterator{contract: _Oldpolygonzkevm.contract, event: "AcceptAdminRole", logs: logs, sub: sub}, nil +} + +// WatchAcceptAdminRole is a free log subscription operation binding the contract event 0x056dc487bbf0795d0bbb1b4f0af523a855503cff740bfb4d5475f7a90c091e8e. +// +// Solidity: event AcceptAdminRole(address newAdmin) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) WatchAcceptAdminRole(opts *bind.WatchOpts, sink chan<- *OldpolygonzkevmAcceptAdminRole) (event.Subscription, error) { + + logs, sub, err := _Oldpolygonzkevm.contract.WatchLogs(opts, "AcceptAdminRole") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(OldpolygonzkevmAcceptAdminRole) + if err := _Oldpolygonzkevm.contract.UnpackLog(event, "AcceptAdminRole", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseAcceptAdminRole is a log parse operation binding the contract event 0x056dc487bbf0795d0bbb1b4f0af523a855503cff740bfb4d5475f7a90c091e8e. +// +// Solidity: event AcceptAdminRole(address newAdmin) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) ParseAcceptAdminRole(log types.Log) (*OldpolygonzkevmAcceptAdminRole, error) { + event := new(OldpolygonzkevmAcceptAdminRole) + if err := _Oldpolygonzkevm.contract.UnpackLog(event, "AcceptAdminRole", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// OldpolygonzkevmActivateForceBatchesIterator is returned from FilterActivateForceBatches and is used to iterate over the raw logs and unpacked data for ActivateForceBatches events raised by the Oldpolygonzkevm contract. +type OldpolygonzkevmActivateForceBatchesIterator struct { + Event *OldpolygonzkevmActivateForceBatches // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *OldpolygonzkevmActivateForceBatchesIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmActivateForceBatches) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmActivateForceBatches) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *OldpolygonzkevmActivateForceBatchesIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *OldpolygonzkevmActivateForceBatchesIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// OldpolygonzkevmActivateForceBatches represents a ActivateForceBatches event raised by the Oldpolygonzkevm contract. +type OldpolygonzkevmActivateForceBatches struct { + Raw types.Log // Blockchain specific contextual infos +} + +// FilterActivateForceBatches is a free log retrieval operation binding the contract event 0x854dd6ce5a1445c4c54388b21cffd11cf5bba1b9e763aec48ce3da75d617412f. +// +// Solidity: event ActivateForceBatches() +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) FilterActivateForceBatches(opts *bind.FilterOpts) (*OldpolygonzkevmActivateForceBatchesIterator, error) { + + logs, sub, err := _Oldpolygonzkevm.contract.FilterLogs(opts, "ActivateForceBatches") + if err != nil { + return nil, err + } + return &OldpolygonzkevmActivateForceBatchesIterator{contract: _Oldpolygonzkevm.contract, event: "ActivateForceBatches", logs: logs, sub: sub}, nil +} + +// WatchActivateForceBatches is a free log subscription operation binding the contract event 0x854dd6ce5a1445c4c54388b21cffd11cf5bba1b9e763aec48ce3da75d617412f. +// +// Solidity: event ActivateForceBatches() +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) WatchActivateForceBatches(opts *bind.WatchOpts, sink chan<- *OldpolygonzkevmActivateForceBatches) (event.Subscription, error) { + + logs, sub, err := _Oldpolygonzkevm.contract.WatchLogs(opts, "ActivateForceBatches") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(OldpolygonzkevmActivateForceBatches) + if err := _Oldpolygonzkevm.contract.UnpackLog(event, "ActivateForceBatches", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseActivateForceBatches is a log parse operation binding the contract event 0x854dd6ce5a1445c4c54388b21cffd11cf5bba1b9e763aec48ce3da75d617412f. +// +// Solidity: event ActivateForceBatches() +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) ParseActivateForceBatches(log types.Log) (*OldpolygonzkevmActivateForceBatches, error) { + event := new(OldpolygonzkevmActivateForceBatches) + if err := _Oldpolygonzkevm.contract.UnpackLog(event, "ActivateForceBatches", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// OldpolygonzkevmConsolidatePendingStateIterator is returned from FilterConsolidatePendingState and is used to iterate over the raw logs and unpacked data for ConsolidatePendingState events raised by the Oldpolygonzkevm contract. +type OldpolygonzkevmConsolidatePendingStateIterator struct { + Event *OldpolygonzkevmConsolidatePendingState // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *OldpolygonzkevmConsolidatePendingStateIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmConsolidatePendingState) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmConsolidatePendingState) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *OldpolygonzkevmConsolidatePendingStateIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *OldpolygonzkevmConsolidatePendingStateIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// OldpolygonzkevmConsolidatePendingState represents a ConsolidatePendingState event raised by the Oldpolygonzkevm contract. +type OldpolygonzkevmConsolidatePendingState struct { + NumBatch uint64 + StateRoot [32]byte + PendingStateNum uint64 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterConsolidatePendingState is a free log retrieval operation binding the contract event 0x328d3c6c0fd6f1be0515e422f2d87e59f25922cbc2233568515a0c4bc3f8510e. +// +// Solidity: event ConsolidatePendingState(uint64 indexed numBatch, bytes32 stateRoot, uint64 indexed pendingStateNum) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) FilterConsolidatePendingState(opts *bind.FilterOpts, numBatch []uint64, pendingStateNum []uint64) (*OldpolygonzkevmConsolidatePendingStateIterator, error) { + + var numBatchRule []interface{} + for _, numBatchItem := range numBatch { + numBatchRule = append(numBatchRule, numBatchItem) + } + + var pendingStateNumRule []interface{} + for _, pendingStateNumItem := range pendingStateNum { + pendingStateNumRule = append(pendingStateNumRule, pendingStateNumItem) + } + + logs, sub, err := _Oldpolygonzkevm.contract.FilterLogs(opts, "ConsolidatePendingState", numBatchRule, pendingStateNumRule) + if err != nil { + return nil, err + } + return &OldpolygonzkevmConsolidatePendingStateIterator{contract: _Oldpolygonzkevm.contract, event: "ConsolidatePendingState", logs: logs, sub: sub}, nil +} + +// WatchConsolidatePendingState is a free log subscription operation binding the contract event 0x328d3c6c0fd6f1be0515e422f2d87e59f25922cbc2233568515a0c4bc3f8510e. +// +// Solidity: event ConsolidatePendingState(uint64 indexed numBatch, bytes32 stateRoot, uint64 indexed pendingStateNum) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) WatchConsolidatePendingState(opts *bind.WatchOpts, sink chan<- *OldpolygonzkevmConsolidatePendingState, numBatch []uint64, pendingStateNum []uint64) (event.Subscription, error) { + + var numBatchRule []interface{} + for _, numBatchItem := range numBatch { + numBatchRule = append(numBatchRule, numBatchItem) + } + + var pendingStateNumRule []interface{} + for _, pendingStateNumItem := range pendingStateNum { + pendingStateNumRule = append(pendingStateNumRule, pendingStateNumItem) + } + + logs, sub, err := _Oldpolygonzkevm.contract.WatchLogs(opts, "ConsolidatePendingState", numBatchRule, pendingStateNumRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(OldpolygonzkevmConsolidatePendingState) + if err := _Oldpolygonzkevm.contract.UnpackLog(event, "ConsolidatePendingState", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseConsolidatePendingState is a log parse operation binding the contract event 0x328d3c6c0fd6f1be0515e422f2d87e59f25922cbc2233568515a0c4bc3f8510e. +// +// Solidity: event ConsolidatePendingState(uint64 indexed numBatch, bytes32 stateRoot, uint64 indexed pendingStateNum) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) ParseConsolidatePendingState(log types.Log) (*OldpolygonzkevmConsolidatePendingState, error) { + event := new(OldpolygonzkevmConsolidatePendingState) + if err := _Oldpolygonzkevm.contract.UnpackLog(event, "ConsolidatePendingState", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// OldpolygonzkevmEmergencyStateActivatedIterator is returned from FilterEmergencyStateActivated and is used to iterate over the raw logs and unpacked data for EmergencyStateActivated events raised by the Oldpolygonzkevm contract. +type OldpolygonzkevmEmergencyStateActivatedIterator struct { + Event *OldpolygonzkevmEmergencyStateActivated // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *OldpolygonzkevmEmergencyStateActivatedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmEmergencyStateActivated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmEmergencyStateActivated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *OldpolygonzkevmEmergencyStateActivatedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *OldpolygonzkevmEmergencyStateActivatedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// OldpolygonzkevmEmergencyStateActivated represents a EmergencyStateActivated event raised by the Oldpolygonzkevm contract. +type OldpolygonzkevmEmergencyStateActivated struct { + Raw types.Log // Blockchain specific contextual infos +} + +// FilterEmergencyStateActivated is a free log retrieval operation binding the contract event 0x2261efe5aef6fedc1fd1550b25facc9181745623049c7901287030b9ad1a5497. +// +// Solidity: event EmergencyStateActivated() +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) FilterEmergencyStateActivated(opts *bind.FilterOpts) (*OldpolygonzkevmEmergencyStateActivatedIterator, error) { + + logs, sub, err := _Oldpolygonzkevm.contract.FilterLogs(opts, "EmergencyStateActivated") + if err != nil { + return nil, err + } + return &OldpolygonzkevmEmergencyStateActivatedIterator{contract: _Oldpolygonzkevm.contract, event: "EmergencyStateActivated", logs: logs, sub: sub}, nil +} + +// WatchEmergencyStateActivated is a free log subscription operation binding the contract event 0x2261efe5aef6fedc1fd1550b25facc9181745623049c7901287030b9ad1a5497. +// +// Solidity: event EmergencyStateActivated() +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) WatchEmergencyStateActivated(opts *bind.WatchOpts, sink chan<- *OldpolygonzkevmEmergencyStateActivated) (event.Subscription, error) { + + logs, sub, err := _Oldpolygonzkevm.contract.WatchLogs(opts, "EmergencyStateActivated") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(OldpolygonzkevmEmergencyStateActivated) + if err := _Oldpolygonzkevm.contract.UnpackLog(event, "EmergencyStateActivated", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseEmergencyStateActivated is a log parse operation binding the contract event 0x2261efe5aef6fedc1fd1550b25facc9181745623049c7901287030b9ad1a5497. +// +// Solidity: event EmergencyStateActivated() +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) ParseEmergencyStateActivated(log types.Log) (*OldpolygonzkevmEmergencyStateActivated, error) { + event := new(OldpolygonzkevmEmergencyStateActivated) + if err := _Oldpolygonzkevm.contract.UnpackLog(event, "EmergencyStateActivated", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// OldpolygonzkevmEmergencyStateDeactivatedIterator is returned from FilterEmergencyStateDeactivated and is used to iterate over the raw logs and unpacked data for EmergencyStateDeactivated events raised by the Oldpolygonzkevm contract. +type OldpolygonzkevmEmergencyStateDeactivatedIterator struct { + Event *OldpolygonzkevmEmergencyStateDeactivated // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *OldpolygonzkevmEmergencyStateDeactivatedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmEmergencyStateDeactivated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmEmergencyStateDeactivated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *OldpolygonzkevmEmergencyStateDeactivatedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *OldpolygonzkevmEmergencyStateDeactivatedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// OldpolygonzkevmEmergencyStateDeactivated represents a EmergencyStateDeactivated event raised by the Oldpolygonzkevm contract. +type OldpolygonzkevmEmergencyStateDeactivated struct { + Raw types.Log // Blockchain specific contextual infos +} + +// FilterEmergencyStateDeactivated is a free log retrieval operation binding the contract event 0x1e5e34eea33501aecf2ebec9fe0e884a40804275ea7fe10b2ba084c8374308b3. +// +// Solidity: event EmergencyStateDeactivated() +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) FilterEmergencyStateDeactivated(opts *bind.FilterOpts) (*OldpolygonzkevmEmergencyStateDeactivatedIterator, error) { + + logs, sub, err := _Oldpolygonzkevm.contract.FilterLogs(opts, "EmergencyStateDeactivated") + if err != nil { + return nil, err + } + return &OldpolygonzkevmEmergencyStateDeactivatedIterator{contract: _Oldpolygonzkevm.contract, event: "EmergencyStateDeactivated", logs: logs, sub: sub}, nil +} + +// WatchEmergencyStateDeactivated is a free log subscription operation binding the contract event 0x1e5e34eea33501aecf2ebec9fe0e884a40804275ea7fe10b2ba084c8374308b3. +// +// Solidity: event EmergencyStateDeactivated() +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) WatchEmergencyStateDeactivated(opts *bind.WatchOpts, sink chan<- *OldpolygonzkevmEmergencyStateDeactivated) (event.Subscription, error) { + + logs, sub, err := _Oldpolygonzkevm.contract.WatchLogs(opts, "EmergencyStateDeactivated") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(OldpolygonzkevmEmergencyStateDeactivated) + if err := _Oldpolygonzkevm.contract.UnpackLog(event, "EmergencyStateDeactivated", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseEmergencyStateDeactivated is a log parse operation binding the contract event 0x1e5e34eea33501aecf2ebec9fe0e884a40804275ea7fe10b2ba084c8374308b3. +// +// Solidity: event EmergencyStateDeactivated() +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) ParseEmergencyStateDeactivated(log types.Log) (*OldpolygonzkevmEmergencyStateDeactivated, error) { + event := new(OldpolygonzkevmEmergencyStateDeactivated) + if err := _Oldpolygonzkevm.contract.UnpackLog(event, "EmergencyStateDeactivated", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// OldpolygonzkevmForceBatchIterator is returned from FilterForceBatch and is used to iterate over the raw logs and unpacked data for ForceBatch events raised by the Oldpolygonzkevm contract. +type OldpolygonzkevmForceBatchIterator struct { + Event *OldpolygonzkevmForceBatch // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *OldpolygonzkevmForceBatchIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmForceBatch) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmForceBatch) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *OldpolygonzkevmForceBatchIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *OldpolygonzkevmForceBatchIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// OldpolygonzkevmForceBatch represents a ForceBatch event raised by the Oldpolygonzkevm contract. +type OldpolygonzkevmForceBatch struct { + ForceBatchNum uint64 + LastGlobalExitRoot [32]byte + Sequencer common.Address + Transactions []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterForceBatch is a free log retrieval operation binding the contract event 0xf94bb37db835f1ab585ee00041849a09b12cd081d77fa15ca070757619cbc931. +// +// Solidity: event ForceBatch(uint64 indexed forceBatchNum, bytes32 lastGlobalExitRoot, address sequencer, bytes transactions) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) FilterForceBatch(opts *bind.FilterOpts, forceBatchNum []uint64) (*OldpolygonzkevmForceBatchIterator, error) { + + var forceBatchNumRule []interface{} + for _, forceBatchNumItem := range forceBatchNum { + forceBatchNumRule = append(forceBatchNumRule, forceBatchNumItem) + } + + logs, sub, err := _Oldpolygonzkevm.contract.FilterLogs(opts, "ForceBatch", forceBatchNumRule) + if err != nil { + return nil, err + } + return &OldpolygonzkevmForceBatchIterator{contract: _Oldpolygonzkevm.contract, event: "ForceBatch", logs: logs, sub: sub}, nil +} + +// WatchForceBatch is a free log subscription operation binding the contract event 0xf94bb37db835f1ab585ee00041849a09b12cd081d77fa15ca070757619cbc931. +// +// Solidity: event ForceBatch(uint64 indexed forceBatchNum, bytes32 lastGlobalExitRoot, address sequencer, bytes transactions) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) WatchForceBatch(opts *bind.WatchOpts, sink chan<- *OldpolygonzkevmForceBatch, forceBatchNum []uint64) (event.Subscription, error) { + + var forceBatchNumRule []interface{} + for _, forceBatchNumItem := range forceBatchNum { + forceBatchNumRule = append(forceBatchNumRule, forceBatchNumItem) + } + + logs, sub, err := _Oldpolygonzkevm.contract.WatchLogs(opts, "ForceBatch", forceBatchNumRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(OldpolygonzkevmForceBatch) + if err := _Oldpolygonzkevm.contract.UnpackLog(event, "ForceBatch", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseForceBatch is a log parse operation binding the contract event 0xf94bb37db835f1ab585ee00041849a09b12cd081d77fa15ca070757619cbc931. +// +// Solidity: event ForceBatch(uint64 indexed forceBatchNum, bytes32 lastGlobalExitRoot, address sequencer, bytes transactions) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) ParseForceBatch(log types.Log) (*OldpolygonzkevmForceBatch, error) { + event := new(OldpolygonzkevmForceBatch) + if err := _Oldpolygonzkevm.contract.UnpackLog(event, "ForceBatch", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// OldpolygonzkevmInitializedIterator is returned from FilterInitialized and is used to iterate over the raw logs and unpacked data for Initialized events raised by the Oldpolygonzkevm contract. +type OldpolygonzkevmInitializedIterator struct { + Event *OldpolygonzkevmInitialized // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *OldpolygonzkevmInitializedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmInitialized) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmInitialized) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *OldpolygonzkevmInitializedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *OldpolygonzkevmInitializedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// OldpolygonzkevmInitialized represents a Initialized event raised by the Oldpolygonzkevm contract. +type OldpolygonzkevmInitialized struct { + Version uint8 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterInitialized is a free log retrieval operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) FilterInitialized(opts *bind.FilterOpts) (*OldpolygonzkevmInitializedIterator, error) { + + logs, sub, err := _Oldpolygonzkevm.contract.FilterLogs(opts, "Initialized") + if err != nil { + return nil, err + } + return &OldpolygonzkevmInitializedIterator{contract: _Oldpolygonzkevm.contract, event: "Initialized", logs: logs, sub: sub}, nil +} + +// WatchInitialized is a free log subscription operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *OldpolygonzkevmInitialized) (event.Subscription, error) { + + logs, sub, err := _Oldpolygonzkevm.contract.WatchLogs(opts, "Initialized") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(OldpolygonzkevmInitialized) + if err := _Oldpolygonzkevm.contract.UnpackLog(event, "Initialized", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseInitialized is a log parse operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) ParseInitialized(log types.Log) (*OldpolygonzkevmInitialized, error) { + event := new(OldpolygonzkevmInitialized) + if err := _Oldpolygonzkevm.contract.UnpackLog(event, "Initialized", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// OldpolygonzkevmOverridePendingStateIterator is returned from FilterOverridePendingState and is used to iterate over the raw logs and unpacked data for OverridePendingState events raised by the Oldpolygonzkevm contract. +type OldpolygonzkevmOverridePendingStateIterator struct { + Event *OldpolygonzkevmOverridePendingState // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *OldpolygonzkevmOverridePendingStateIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmOverridePendingState) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmOverridePendingState) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *OldpolygonzkevmOverridePendingStateIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *OldpolygonzkevmOverridePendingStateIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// OldpolygonzkevmOverridePendingState represents a OverridePendingState event raised by the Oldpolygonzkevm contract. +type OldpolygonzkevmOverridePendingState struct { + NumBatch uint64 + StateRoot [32]byte + Aggregator common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterOverridePendingState is a free log retrieval operation binding the contract event 0xcc1b5520188bf1dd3e63f98164b577c4d75c11a619ddea692112f0d1aec4cf72. +// +// Solidity: event OverridePendingState(uint64 indexed numBatch, bytes32 stateRoot, address indexed aggregator) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) FilterOverridePendingState(opts *bind.FilterOpts, numBatch []uint64, aggregator []common.Address) (*OldpolygonzkevmOverridePendingStateIterator, error) { + + var numBatchRule []interface{} + for _, numBatchItem := range numBatch { + numBatchRule = append(numBatchRule, numBatchItem) + } + + var aggregatorRule []interface{} + for _, aggregatorItem := range aggregator { + aggregatorRule = append(aggregatorRule, aggregatorItem) + } + + logs, sub, err := _Oldpolygonzkevm.contract.FilterLogs(opts, "OverridePendingState", numBatchRule, aggregatorRule) + if err != nil { + return nil, err + } + return &OldpolygonzkevmOverridePendingStateIterator{contract: _Oldpolygonzkevm.contract, event: "OverridePendingState", logs: logs, sub: sub}, nil +} + +// WatchOverridePendingState is a free log subscription operation binding the contract event 0xcc1b5520188bf1dd3e63f98164b577c4d75c11a619ddea692112f0d1aec4cf72. +// +// Solidity: event OverridePendingState(uint64 indexed numBatch, bytes32 stateRoot, address indexed aggregator) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) WatchOverridePendingState(opts *bind.WatchOpts, sink chan<- *OldpolygonzkevmOverridePendingState, numBatch []uint64, aggregator []common.Address) (event.Subscription, error) { + + var numBatchRule []interface{} + for _, numBatchItem := range numBatch { + numBatchRule = append(numBatchRule, numBatchItem) + } + + var aggregatorRule []interface{} + for _, aggregatorItem := range aggregator { + aggregatorRule = append(aggregatorRule, aggregatorItem) + } + + logs, sub, err := _Oldpolygonzkevm.contract.WatchLogs(opts, "OverridePendingState", numBatchRule, aggregatorRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(OldpolygonzkevmOverridePendingState) + if err := _Oldpolygonzkevm.contract.UnpackLog(event, "OverridePendingState", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseOverridePendingState is a log parse operation binding the contract event 0xcc1b5520188bf1dd3e63f98164b577c4d75c11a619ddea692112f0d1aec4cf72. +// +// Solidity: event OverridePendingState(uint64 indexed numBatch, bytes32 stateRoot, address indexed aggregator) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) ParseOverridePendingState(log types.Log) (*OldpolygonzkevmOverridePendingState, error) { + event := new(OldpolygonzkevmOverridePendingState) + if err := _Oldpolygonzkevm.contract.UnpackLog(event, "OverridePendingState", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// OldpolygonzkevmOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the Oldpolygonzkevm contract. +type OldpolygonzkevmOwnershipTransferredIterator struct { + Event *OldpolygonzkevmOwnershipTransferred // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *OldpolygonzkevmOwnershipTransferredIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmOwnershipTransferred) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmOwnershipTransferred) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *OldpolygonzkevmOwnershipTransferredIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *OldpolygonzkevmOwnershipTransferredIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// OldpolygonzkevmOwnershipTransferred represents a OwnershipTransferred event raised by the Oldpolygonzkevm contract. +type OldpolygonzkevmOwnershipTransferred struct { + PreviousOwner common.Address + NewOwner common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. +// +// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*OldpolygonzkevmOwnershipTransferredIterator, error) { + + var previousOwnerRule []interface{} + for _, previousOwnerItem := range previousOwner { + previousOwnerRule = append(previousOwnerRule, previousOwnerItem) + } + var newOwnerRule []interface{} + for _, newOwnerItem := range newOwner { + newOwnerRule = append(newOwnerRule, newOwnerItem) + } + + logs, sub, err := _Oldpolygonzkevm.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) + if err != nil { + return nil, err + } + return &OldpolygonzkevmOwnershipTransferredIterator{contract: _Oldpolygonzkevm.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil +} + +// WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. +// +// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *OldpolygonzkevmOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) { + + var previousOwnerRule []interface{} + for _, previousOwnerItem := range previousOwner { + previousOwnerRule = append(previousOwnerRule, previousOwnerItem) + } + var newOwnerRule []interface{} + for _, newOwnerItem := range newOwner { + newOwnerRule = append(newOwnerRule, newOwnerItem) + } + + logs, sub, err := _Oldpolygonzkevm.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(OldpolygonzkevmOwnershipTransferred) + if err := _Oldpolygonzkevm.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. +// +// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) ParseOwnershipTransferred(log types.Log) (*OldpolygonzkevmOwnershipTransferred, error) { + event := new(OldpolygonzkevmOwnershipTransferred) + if err := _Oldpolygonzkevm.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// OldpolygonzkevmProveNonDeterministicPendingStateIterator is returned from FilterProveNonDeterministicPendingState and is used to iterate over the raw logs and unpacked data for ProveNonDeterministicPendingState events raised by the Oldpolygonzkevm contract. +type OldpolygonzkevmProveNonDeterministicPendingStateIterator struct { + Event *OldpolygonzkevmProveNonDeterministicPendingState // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *OldpolygonzkevmProveNonDeterministicPendingStateIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmProveNonDeterministicPendingState) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmProveNonDeterministicPendingState) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *OldpolygonzkevmProveNonDeterministicPendingStateIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *OldpolygonzkevmProveNonDeterministicPendingStateIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// OldpolygonzkevmProveNonDeterministicPendingState represents a ProveNonDeterministicPendingState event raised by the Oldpolygonzkevm contract. +type OldpolygonzkevmProveNonDeterministicPendingState struct { + StoredStateRoot [32]byte + ProvedStateRoot [32]byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterProveNonDeterministicPendingState is a free log retrieval operation binding the contract event 0x1f44c21118c4603cfb4e1b621dbcfa2b73efcececee2b99b620b2953d33a7010. +// +// Solidity: event ProveNonDeterministicPendingState(bytes32 storedStateRoot, bytes32 provedStateRoot) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) FilterProveNonDeterministicPendingState(opts *bind.FilterOpts) (*OldpolygonzkevmProveNonDeterministicPendingStateIterator, error) { + + logs, sub, err := _Oldpolygonzkevm.contract.FilterLogs(opts, "ProveNonDeterministicPendingState") + if err != nil { + return nil, err + } + return &OldpolygonzkevmProveNonDeterministicPendingStateIterator{contract: _Oldpolygonzkevm.contract, event: "ProveNonDeterministicPendingState", logs: logs, sub: sub}, nil +} + +// WatchProveNonDeterministicPendingState is a free log subscription operation binding the contract event 0x1f44c21118c4603cfb4e1b621dbcfa2b73efcececee2b99b620b2953d33a7010. +// +// Solidity: event ProveNonDeterministicPendingState(bytes32 storedStateRoot, bytes32 provedStateRoot) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) WatchProveNonDeterministicPendingState(opts *bind.WatchOpts, sink chan<- *OldpolygonzkevmProveNonDeterministicPendingState) (event.Subscription, error) { + + logs, sub, err := _Oldpolygonzkevm.contract.WatchLogs(opts, "ProveNonDeterministicPendingState") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(OldpolygonzkevmProveNonDeterministicPendingState) + if err := _Oldpolygonzkevm.contract.UnpackLog(event, "ProveNonDeterministicPendingState", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseProveNonDeterministicPendingState is a log parse operation binding the contract event 0x1f44c21118c4603cfb4e1b621dbcfa2b73efcececee2b99b620b2953d33a7010. +// +// Solidity: event ProveNonDeterministicPendingState(bytes32 storedStateRoot, bytes32 provedStateRoot) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) ParseProveNonDeterministicPendingState(log types.Log) (*OldpolygonzkevmProveNonDeterministicPendingState, error) { + event := new(OldpolygonzkevmProveNonDeterministicPendingState) + if err := _Oldpolygonzkevm.contract.UnpackLog(event, "ProveNonDeterministicPendingState", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// OldpolygonzkevmSequenceBatchesIterator is returned from FilterSequenceBatches and is used to iterate over the raw logs and unpacked data for SequenceBatches events raised by the Oldpolygonzkevm contract. +type OldpolygonzkevmSequenceBatchesIterator struct { + Event *OldpolygonzkevmSequenceBatches // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *OldpolygonzkevmSequenceBatchesIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmSequenceBatches) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmSequenceBatches) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *OldpolygonzkevmSequenceBatchesIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *OldpolygonzkevmSequenceBatchesIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// OldpolygonzkevmSequenceBatches represents a SequenceBatches event raised by the Oldpolygonzkevm contract. +type OldpolygonzkevmSequenceBatches struct { + NumBatch uint64 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterSequenceBatches is a free log retrieval operation binding the contract event 0x303446e6a8cb73c83dff421c0b1d5e5ce0719dab1bff13660fc254e58cc17fce. +// +// Solidity: event SequenceBatches(uint64 indexed numBatch) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) FilterSequenceBatches(opts *bind.FilterOpts, numBatch []uint64) (*OldpolygonzkevmSequenceBatchesIterator, error) { + + var numBatchRule []interface{} + for _, numBatchItem := range numBatch { + numBatchRule = append(numBatchRule, numBatchItem) + } + + logs, sub, err := _Oldpolygonzkevm.contract.FilterLogs(opts, "SequenceBatches", numBatchRule) + if err != nil { + return nil, err + } + return &OldpolygonzkevmSequenceBatchesIterator{contract: _Oldpolygonzkevm.contract, event: "SequenceBatches", logs: logs, sub: sub}, nil +} + +// WatchSequenceBatches is a free log subscription operation binding the contract event 0x303446e6a8cb73c83dff421c0b1d5e5ce0719dab1bff13660fc254e58cc17fce. +// +// Solidity: event SequenceBatches(uint64 indexed numBatch) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) WatchSequenceBatches(opts *bind.WatchOpts, sink chan<- *OldpolygonzkevmSequenceBatches, numBatch []uint64) (event.Subscription, error) { + + var numBatchRule []interface{} + for _, numBatchItem := range numBatch { + numBatchRule = append(numBatchRule, numBatchItem) + } + + logs, sub, err := _Oldpolygonzkevm.contract.WatchLogs(opts, "SequenceBatches", numBatchRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(OldpolygonzkevmSequenceBatches) + if err := _Oldpolygonzkevm.contract.UnpackLog(event, "SequenceBatches", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseSequenceBatches is a log parse operation binding the contract event 0x303446e6a8cb73c83dff421c0b1d5e5ce0719dab1bff13660fc254e58cc17fce. +// +// Solidity: event SequenceBatches(uint64 indexed numBatch) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) ParseSequenceBatches(log types.Log) (*OldpolygonzkevmSequenceBatches, error) { + event := new(OldpolygonzkevmSequenceBatches) + if err := _Oldpolygonzkevm.contract.UnpackLog(event, "SequenceBatches", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// OldpolygonzkevmSequenceForceBatchesIterator is returned from FilterSequenceForceBatches and is used to iterate over the raw logs and unpacked data for SequenceForceBatches events raised by the Oldpolygonzkevm contract. +type OldpolygonzkevmSequenceForceBatchesIterator struct { + Event *OldpolygonzkevmSequenceForceBatches // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *OldpolygonzkevmSequenceForceBatchesIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmSequenceForceBatches) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmSequenceForceBatches) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *OldpolygonzkevmSequenceForceBatchesIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *OldpolygonzkevmSequenceForceBatchesIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// OldpolygonzkevmSequenceForceBatches represents a SequenceForceBatches event raised by the Oldpolygonzkevm contract. +type OldpolygonzkevmSequenceForceBatches struct { + NumBatch uint64 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterSequenceForceBatches is a free log retrieval operation binding the contract event 0x648a61dd2438f072f5a1960939abd30f37aea80d2e94c9792ad142d3e0a490a4. +// +// Solidity: event SequenceForceBatches(uint64 indexed numBatch) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) FilterSequenceForceBatches(opts *bind.FilterOpts, numBatch []uint64) (*OldpolygonzkevmSequenceForceBatchesIterator, error) { + + var numBatchRule []interface{} + for _, numBatchItem := range numBatch { + numBatchRule = append(numBatchRule, numBatchItem) + } + + logs, sub, err := _Oldpolygonzkevm.contract.FilterLogs(opts, "SequenceForceBatches", numBatchRule) + if err != nil { + return nil, err + } + return &OldpolygonzkevmSequenceForceBatchesIterator{contract: _Oldpolygonzkevm.contract, event: "SequenceForceBatches", logs: logs, sub: sub}, nil +} + +// WatchSequenceForceBatches is a free log subscription operation binding the contract event 0x648a61dd2438f072f5a1960939abd30f37aea80d2e94c9792ad142d3e0a490a4. +// +// Solidity: event SequenceForceBatches(uint64 indexed numBatch) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) WatchSequenceForceBatches(opts *bind.WatchOpts, sink chan<- *OldpolygonzkevmSequenceForceBatches, numBatch []uint64) (event.Subscription, error) { + + var numBatchRule []interface{} + for _, numBatchItem := range numBatch { + numBatchRule = append(numBatchRule, numBatchItem) + } + + logs, sub, err := _Oldpolygonzkevm.contract.WatchLogs(opts, "SequenceForceBatches", numBatchRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(OldpolygonzkevmSequenceForceBatches) + if err := _Oldpolygonzkevm.contract.UnpackLog(event, "SequenceForceBatches", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseSequenceForceBatches is a log parse operation binding the contract event 0x648a61dd2438f072f5a1960939abd30f37aea80d2e94c9792ad142d3e0a490a4. +// +// Solidity: event SequenceForceBatches(uint64 indexed numBatch) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) ParseSequenceForceBatches(log types.Log) (*OldpolygonzkevmSequenceForceBatches, error) { + event := new(OldpolygonzkevmSequenceForceBatches) + if err := _Oldpolygonzkevm.contract.UnpackLog(event, "SequenceForceBatches", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// OldpolygonzkevmSetForceBatchTimeoutIterator is returned from FilterSetForceBatchTimeout and is used to iterate over the raw logs and unpacked data for SetForceBatchTimeout events raised by the Oldpolygonzkevm contract. +type OldpolygonzkevmSetForceBatchTimeoutIterator struct { + Event *OldpolygonzkevmSetForceBatchTimeout // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *OldpolygonzkevmSetForceBatchTimeoutIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmSetForceBatchTimeout) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmSetForceBatchTimeout) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *OldpolygonzkevmSetForceBatchTimeoutIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *OldpolygonzkevmSetForceBatchTimeoutIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// OldpolygonzkevmSetForceBatchTimeout represents a SetForceBatchTimeout event raised by the Oldpolygonzkevm contract. +type OldpolygonzkevmSetForceBatchTimeout struct { + NewforceBatchTimeout uint64 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterSetForceBatchTimeout is a free log retrieval operation binding the contract event 0xa7eb6cb8a613eb4e8bddc1ac3d61ec6cf10898760f0b187bcca794c6ca6fa40b. +// +// Solidity: event SetForceBatchTimeout(uint64 newforceBatchTimeout) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) FilterSetForceBatchTimeout(opts *bind.FilterOpts) (*OldpolygonzkevmSetForceBatchTimeoutIterator, error) { + + logs, sub, err := _Oldpolygonzkevm.contract.FilterLogs(opts, "SetForceBatchTimeout") + if err != nil { + return nil, err + } + return &OldpolygonzkevmSetForceBatchTimeoutIterator{contract: _Oldpolygonzkevm.contract, event: "SetForceBatchTimeout", logs: logs, sub: sub}, nil +} + +// WatchSetForceBatchTimeout is a free log subscription operation binding the contract event 0xa7eb6cb8a613eb4e8bddc1ac3d61ec6cf10898760f0b187bcca794c6ca6fa40b. +// +// Solidity: event SetForceBatchTimeout(uint64 newforceBatchTimeout) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) WatchSetForceBatchTimeout(opts *bind.WatchOpts, sink chan<- *OldpolygonzkevmSetForceBatchTimeout) (event.Subscription, error) { + + logs, sub, err := _Oldpolygonzkevm.contract.WatchLogs(opts, "SetForceBatchTimeout") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(OldpolygonzkevmSetForceBatchTimeout) + if err := _Oldpolygonzkevm.contract.UnpackLog(event, "SetForceBatchTimeout", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseSetForceBatchTimeout is a log parse operation binding the contract event 0xa7eb6cb8a613eb4e8bddc1ac3d61ec6cf10898760f0b187bcca794c6ca6fa40b. +// +// Solidity: event SetForceBatchTimeout(uint64 newforceBatchTimeout) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) ParseSetForceBatchTimeout(log types.Log) (*OldpolygonzkevmSetForceBatchTimeout, error) { + event := new(OldpolygonzkevmSetForceBatchTimeout) + if err := _Oldpolygonzkevm.contract.UnpackLog(event, "SetForceBatchTimeout", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// OldpolygonzkevmSetMultiplierBatchFeeIterator is returned from FilterSetMultiplierBatchFee and is used to iterate over the raw logs and unpacked data for SetMultiplierBatchFee events raised by the Oldpolygonzkevm contract. +type OldpolygonzkevmSetMultiplierBatchFeeIterator struct { + Event *OldpolygonzkevmSetMultiplierBatchFee // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *OldpolygonzkevmSetMultiplierBatchFeeIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmSetMultiplierBatchFee) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmSetMultiplierBatchFee) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *OldpolygonzkevmSetMultiplierBatchFeeIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *OldpolygonzkevmSetMultiplierBatchFeeIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// OldpolygonzkevmSetMultiplierBatchFee represents a SetMultiplierBatchFee event raised by the Oldpolygonzkevm contract. +type OldpolygonzkevmSetMultiplierBatchFee struct { + NewMultiplierBatchFee uint16 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterSetMultiplierBatchFee is a free log retrieval operation binding the contract event 0x7019933d795eba185c180209e8ae8bffbaa25bcef293364687702c31f4d302c5. +// +// Solidity: event SetMultiplierBatchFee(uint16 newMultiplierBatchFee) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) FilterSetMultiplierBatchFee(opts *bind.FilterOpts) (*OldpolygonzkevmSetMultiplierBatchFeeIterator, error) { + + logs, sub, err := _Oldpolygonzkevm.contract.FilterLogs(opts, "SetMultiplierBatchFee") + if err != nil { + return nil, err + } + return &OldpolygonzkevmSetMultiplierBatchFeeIterator{contract: _Oldpolygonzkevm.contract, event: "SetMultiplierBatchFee", logs: logs, sub: sub}, nil +} + +// WatchSetMultiplierBatchFee is a free log subscription operation binding the contract event 0x7019933d795eba185c180209e8ae8bffbaa25bcef293364687702c31f4d302c5. +// +// Solidity: event SetMultiplierBatchFee(uint16 newMultiplierBatchFee) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) WatchSetMultiplierBatchFee(opts *bind.WatchOpts, sink chan<- *OldpolygonzkevmSetMultiplierBatchFee) (event.Subscription, error) { + + logs, sub, err := _Oldpolygonzkevm.contract.WatchLogs(opts, "SetMultiplierBatchFee") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(OldpolygonzkevmSetMultiplierBatchFee) + if err := _Oldpolygonzkevm.contract.UnpackLog(event, "SetMultiplierBatchFee", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseSetMultiplierBatchFee is a log parse operation binding the contract event 0x7019933d795eba185c180209e8ae8bffbaa25bcef293364687702c31f4d302c5. +// +// Solidity: event SetMultiplierBatchFee(uint16 newMultiplierBatchFee) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) ParseSetMultiplierBatchFee(log types.Log) (*OldpolygonzkevmSetMultiplierBatchFee, error) { + event := new(OldpolygonzkevmSetMultiplierBatchFee) + if err := _Oldpolygonzkevm.contract.UnpackLog(event, "SetMultiplierBatchFee", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// OldpolygonzkevmSetPendingStateTimeoutIterator is returned from FilterSetPendingStateTimeout and is used to iterate over the raw logs and unpacked data for SetPendingStateTimeout events raised by the Oldpolygonzkevm contract. +type OldpolygonzkevmSetPendingStateTimeoutIterator struct { + Event *OldpolygonzkevmSetPendingStateTimeout // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *OldpolygonzkevmSetPendingStateTimeoutIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmSetPendingStateTimeout) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmSetPendingStateTimeout) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *OldpolygonzkevmSetPendingStateTimeoutIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *OldpolygonzkevmSetPendingStateTimeoutIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// OldpolygonzkevmSetPendingStateTimeout represents a SetPendingStateTimeout event raised by the Oldpolygonzkevm contract. +type OldpolygonzkevmSetPendingStateTimeout struct { + NewPendingStateTimeout uint64 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterSetPendingStateTimeout is a free log retrieval operation binding the contract event 0xc4121f4e22c69632ebb7cf1f462be0511dc034f999b52013eddfb24aab765c75. +// +// Solidity: event SetPendingStateTimeout(uint64 newPendingStateTimeout) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) FilterSetPendingStateTimeout(opts *bind.FilterOpts) (*OldpolygonzkevmSetPendingStateTimeoutIterator, error) { + + logs, sub, err := _Oldpolygonzkevm.contract.FilterLogs(opts, "SetPendingStateTimeout") + if err != nil { + return nil, err + } + return &OldpolygonzkevmSetPendingStateTimeoutIterator{contract: _Oldpolygonzkevm.contract, event: "SetPendingStateTimeout", logs: logs, sub: sub}, nil +} + +// WatchSetPendingStateTimeout is a free log subscription operation binding the contract event 0xc4121f4e22c69632ebb7cf1f462be0511dc034f999b52013eddfb24aab765c75. +// +// Solidity: event SetPendingStateTimeout(uint64 newPendingStateTimeout) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) WatchSetPendingStateTimeout(opts *bind.WatchOpts, sink chan<- *OldpolygonzkevmSetPendingStateTimeout) (event.Subscription, error) { + + logs, sub, err := _Oldpolygonzkevm.contract.WatchLogs(opts, "SetPendingStateTimeout") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(OldpolygonzkevmSetPendingStateTimeout) + if err := _Oldpolygonzkevm.contract.UnpackLog(event, "SetPendingStateTimeout", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseSetPendingStateTimeout is a log parse operation binding the contract event 0xc4121f4e22c69632ebb7cf1f462be0511dc034f999b52013eddfb24aab765c75. +// +// Solidity: event SetPendingStateTimeout(uint64 newPendingStateTimeout) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) ParseSetPendingStateTimeout(log types.Log) (*OldpolygonzkevmSetPendingStateTimeout, error) { + event := new(OldpolygonzkevmSetPendingStateTimeout) + if err := _Oldpolygonzkevm.contract.UnpackLog(event, "SetPendingStateTimeout", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// OldpolygonzkevmSetTrustedAggregatorIterator is returned from FilterSetTrustedAggregator and is used to iterate over the raw logs and unpacked data for SetTrustedAggregator events raised by the Oldpolygonzkevm contract. +type OldpolygonzkevmSetTrustedAggregatorIterator struct { + Event *OldpolygonzkevmSetTrustedAggregator // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *OldpolygonzkevmSetTrustedAggregatorIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmSetTrustedAggregator) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmSetTrustedAggregator) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *OldpolygonzkevmSetTrustedAggregatorIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *OldpolygonzkevmSetTrustedAggregatorIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// OldpolygonzkevmSetTrustedAggregator represents a SetTrustedAggregator event raised by the Oldpolygonzkevm contract. +type OldpolygonzkevmSetTrustedAggregator struct { + NewTrustedAggregator common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterSetTrustedAggregator is a free log retrieval operation binding the contract event 0x61f8fec29495a3078e9271456f05fb0707fd4e41f7661865f80fc437d06681ca. +// +// Solidity: event SetTrustedAggregator(address newTrustedAggregator) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) FilterSetTrustedAggregator(opts *bind.FilterOpts) (*OldpolygonzkevmSetTrustedAggregatorIterator, error) { + + logs, sub, err := _Oldpolygonzkevm.contract.FilterLogs(opts, "SetTrustedAggregator") + if err != nil { + return nil, err + } + return &OldpolygonzkevmSetTrustedAggregatorIterator{contract: _Oldpolygonzkevm.contract, event: "SetTrustedAggregator", logs: logs, sub: sub}, nil +} + +// WatchSetTrustedAggregator is a free log subscription operation binding the contract event 0x61f8fec29495a3078e9271456f05fb0707fd4e41f7661865f80fc437d06681ca. +// +// Solidity: event SetTrustedAggregator(address newTrustedAggregator) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) WatchSetTrustedAggregator(opts *bind.WatchOpts, sink chan<- *OldpolygonzkevmSetTrustedAggregator) (event.Subscription, error) { + + logs, sub, err := _Oldpolygonzkevm.contract.WatchLogs(opts, "SetTrustedAggregator") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(OldpolygonzkevmSetTrustedAggregator) + if err := _Oldpolygonzkevm.contract.UnpackLog(event, "SetTrustedAggregator", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseSetTrustedAggregator is a log parse operation binding the contract event 0x61f8fec29495a3078e9271456f05fb0707fd4e41f7661865f80fc437d06681ca. +// +// Solidity: event SetTrustedAggregator(address newTrustedAggregator) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) ParseSetTrustedAggregator(log types.Log) (*OldpolygonzkevmSetTrustedAggregator, error) { + event := new(OldpolygonzkevmSetTrustedAggregator) + if err := _Oldpolygonzkevm.contract.UnpackLog(event, "SetTrustedAggregator", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// OldpolygonzkevmSetTrustedAggregatorTimeoutIterator is returned from FilterSetTrustedAggregatorTimeout and is used to iterate over the raw logs and unpacked data for SetTrustedAggregatorTimeout events raised by the Oldpolygonzkevm contract. +type OldpolygonzkevmSetTrustedAggregatorTimeoutIterator struct { + Event *OldpolygonzkevmSetTrustedAggregatorTimeout // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *OldpolygonzkevmSetTrustedAggregatorTimeoutIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmSetTrustedAggregatorTimeout) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmSetTrustedAggregatorTimeout) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *OldpolygonzkevmSetTrustedAggregatorTimeoutIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *OldpolygonzkevmSetTrustedAggregatorTimeoutIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// OldpolygonzkevmSetTrustedAggregatorTimeout represents a SetTrustedAggregatorTimeout event raised by the Oldpolygonzkevm contract. +type OldpolygonzkevmSetTrustedAggregatorTimeout struct { + NewTrustedAggregatorTimeout uint64 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterSetTrustedAggregatorTimeout is a free log retrieval operation binding the contract event 0x1f4fa24c2e4bad19a7f3ec5c5485f70d46c798461c2e684f55bbd0fc661373a1. +// +// Solidity: event SetTrustedAggregatorTimeout(uint64 newTrustedAggregatorTimeout) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) FilterSetTrustedAggregatorTimeout(opts *bind.FilterOpts) (*OldpolygonzkevmSetTrustedAggregatorTimeoutIterator, error) { + + logs, sub, err := _Oldpolygonzkevm.contract.FilterLogs(opts, "SetTrustedAggregatorTimeout") + if err != nil { + return nil, err + } + return &OldpolygonzkevmSetTrustedAggregatorTimeoutIterator{contract: _Oldpolygonzkevm.contract, event: "SetTrustedAggregatorTimeout", logs: logs, sub: sub}, nil +} + +// WatchSetTrustedAggregatorTimeout is a free log subscription operation binding the contract event 0x1f4fa24c2e4bad19a7f3ec5c5485f70d46c798461c2e684f55bbd0fc661373a1. +// +// Solidity: event SetTrustedAggregatorTimeout(uint64 newTrustedAggregatorTimeout) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) WatchSetTrustedAggregatorTimeout(opts *bind.WatchOpts, sink chan<- *OldpolygonzkevmSetTrustedAggregatorTimeout) (event.Subscription, error) { + + logs, sub, err := _Oldpolygonzkevm.contract.WatchLogs(opts, "SetTrustedAggregatorTimeout") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(OldpolygonzkevmSetTrustedAggregatorTimeout) + if err := _Oldpolygonzkevm.contract.UnpackLog(event, "SetTrustedAggregatorTimeout", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseSetTrustedAggregatorTimeout is a log parse operation binding the contract event 0x1f4fa24c2e4bad19a7f3ec5c5485f70d46c798461c2e684f55bbd0fc661373a1. +// +// Solidity: event SetTrustedAggregatorTimeout(uint64 newTrustedAggregatorTimeout) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) ParseSetTrustedAggregatorTimeout(log types.Log) (*OldpolygonzkevmSetTrustedAggregatorTimeout, error) { + event := new(OldpolygonzkevmSetTrustedAggregatorTimeout) + if err := _Oldpolygonzkevm.contract.UnpackLog(event, "SetTrustedAggregatorTimeout", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// OldpolygonzkevmSetTrustedSequencerIterator is returned from FilterSetTrustedSequencer and is used to iterate over the raw logs and unpacked data for SetTrustedSequencer events raised by the Oldpolygonzkevm contract. +type OldpolygonzkevmSetTrustedSequencerIterator struct { + Event *OldpolygonzkevmSetTrustedSequencer // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *OldpolygonzkevmSetTrustedSequencerIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmSetTrustedSequencer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmSetTrustedSequencer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *OldpolygonzkevmSetTrustedSequencerIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *OldpolygonzkevmSetTrustedSequencerIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// OldpolygonzkevmSetTrustedSequencer represents a SetTrustedSequencer event raised by the Oldpolygonzkevm contract. +type OldpolygonzkevmSetTrustedSequencer struct { + NewTrustedSequencer common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterSetTrustedSequencer is a free log retrieval operation binding the contract event 0xf54144f9611984021529f814a1cb6a41e22c58351510a0d9f7e822618abb9cc0. +// +// Solidity: event SetTrustedSequencer(address newTrustedSequencer) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) FilterSetTrustedSequencer(opts *bind.FilterOpts) (*OldpolygonzkevmSetTrustedSequencerIterator, error) { + + logs, sub, err := _Oldpolygonzkevm.contract.FilterLogs(opts, "SetTrustedSequencer") + if err != nil { + return nil, err + } + return &OldpolygonzkevmSetTrustedSequencerIterator{contract: _Oldpolygonzkevm.contract, event: "SetTrustedSequencer", logs: logs, sub: sub}, nil +} + +// WatchSetTrustedSequencer is a free log subscription operation binding the contract event 0xf54144f9611984021529f814a1cb6a41e22c58351510a0d9f7e822618abb9cc0. +// +// Solidity: event SetTrustedSequencer(address newTrustedSequencer) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) WatchSetTrustedSequencer(opts *bind.WatchOpts, sink chan<- *OldpolygonzkevmSetTrustedSequencer) (event.Subscription, error) { + + logs, sub, err := _Oldpolygonzkevm.contract.WatchLogs(opts, "SetTrustedSequencer") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(OldpolygonzkevmSetTrustedSequencer) + if err := _Oldpolygonzkevm.contract.UnpackLog(event, "SetTrustedSequencer", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseSetTrustedSequencer is a log parse operation binding the contract event 0xf54144f9611984021529f814a1cb6a41e22c58351510a0d9f7e822618abb9cc0. +// +// Solidity: event SetTrustedSequencer(address newTrustedSequencer) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) ParseSetTrustedSequencer(log types.Log) (*OldpolygonzkevmSetTrustedSequencer, error) { + event := new(OldpolygonzkevmSetTrustedSequencer) + if err := _Oldpolygonzkevm.contract.UnpackLog(event, "SetTrustedSequencer", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// OldpolygonzkevmSetTrustedSequencerURLIterator is returned from FilterSetTrustedSequencerURL and is used to iterate over the raw logs and unpacked data for SetTrustedSequencerURL events raised by the Oldpolygonzkevm contract. +type OldpolygonzkevmSetTrustedSequencerURLIterator struct { + Event *OldpolygonzkevmSetTrustedSequencerURL // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *OldpolygonzkevmSetTrustedSequencerURLIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmSetTrustedSequencerURL) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmSetTrustedSequencerURL) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *OldpolygonzkevmSetTrustedSequencerURLIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *OldpolygonzkevmSetTrustedSequencerURLIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// OldpolygonzkevmSetTrustedSequencerURL represents a SetTrustedSequencerURL event raised by the Oldpolygonzkevm contract. +type OldpolygonzkevmSetTrustedSequencerURL struct { + NewTrustedSequencerURL string + Raw types.Log // Blockchain specific contextual infos +} + +// FilterSetTrustedSequencerURL is a free log retrieval operation binding the contract event 0x6b8f723a4c7a5335cafae8a598a0aa0301be1387c037dccc085b62add6448b20. +// +// Solidity: event SetTrustedSequencerURL(string newTrustedSequencerURL) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) FilterSetTrustedSequencerURL(opts *bind.FilterOpts) (*OldpolygonzkevmSetTrustedSequencerURLIterator, error) { + + logs, sub, err := _Oldpolygonzkevm.contract.FilterLogs(opts, "SetTrustedSequencerURL") + if err != nil { + return nil, err + } + return &OldpolygonzkevmSetTrustedSequencerURLIterator{contract: _Oldpolygonzkevm.contract, event: "SetTrustedSequencerURL", logs: logs, sub: sub}, nil +} + +// WatchSetTrustedSequencerURL is a free log subscription operation binding the contract event 0x6b8f723a4c7a5335cafae8a598a0aa0301be1387c037dccc085b62add6448b20. +// +// Solidity: event SetTrustedSequencerURL(string newTrustedSequencerURL) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) WatchSetTrustedSequencerURL(opts *bind.WatchOpts, sink chan<- *OldpolygonzkevmSetTrustedSequencerURL) (event.Subscription, error) { + + logs, sub, err := _Oldpolygonzkevm.contract.WatchLogs(opts, "SetTrustedSequencerURL") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(OldpolygonzkevmSetTrustedSequencerURL) + if err := _Oldpolygonzkevm.contract.UnpackLog(event, "SetTrustedSequencerURL", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseSetTrustedSequencerURL is a log parse operation binding the contract event 0x6b8f723a4c7a5335cafae8a598a0aa0301be1387c037dccc085b62add6448b20. +// +// Solidity: event SetTrustedSequencerURL(string newTrustedSequencerURL) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) ParseSetTrustedSequencerURL(log types.Log) (*OldpolygonzkevmSetTrustedSequencerURL, error) { + event := new(OldpolygonzkevmSetTrustedSequencerURL) + if err := _Oldpolygonzkevm.contract.UnpackLog(event, "SetTrustedSequencerURL", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// OldpolygonzkevmSetVerifyBatchTimeTargetIterator is returned from FilterSetVerifyBatchTimeTarget and is used to iterate over the raw logs and unpacked data for SetVerifyBatchTimeTarget events raised by the Oldpolygonzkevm contract. +type OldpolygonzkevmSetVerifyBatchTimeTargetIterator struct { + Event *OldpolygonzkevmSetVerifyBatchTimeTarget // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *OldpolygonzkevmSetVerifyBatchTimeTargetIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmSetVerifyBatchTimeTarget) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmSetVerifyBatchTimeTarget) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *OldpolygonzkevmSetVerifyBatchTimeTargetIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *OldpolygonzkevmSetVerifyBatchTimeTargetIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// OldpolygonzkevmSetVerifyBatchTimeTarget represents a SetVerifyBatchTimeTarget event raised by the Oldpolygonzkevm contract. +type OldpolygonzkevmSetVerifyBatchTimeTarget struct { + NewVerifyBatchTimeTarget uint64 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterSetVerifyBatchTimeTarget is a free log retrieval operation binding the contract event 0x1b023231a1ab6b5d93992f168fb44498e1a7e64cef58daff6f1c216de6a68c28. +// +// Solidity: event SetVerifyBatchTimeTarget(uint64 newVerifyBatchTimeTarget) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) FilterSetVerifyBatchTimeTarget(opts *bind.FilterOpts) (*OldpolygonzkevmSetVerifyBatchTimeTargetIterator, error) { + + logs, sub, err := _Oldpolygonzkevm.contract.FilterLogs(opts, "SetVerifyBatchTimeTarget") + if err != nil { + return nil, err + } + return &OldpolygonzkevmSetVerifyBatchTimeTargetIterator{contract: _Oldpolygonzkevm.contract, event: "SetVerifyBatchTimeTarget", logs: logs, sub: sub}, nil +} + +// WatchSetVerifyBatchTimeTarget is a free log subscription operation binding the contract event 0x1b023231a1ab6b5d93992f168fb44498e1a7e64cef58daff6f1c216de6a68c28. +// +// Solidity: event SetVerifyBatchTimeTarget(uint64 newVerifyBatchTimeTarget) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) WatchSetVerifyBatchTimeTarget(opts *bind.WatchOpts, sink chan<- *OldpolygonzkevmSetVerifyBatchTimeTarget) (event.Subscription, error) { + + logs, sub, err := _Oldpolygonzkevm.contract.WatchLogs(opts, "SetVerifyBatchTimeTarget") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(OldpolygonzkevmSetVerifyBatchTimeTarget) + if err := _Oldpolygonzkevm.contract.UnpackLog(event, "SetVerifyBatchTimeTarget", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseSetVerifyBatchTimeTarget is a log parse operation binding the contract event 0x1b023231a1ab6b5d93992f168fb44498e1a7e64cef58daff6f1c216de6a68c28. +// +// Solidity: event SetVerifyBatchTimeTarget(uint64 newVerifyBatchTimeTarget) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) ParseSetVerifyBatchTimeTarget(log types.Log) (*OldpolygonzkevmSetVerifyBatchTimeTarget, error) { + event := new(OldpolygonzkevmSetVerifyBatchTimeTarget) + if err := _Oldpolygonzkevm.contract.UnpackLog(event, "SetVerifyBatchTimeTarget", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// OldpolygonzkevmTransferAdminRoleIterator is returned from FilterTransferAdminRole and is used to iterate over the raw logs and unpacked data for TransferAdminRole events raised by the Oldpolygonzkevm contract. +type OldpolygonzkevmTransferAdminRoleIterator struct { + Event *OldpolygonzkevmTransferAdminRole // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *OldpolygonzkevmTransferAdminRoleIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmTransferAdminRole) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmTransferAdminRole) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *OldpolygonzkevmTransferAdminRoleIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *OldpolygonzkevmTransferAdminRoleIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// OldpolygonzkevmTransferAdminRole represents a TransferAdminRole event raised by the Oldpolygonzkevm contract. +type OldpolygonzkevmTransferAdminRole struct { + NewPendingAdmin common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterTransferAdminRole is a free log retrieval operation binding the contract event 0xa5b56b7906fd0a20e3f35120dd8343db1e12e037a6c90111c7e42885e82a1ce6. +// +// Solidity: event TransferAdminRole(address newPendingAdmin) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) FilterTransferAdminRole(opts *bind.FilterOpts) (*OldpolygonzkevmTransferAdminRoleIterator, error) { + + logs, sub, err := _Oldpolygonzkevm.contract.FilterLogs(opts, "TransferAdminRole") + if err != nil { + return nil, err + } + return &OldpolygonzkevmTransferAdminRoleIterator{contract: _Oldpolygonzkevm.contract, event: "TransferAdminRole", logs: logs, sub: sub}, nil +} + +// WatchTransferAdminRole is a free log subscription operation binding the contract event 0xa5b56b7906fd0a20e3f35120dd8343db1e12e037a6c90111c7e42885e82a1ce6. +// +// Solidity: event TransferAdminRole(address newPendingAdmin) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) WatchTransferAdminRole(opts *bind.WatchOpts, sink chan<- *OldpolygonzkevmTransferAdminRole) (event.Subscription, error) { + + logs, sub, err := _Oldpolygonzkevm.contract.WatchLogs(opts, "TransferAdminRole") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(OldpolygonzkevmTransferAdminRole) + if err := _Oldpolygonzkevm.contract.UnpackLog(event, "TransferAdminRole", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseTransferAdminRole is a log parse operation binding the contract event 0xa5b56b7906fd0a20e3f35120dd8343db1e12e037a6c90111c7e42885e82a1ce6. +// +// Solidity: event TransferAdminRole(address newPendingAdmin) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) ParseTransferAdminRole(log types.Log) (*OldpolygonzkevmTransferAdminRole, error) { + event := new(OldpolygonzkevmTransferAdminRole) + if err := _Oldpolygonzkevm.contract.UnpackLog(event, "TransferAdminRole", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// OldpolygonzkevmUpdateZkEVMVersionIterator is returned from FilterUpdateZkEVMVersion and is used to iterate over the raw logs and unpacked data for UpdateZkEVMVersion events raised by the Oldpolygonzkevm contract. +type OldpolygonzkevmUpdateZkEVMVersionIterator struct { + Event *OldpolygonzkevmUpdateZkEVMVersion // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *OldpolygonzkevmUpdateZkEVMVersionIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmUpdateZkEVMVersion) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmUpdateZkEVMVersion) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *OldpolygonzkevmUpdateZkEVMVersionIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *OldpolygonzkevmUpdateZkEVMVersionIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// OldpolygonzkevmUpdateZkEVMVersion represents a UpdateZkEVMVersion event raised by the Oldpolygonzkevm contract. +type OldpolygonzkevmUpdateZkEVMVersion struct { + NumBatch uint64 + ForkID uint64 + Version string + Raw types.Log // Blockchain specific contextual infos +} + +// FilterUpdateZkEVMVersion is a free log retrieval operation binding the contract event 0xed7be53c9f1a96a481223b15568a5b1a475e01a74b347d6ca187c8bf0c078cd6. +// +// Solidity: event UpdateZkEVMVersion(uint64 numBatch, uint64 forkID, string version) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) FilterUpdateZkEVMVersion(opts *bind.FilterOpts) (*OldpolygonzkevmUpdateZkEVMVersionIterator, error) { + + logs, sub, err := _Oldpolygonzkevm.contract.FilterLogs(opts, "UpdateZkEVMVersion") + if err != nil { + return nil, err + } + return &OldpolygonzkevmUpdateZkEVMVersionIterator{contract: _Oldpolygonzkevm.contract, event: "UpdateZkEVMVersion", logs: logs, sub: sub}, nil +} + +// WatchUpdateZkEVMVersion is a free log subscription operation binding the contract event 0xed7be53c9f1a96a481223b15568a5b1a475e01a74b347d6ca187c8bf0c078cd6. +// +// Solidity: event UpdateZkEVMVersion(uint64 numBatch, uint64 forkID, string version) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) WatchUpdateZkEVMVersion(opts *bind.WatchOpts, sink chan<- *OldpolygonzkevmUpdateZkEVMVersion) (event.Subscription, error) { + + logs, sub, err := _Oldpolygonzkevm.contract.WatchLogs(opts, "UpdateZkEVMVersion") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(OldpolygonzkevmUpdateZkEVMVersion) + if err := _Oldpolygonzkevm.contract.UnpackLog(event, "UpdateZkEVMVersion", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseUpdateZkEVMVersion is a log parse operation binding the contract event 0xed7be53c9f1a96a481223b15568a5b1a475e01a74b347d6ca187c8bf0c078cd6. +// +// Solidity: event UpdateZkEVMVersion(uint64 numBatch, uint64 forkID, string version) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) ParseUpdateZkEVMVersion(log types.Log) (*OldpolygonzkevmUpdateZkEVMVersion, error) { + event := new(OldpolygonzkevmUpdateZkEVMVersion) + if err := _Oldpolygonzkevm.contract.UnpackLog(event, "UpdateZkEVMVersion", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// OldpolygonzkevmVerifyBatchesIterator is returned from FilterVerifyBatches and is used to iterate over the raw logs and unpacked data for VerifyBatches events raised by the Oldpolygonzkevm contract. +type OldpolygonzkevmVerifyBatchesIterator struct { + Event *OldpolygonzkevmVerifyBatches // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *OldpolygonzkevmVerifyBatchesIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmVerifyBatches) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmVerifyBatches) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *OldpolygonzkevmVerifyBatchesIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *OldpolygonzkevmVerifyBatchesIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// OldpolygonzkevmVerifyBatches represents a VerifyBatches event raised by the Oldpolygonzkevm contract. +type OldpolygonzkevmVerifyBatches struct { + NumBatch uint64 + StateRoot [32]byte + Aggregator common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterVerifyBatches is a free log retrieval operation binding the contract event 0x9c72852172521097ba7e1482e6b44b351323df0155f97f4ea18fcec28e1f5966. +// +// Solidity: event VerifyBatches(uint64 indexed numBatch, bytes32 stateRoot, address indexed aggregator) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) FilterVerifyBatches(opts *bind.FilterOpts, numBatch []uint64, aggregator []common.Address) (*OldpolygonzkevmVerifyBatchesIterator, error) { + + var numBatchRule []interface{} + for _, numBatchItem := range numBatch { + numBatchRule = append(numBatchRule, numBatchItem) + } + + var aggregatorRule []interface{} + for _, aggregatorItem := range aggregator { + aggregatorRule = append(aggregatorRule, aggregatorItem) + } + + logs, sub, err := _Oldpolygonzkevm.contract.FilterLogs(opts, "VerifyBatches", numBatchRule, aggregatorRule) + if err != nil { + return nil, err + } + return &OldpolygonzkevmVerifyBatchesIterator{contract: _Oldpolygonzkevm.contract, event: "VerifyBatches", logs: logs, sub: sub}, nil +} + +// WatchVerifyBatches is a free log subscription operation binding the contract event 0x9c72852172521097ba7e1482e6b44b351323df0155f97f4ea18fcec28e1f5966. +// +// Solidity: event VerifyBatches(uint64 indexed numBatch, bytes32 stateRoot, address indexed aggregator) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) WatchVerifyBatches(opts *bind.WatchOpts, sink chan<- *OldpolygonzkevmVerifyBatches, numBatch []uint64, aggregator []common.Address) (event.Subscription, error) { + + var numBatchRule []interface{} + for _, numBatchItem := range numBatch { + numBatchRule = append(numBatchRule, numBatchItem) + } + + var aggregatorRule []interface{} + for _, aggregatorItem := range aggregator { + aggregatorRule = append(aggregatorRule, aggregatorItem) + } + + logs, sub, err := _Oldpolygonzkevm.contract.WatchLogs(opts, "VerifyBatches", numBatchRule, aggregatorRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(OldpolygonzkevmVerifyBatches) + if err := _Oldpolygonzkevm.contract.UnpackLog(event, "VerifyBatches", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseVerifyBatches is a log parse operation binding the contract event 0x9c72852172521097ba7e1482e6b44b351323df0155f97f4ea18fcec28e1f5966. +// +// Solidity: event VerifyBatches(uint64 indexed numBatch, bytes32 stateRoot, address indexed aggregator) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) ParseVerifyBatches(log types.Log) (*OldpolygonzkevmVerifyBatches, error) { + event := new(OldpolygonzkevmVerifyBatches) + if err := _Oldpolygonzkevm.contract.UnpackLog(event, "VerifyBatches", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// OldpolygonzkevmVerifyBatchesTrustedAggregatorIterator is returned from FilterVerifyBatchesTrustedAggregator and is used to iterate over the raw logs and unpacked data for VerifyBatchesTrustedAggregator events raised by the Oldpolygonzkevm contract. +type OldpolygonzkevmVerifyBatchesTrustedAggregatorIterator struct { + Event *OldpolygonzkevmVerifyBatchesTrustedAggregator // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *OldpolygonzkevmVerifyBatchesTrustedAggregatorIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmVerifyBatchesTrustedAggregator) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmVerifyBatchesTrustedAggregator) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *OldpolygonzkevmVerifyBatchesTrustedAggregatorIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *OldpolygonzkevmVerifyBatchesTrustedAggregatorIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// OldpolygonzkevmVerifyBatchesTrustedAggregator represents a VerifyBatchesTrustedAggregator event raised by the Oldpolygonzkevm contract. +type OldpolygonzkevmVerifyBatchesTrustedAggregator struct { + NumBatch uint64 + StateRoot [32]byte + Aggregator common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterVerifyBatchesTrustedAggregator is a free log retrieval operation binding the contract event 0xcb339b570a7f0b25afa7333371ff11192092a0aeace12b671f4c212f2815c6fe. +// +// Solidity: event VerifyBatchesTrustedAggregator(uint64 indexed numBatch, bytes32 stateRoot, address indexed aggregator) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) FilterVerifyBatchesTrustedAggregator(opts *bind.FilterOpts, numBatch []uint64, aggregator []common.Address) (*OldpolygonzkevmVerifyBatchesTrustedAggregatorIterator, error) { + + var numBatchRule []interface{} + for _, numBatchItem := range numBatch { + numBatchRule = append(numBatchRule, numBatchItem) + } + + var aggregatorRule []interface{} + for _, aggregatorItem := range aggregator { + aggregatorRule = append(aggregatorRule, aggregatorItem) + } + + logs, sub, err := _Oldpolygonzkevm.contract.FilterLogs(opts, "VerifyBatchesTrustedAggregator", numBatchRule, aggregatorRule) + if err != nil { + return nil, err + } + return &OldpolygonzkevmVerifyBatchesTrustedAggregatorIterator{contract: _Oldpolygonzkevm.contract, event: "VerifyBatchesTrustedAggregator", logs: logs, sub: sub}, nil +} + +// WatchVerifyBatchesTrustedAggregator is a free log subscription operation binding the contract event 0xcb339b570a7f0b25afa7333371ff11192092a0aeace12b671f4c212f2815c6fe. +// +// Solidity: event VerifyBatchesTrustedAggregator(uint64 indexed numBatch, bytes32 stateRoot, address indexed aggregator) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) WatchVerifyBatchesTrustedAggregator(opts *bind.WatchOpts, sink chan<- *OldpolygonzkevmVerifyBatchesTrustedAggregator, numBatch []uint64, aggregator []common.Address) (event.Subscription, error) { + + var numBatchRule []interface{} + for _, numBatchItem := range numBatch { + numBatchRule = append(numBatchRule, numBatchItem) + } + + var aggregatorRule []interface{} + for _, aggregatorItem := range aggregator { + aggregatorRule = append(aggregatorRule, aggregatorItem) + } + + logs, sub, err := _Oldpolygonzkevm.contract.WatchLogs(opts, "VerifyBatchesTrustedAggregator", numBatchRule, aggregatorRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(OldpolygonzkevmVerifyBatchesTrustedAggregator) + if err := _Oldpolygonzkevm.contract.UnpackLog(event, "VerifyBatchesTrustedAggregator", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseVerifyBatchesTrustedAggregator is a log parse operation binding the contract event 0xcb339b570a7f0b25afa7333371ff11192092a0aeace12b671f4c212f2815c6fe. +// +// Solidity: event VerifyBatchesTrustedAggregator(uint64 indexed numBatch, bytes32 stateRoot, address indexed aggregator) +func (_Oldpolygonzkevm *OldpolygonzkevmFilterer) ParseVerifyBatchesTrustedAggregator(log types.Log) (*OldpolygonzkevmVerifyBatchesTrustedAggregator, error) { + event := new(OldpolygonzkevmVerifyBatchesTrustedAggregator) + if err := _Oldpolygonzkevm.contract.UnpackLog(event, "VerifyBatchesTrustedAggregator", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/etherman/smartcontracts/oldpolygonzkevmbridge/oldpolygonzkevmbridge.go b/etherman/smartcontracts/oldpolygonzkevmbridge/oldpolygonzkevmbridge.go new file mode 100644 index 0000000..da71cf6 --- /dev/null +++ b/etherman/smartcontracts/oldpolygonzkevmbridge/oldpolygonzkevmbridge.go @@ -0,0 +1,1666 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package oldpolygonzkevmbridge + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// OldpolygonzkevmbridgeMetaData contains all meta data concerning the Oldpolygonzkevmbridge contract. +var OldpolygonzkevmbridgeMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[],\"name\":\"AlreadyClaimed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"AmountDoesNotMatchMsgValue\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DestinationNetworkInvalid\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"EtherTransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"GlobalExitRootInvalid\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidSmtProof\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"MerkleTreeFull\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"MessageFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"MsgValueNotZero\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotValidAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotValidOwner\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotValidSignature\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotValidSpender\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OnlyEmergencyState\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OnlyNotEmergencyState\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OnlyPolygonZkEVM\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"leafType\",\"type\":\"uint8\"},{\"indexed\":false,\"internalType\":\"uint32\",\"name\":\"originNetwork\",\"type\":\"uint32\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"originAddress\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint32\",\"name\":\"destinationNetwork\",\"type\":\"uint32\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"destinationAddress\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"metadata\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint32\",\"name\":\"depositCount\",\"type\":\"uint32\"}],\"name\":\"BridgeEvent\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint32\",\"name\":\"index\",\"type\":\"uint32\"},{\"indexed\":false,\"internalType\":\"uint32\",\"name\":\"originNetwork\",\"type\":\"uint32\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"originAddress\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"destinationAddress\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"ClaimEvent\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[],\"name\":\"EmergencyStateActivated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[],\"name\":\"EmergencyStateDeactivated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint32\",\"name\":\"originNetwork\",\"type\":\"uint32\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"originTokenAddress\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"wrappedTokenAddress\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"metadata\",\"type\":\"bytes\"}],\"name\":\"NewWrappedToken\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"activateEmergencyState\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"destinationNetwork\",\"type\":\"uint32\"},{\"internalType\":\"address\",\"name\":\"destinationAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"forceUpdateGlobalExitRoot\",\"type\":\"bool\"},{\"internalType\":\"bytes\",\"name\":\"permitData\",\"type\":\"bytes\"}],\"name\":\"bridgeAsset\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"destinationNetwork\",\"type\":\"uint32\"},{\"internalType\":\"address\",\"name\":\"destinationAddress\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"forceUpdateGlobalExitRoot\",\"type\":\"bool\"},{\"internalType\":\"bytes\",\"name\":\"metadata\",\"type\":\"bytes\"}],\"name\":\"bridgeMessage\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32[32]\",\"name\":\"smtProof\",\"type\":\"bytes32[32]\"},{\"internalType\":\"uint32\",\"name\":\"index\",\"type\":\"uint32\"},{\"internalType\":\"bytes32\",\"name\":\"mainnetExitRoot\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"rollupExitRoot\",\"type\":\"bytes32\"},{\"internalType\":\"uint32\",\"name\":\"originNetwork\",\"type\":\"uint32\"},{\"internalType\":\"address\",\"name\":\"originTokenAddress\",\"type\":\"address\"},{\"internalType\":\"uint32\",\"name\":\"destinationNetwork\",\"type\":\"uint32\"},{\"internalType\":\"address\",\"name\":\"destinationAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"metadata\",\"type\":\"bytes\"}],\"name\":\"claimAsset\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32[32]\",\"name\":\"smtProof\",\"type\":\"bytes32[32]\"},{\"internalType\":\"uint32\",\"name\":\"index\",\"type\":\"uint32\"},{\"internalType\":\"bytes32\",\"name\":\"mainnetExitRoot\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"rollupExitRoot\",\"type\":\"bytes32\"},{\"internalType\":\"uint32\",\"name\":\"originNetwork\",\"type\":\"uint32\"},{\"internalType\":\"address\",\"name\":\"originAddress\",\"type\":\"address\"},{\"internalType\":\"uint32\",\"name\":\"destinationNetwork\",\"type\":\"uint32\"},{\"internalType\":\"address\",\"name\":\"destinationAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"metadata\",\"type\":\"bytes\"}],\"name\":\"claimMessage\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"claimedBitMap\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"deactivateEmergencyState\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"depositCount\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getDepositRoot\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint8\",\"name\":\"leafType\",\"type\":\"uint8\"},{\"internalType\":\"uint32\",\"name\":\"originNetwork\",\"type\":\"uint32\"},{\"internalType\":\"address\",\"name\":\"originAddress\",\"type\":\"address\"},{\"internalType\":\"uint32\",\"name\":\"destinationNetwork\",\"type\":\"uint32\"},{\"internalType\":\"address\",\"name\":\"destinationAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"metadataHash\",\"type\":\"bytes32\"}],\"name\":\"getLeafValue\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"originNetwork\",\"type\":\"uint32\"},{\"internalType\":\"address\",\"name\":\"originTokenAddress\",\"type\":\"address\"}],\"name\":\"getTokenWrappedAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"globalExitRootManager\",\"outputs\":[{\"internalType\":\"contractIBasePolygonZkEVMGlobalExitRoot\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"_networkID\",\"type\":\"uint32\"},{\"internalType\":\"contractIBasePolygonZkEVMGlobalExitRoot\",\"name\":\"_globalExitRootManager\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_polygonZkEVMaddress\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"index\",\"type\":\"uint256\"}],\"name\":\"isClaimed\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"isEmergencyState\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"lastUpdatedDepositCount\",\"outputs\":[{\"internalType\":\"uint32\",\"name\":\"\",\"type\":\"uint32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"networkID\",\"outputs\":[{\"internalType\":\"uint32\",\"name\":\"\",\"type\":\"uint32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"polygonZkEVMaddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"originNetwork\",\"type\":\"uint32\"},{\"internalType\":\"address\",\"name\":\"originTokenAddress\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"symbol\",\"type\":\"string\"},{\"internalType\":\"uint8\",\"name\":\"decimals\",\"type\":\"uint8\"}],\"name\":\"precalculatedWrapperAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"tokenInfoToWrappedToken\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"updateGlobalExitRoot\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"leafHash\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32[32]\",\"name\":\"smtProof\",\"type\":\"bytes32[32]\"},{\"internalType\":\"uint32\",\"name\":\"index\",\"type\":\"uint32\"},{\"internalType\":\"bytes32\",\"name\":\"root\",\"type\":\"bytes32\"}],\"name\":\"verifyMerkleProof\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"wrappedTokenToTokenInfo\",\"outputs\":[{\"internalType\":\"uint32\",\"name\":\"originNetwork\",\"type\":\"uint32\"},{\"internalType\":\"address\",\"name\":\"originTokenAddress\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", + Bin: "0x608060405234801561001057600080fd5b50615c83806100206000396000f3fe6080604052600436106200019f5760003560e01c8063647c576c11620000e7578063be5831c71162000089578063dbc169761162000060578063dbc169761462000639578063ee25560b1462000651578063fb570834146200068257600080fd5b8063be5831c714620005ae578063cd58657914620005ea578063d02103ca146200060157600080fd5b80639e34070f11620000be5780639e34070f146200050a578063aaa13cc2146200054f578063bab161bf146200057457600080fd5b8063647c576c146200048657806379e2cf9714620004ab57806381b1c17414620004c357600080fd5b80632d2c9d94116200015157806334ac9cf2116200012857806334ac9cf2146200034b5780633ae05047146200037a5780633e197043146200039257600080fd5b80632d2c9d9414620002765780632dfdf0b5146200029b578063318aee3d14620002c257600080fd5b806322e95f2c116200018657806322e95f2c14620001ef578063240ff378146200023a5780632cffd02e146200025157600080fd5b806315064c9614620001a45780632072f6c514620001d5575b600080fd5b348015620001b157600080fd5b50606854620001c09060ff1681565b60405190151581526020015b60405180910390f35b348015620001e257600080fd5b50620001ed620006a7565b005b348015620001fc57600080fd5b50620002146200020e366004620032db565b62000705565b60405173ffffffffffffffffffffffffffffffffffffffff9091168152602001620001cc565b620001ed6200024b36600462003372565b620007a8565b3480156200025e57600080fd5b50620001ed6200027036600462003409565b620009d0565b3480156200028357600080fd5b50620001ed6200029536600462003409565b62000f74565b348015620002a857600080fd5b50620002b360535481565b604051908152602001620001cc565b348015620002cf57600080fd5b5062000319620002e1366004620034ef565b606b6020526000908152604090205463ffffffff811690640100000000900473ffffffffffffffffffffffffffffffffffffffff1682565b6040805163ffffffff909316835273ffffffffffffffffffffffffffffffffffffffff909116602083015201620001cc565b3480156200035857600080fd5b50606c54620002149073ffffffffffffffffffffffffffffffffffffffff1681565b3480156200038757600080fd5b50620002b362001178565b3480156200039f57600080fd5b50620002b3620003b136600462003526565b6040517fff0000000000000000000000000000000000000000000000000000000000000060f889901b1660208201527fffffffff0000000000000000000000000000000000000000000000000000000060e088811b821660218401527fffffffffffffffffffffffffffffffffffffffff000000000000000000000000606089811b821660258601529188901b909216603984015285901b16603d8201526051810183905260718101829052600090609101604051602081830303815290604052805190602001209050979650505050505050565b3480156200049357600080fd5b50620001ed620004a5366004620035b0565b6200125e565b348015620004b857600080fd5b50620001ed620014ad565b348015620004d057600080fd5b5062000214620004e236600462003600565b606a6020526000908152604090205473ffffffffffffffffffffffffffffffffffffffff1681565b3480156200051757600080fd5b50620001c06200052936600462003600565b600881901c600090815260696020526040902054600160ff9092169190911b9081161490565b3480156200055c57600080fd5b50620002146200056e3660046200361a565b620014e7565b3480156200058157600080fd5b506068546200059890610100900463ffffffff1681565b60405163ffffffff9091168152602001620001cc565b348015620005bb57600080fd5b506068546200059890790100000000000000000000000000000000000000000000000000900463ffffffff1681565b620001ed620005fb366004620036ce565b620016d3565b3480156200060e57600080fd5b50606854620002149065010000000000900473ffffffffffffffffffffffffffffffffffffffff1681565b3480156200064657600080fd5b50620001ed62001c37565b3480156200065e57600080fd5b50620002b36200067036600462003600565b60696020526000908152604090205481565b3480156200068f57600080fd5b50620001c0620006a136600462003770565b62001c93565b606c5473ffffffffffffffffffffffffffffffffffffffff163314620006f9576040517fe2e8106b00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6200070362001d7c565b565b6040805160e084901b7fffffffff0000000000000000000000000000000000000000000000000000000016602080830191909152606084901b7fffffffffffffffffffffffffffffffffffffffff00000000000000000000000016602483015282516018818403018152603890920183528151918101919091206000908152606a909152205473ffffffffffffffffffffffffffffffffffffffff165b92915050565b60685460ff1615620007e6576040517f2f0047fc00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60685463ffffffff8681166101009092041614806200080c5750600263ffffffff861610155b1562000844576040517f0595ea2e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b7f501781209a1f8899323b96b4ef08b168df93e0a90c673d1e4cce39366cb62f9b6001606860019054906101000a900463ffffffff163388883488886053546040516200089a9998979695949392919062003806565b60405180910390a1620009b8620009b26001606860019054906101000a900463ffffffff16338989348989604051620008d592919062003881565b60405180910390206040517fff0000000000000000000000000000000000000000000000000000000000000060f889901b1660208201527fffffffff0000000000000000000000000000000000000000000000000000000060e088811b821660218401527fffffffffffffffffffffffffffffffffffffffff000000000000000000000000606089811b821660258601529188901b909216603984015285901b16603d8201526051810183905260718101829052600090609101604051602081830303815290604052805190602001209050979650505050505050565b62001e10565b8215620009c957620009c962001f27565b5050505050565b60685460ff161562000a0e576040517f2f0047fc00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b62000a258b8b8b8b8b8b8b8b8b8b8b600062001ffc565b73ffffffffffffffffffffffffffffffffffffffff861662000b01576040805160008082526020820190925273ffffffffffffffffffffffffffffffffffffffff861690859060405162000a7a9190620038e6565b60006040518083038185875af1925050503d806000811462000ab9576040519150601f19603f3d011682016040523d82523d6000602084013e62000abe565b606091505b505090508062000afa576040517f6747a28800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5062000efc565b60685463ffffffff61010090910481169088160362000b435762000b3d73ffffffffffffffffffffffffffffffffffffffff87168585620021ed565b62000efc565b6040517fffffffff0000000000000000000000000000000000000000000000000000000060e089901b1660208201527fffffffffffffffffffffffffffffffffffffffff000000000000000000000000606088901b166024820152600090603801604080517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe081840301815291815281516020928301206000818152606a90935291205490915073ffffffffffffffffffffffffffffffffffffffff168062000e6e576000808062000c1886880188620039fb565b92509250925060008584848460405162000c329062003292565b62000c409392919062003abd565b8190604051809103906000f590508015801562000c61573d6000803e3d6000fd5b506040517f40c10f1900000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff8c81166004830152602482018c9052919250908216906340c10f1990604401600060405180830381600087803b15801562000cd757600080fd5b505af115801562000cec573d6000803e3d6000fd5b5050505080606a600088815260200190815260200160002060006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555060405180604001604052808e63ffffffff1681526020018d73ffffffffffffffffffffffffffffffffffffffff16815250606b60008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008201518160000160006101000a81548163ffffffff021916908363ffffffff16021790555060208201518160000160046101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055509050507f490e59a1701b938786ac72570a1efeac994a3dbe96e2e883e19e902ace6e6a398d8d838b8b60405162000e5c95949392919062003afa565b60405180910390a15050505062000ef9565b6040517f40c10f1900000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff8781166004830152602482018790528216906340c10f1990604401600060405180830381600087803b15801562000edf57600080fd5b505af115801562000ef4573d6000803e3d6000fd5b505050505b50505b6040805163ffffffff8c811682528916602082015273ffffffffffffffffffffffffffffffffffffffff88811682840152861660608201526080810185905290517f25308c93ceeed162da955b3f7ce3e3f93606579e40fb92029faa9efe275459839181900360a00190a15050505050505050505050565b60685460ff161562000fb2576040517f2f0047fc00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b62000fc98b8b8b8b8b8b8b8b8b8b8b600162001ffc565b60008473ffffffffffffffffffffffffffffffffffffffff1684888a868660405160240162000ffc949392919062003b42565b604080517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe08184030181529181526020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167f1806b5f200000000000000000000000000000000000000000000000000000000179052516200107f9190620038e6565b60006040518083038185875af1925050503d8060008114620010be576040519150601f19603f3d011682016040523d82523d6000602084013e620010c3565b606091505b5050905080620010ff576040517f37e391c300000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6040805163ffffffff8d811682528a16602082015273ffffffffffffffffffffffffffffffffffffffff89811682840152871660608201526080810186905290517f25308c93ceeed162da955b3f7ce3e3f93606579e40fb92029faa9efe275459839181900360a00190a1505050505050505050505050565b605354600090819081805b602081101562001255578083901c600116600103620011e65760338160208110620011b257620011b262003b8a565b0154604080516020810192909252810185905260600160405160208183030381529060405280519060200120935062001213565b60408051602081018690529081018390526060016040516020818303038152906040528051906020012093505b604080516020810184905290810183905260600160405160208183030381529060405280519060200120915080806200124c9062003be8565b91505062001183565b50919392505050565b600054610100900460ff16158080156200127f5750600054600160ff909116105b806200129b5750303b1580156200129b575060005460ff166001145b6200132d576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602e60248201527f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160448201527f647920696e697469616c697a656400000000000000000000000000000000000060648201526084015b60405180910390fd5b600080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0016600117905580156200138c57600080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff166101001790555b606880547fffffffffffffff000000000000000000000000000000000000000000000000ff1661010063ffffffff8716027fffffffffffffff0000000000000000000000000000000000000000ffffffffff16176501000000000073ffffffffffffffffffffffffffffffffffffffff8681169190910291909117909155606c80547fffffffffffffffffffffffff00000000000000000000000000000000000000001691841691909117905562001443620022c3565b8015620014a757600080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff169055604051600181527f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb38474024989060200160405180910390a15b50505050565b605354606854790100000000000000000000000000000000000000000000000000900463ffffffff16101562000703576200070362001f27565b6040517fffffffff0000000000000000000000000000000000000000000000000000000060e089901b1660208201527fffffffffffffffffffffffffffffffffffffffff000000000000000000000000606088901b1660248201526000908190603801604051602081830303815290604052805190602001209050600060ff60f81b3083604051806020016200157d9062003292565b7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe082820381018352601f909101166040819052620015c8908d908d908d908d908d9060200162003c23565b604080517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe08184030181529082905262001606929160200162003c64565b604051602081830303815290604052805190602001206040516020016200168f94939291907fff0000000000000000000000000000000000000000000000000000000000000094909416845260609290921b7fffffffffffffffffffffffffffffffffffffffff0000000000000000000000001660018401526015830152603582015260550190565b604080518083037fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe001815291905280516020909101209a9950505050505050505050565b60685460ff161562001711576040517f2f0047fc00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6200171b62002366565b60685463ffffffff888116610100909204161480620017415750600263ffffffff881610155b1562001779576040517f0595ea2e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60008060608773ffffffffffffffffffffffffffffffffffffffff8816620017df57883414620017d5576040517fb89240f500000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6000925062001ad9565b341562001818576040517f798ee6f100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b73ffffffffffffffffffffffffffffffffffffffff8089166000908152606b602090815260409182902082518084019093525463ffffffff811683526401000000009004909216918101829052901562001908576040517f9dc29fac000000000000000000000000000000000000000000000000000000008152336004820152602481018b905273ffffffffffffffffffffffffffffffffffffffff8a1690639dc29fac90604401600060405180830381600087803b158015620018db57600080fd5b505af1158015620018f0573d6000803e3d6000fd5b50505050806020015194508060000151935062001ad7565b85156200191d576200191d898b8989620023db565b6040517f70a0823100000000000000000000000000000000000000000000000000000000815230600482015260009073ffffffffffffffffffffffffffffffffffffffff8b16906370a0823190602401602060405180830381865afa1580156200198b573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190620019b1919062003c97565b9050620019d773ffffffffffffffffffffffffffffffffffffffff8b1633308e620028f9565b6040517f70a0823100000000000000000000000000000000000000000000000000000000815230600482015260009073ffffffffffffffffffffffffffffffffffffffff8c16906370a0823190602401602060405180830381865afa15801562001a45573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019062001a6b919062003c97565b905062001a79828262003cb1565b6068548c9850610100900463ffffffff169650935062001a998762002959565b62001aa48c62002a71565b62001aaf8d62002b7e565b60405160200162001ac39392919062003abd565b604051602081830303815290604052945050505b505b7f501781209a1f8899323b96b4ef08b168df93e0a90c673d1e4cce39366cb62f9b600084868e8e868860535460405162001b1b98979695949392919062003cc7565b60405180910390a162001c0f620009b2600085878f8f8789805190602001206040517fff0000000000000000000000000000000000000000000000000000000000000060f889901b1660208201527fffffffff0000000000000000000000000000000000000000000000000000000060e088811b821660218401527fffffffffffffffffffffffffffffffffffffffff000000000000000000000000606089811b821660258601529188901b909216603984015285901b16603d8201526051810183905260718101829052600090609101604051602081830303815290604052805190602001209050979650505050505050565b861562001c205762001c2062001f27565b5050505062001c2e60018055565b50505050505050565b606c5473ffffffffffffffffffffffffffffffffffffffff16331462001c89576040517fe2e8106b00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6200070362002c80565b600084815b602081101562001d6e57600163ffffffff8616821c8116900362001d0a5785816020811062001ccb5762001ccb62003b8a565b60200201358260405160200162001cec929190918252602082015260400190565b60405160208183030381529060405280519060200120915062001d59565b8186826020811062001d205762001d2062003b8a565b602002013560405160200162001d40929190918252602082015260400190565b6040516020818303038152906040528051906020012091505b8062001d658162003be8565b91505062001c98565b50821490505b949350505050565b60685460ff161562001dba576040517f2f0047fc00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b606880547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff001660011790556040517f2261efe5aef6fedc1fd1550b25facc9181745623049c7901287030b9ad1a549790600090a1565b80600162001e216020600262003e79565b62001e2d919062003cb1565b6053541062001e68576040517fef5ccf6600000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600060536000815462001e7b9062003be8565b9182905550905060005b602081101562001f17578082901c60011660010362001ebd57826033826020811062001eb55762001eb562003b8a565b015550505050565b6033816020811062001ed35762001ed362003b8a565b01546040805160208101929092528101849052606001604051602081830303815290604052805190602001209250808062001f0e9062003be8565b91505062001e85565b5062001f2262003e87565b505050565b6053546068805463ffffffff909216790100000000000000000000000000000000000000000000000000027fffffff00000000ffffffffffffffffffffffffffffffffffffffffffffffffff909216919091179081905573ffffffffffffffffffffffffffffffffffffffff65010000000000909104166333d6247d62001fad62001178565b6040518263ffffffff1660e01b815260040162001fcc91815260200190565b600060405180830381600087803b15801562001fe757600080fd5b505af1158015620014a7573d6000803e3d6000fd5b6200200d8b63ffffffff1662002d10565b6068546040805160208082018e90528183018d9052825180830384018152606083019384905280519101207f257b363200000000000000000000000000000000000000000000000000000000909252606481019190915260009165010000000000900473ffffffffffffffffffffffffffffffffffffffff169063257b3632906084016020604051808303816000875af1158015620020b0573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190620020d6919062003c97565b90508060000362002112576040517e2f6fad00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60685463ffffffff88811661010090920416146200215c576040517f0595ea2e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b606854600090610100900463ffffffff166200217a5750896200217d565b508a5b620021a66200219d848c8c8c8c8c8c8c604051620008d592919062003881565b8f8f8462001c93565b620021dd576040517fe0417cec00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5050505050505050505050505050565b60405173ffffffffffffffffffffffffffffffffffffffff831660248201526044810182905262001f229084907fa9059cbb00000000000000000000000000000000000000000000000000000000906064015b604080517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe08184030181529190526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fffffffff000000000000000000000000000000000000000000000000000000009093169290921790915262002d75565b600054610100900460ff166200235c576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602b60248201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960448201527f6e697469616c697a696e67000000000000000000000000000000000000000000606482015260840162001324565b6200070362002e88565b600260015403620023d4576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601f60248201527f5265656e7472616e637947756172643a207265656e7472616e742063616c6c00604482015260640162001324565b6002600155565b6000620023ec600482848662003eb6565b620023f79162003ee2565b90507f2afa5331000000000000000000000000000000000000000000000000000000007fffffffff00000000000000000000000000000000000000000000000000000000821601620026765760008080808080806200245a896004818d62003eb6565b81019062002469919062003f2b565b96509650965096509650965096503373ffffffffffffffffffffffffffffffffffffffff168773ffffffffffffffffffffffffffffffffffffffff1614620024dd576040517f912ecce700000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b73ffffffffffffffffffffffffffffffffffffffff861630146200252d576040517f750643af00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8a851462002567576040517f03fffc4b00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6040805173ffffffffffffffffffffffffffffffffffffffff89811660248301528881166044830152606482018890526084820187905260ff861660a483015260c4820185905260e48083018590528351808403909101815261010490920183526020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fd505accf000000000000000000000000000000000000000000000000000000001790529151918e1691620026229190620038e6565b6000604051808303816000865af19150503d806000811462002661576040519150601f19603f3d011682016040523d82523d6000602084013e62002666565b606091505b50505050505050505050620009c9565b7fffffffff0000000000000000000000000000000000000000000000000000000081167f8fcbaf0c0000000000000000000000000000000000000000000000000000000014620026f2576040517fe282c0ba00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6000808080808080806200270a8a6004818e62003eb6565b81019062002719919062003f86565b975097509750975097509750975097503373ffffffffffffffffffffffffffffffffffffffff168873ffffffffffffffffffffffffffffffffffffffff16146200278f576040517f912ecce700000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b73ffffffffffffffffffffffffffffffffffffffff87163014620027df576040517f750643af00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6040805173ffffffffffffffffffffffffffffffffffffffff8a811660248301528981166044830152606482018990526084820188905286151560a483015260ff861660c483015260e482018590526101048083018590528351808403909101815261012490920183526020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167f8fcbaf0c000000000000000000000000000000000000000000000000000000001790529151918f1691620028a39190620038e6565b6000604051808303816000865af19150503d8060008114620028e2576040519150601f19603f3d011682016040523d82523d6000602084013e620028e7565b606091505b50505050505050505050505050505050565b60405173ffffffffffffffffffffffffffffffffffffffff80851660248301528316604482015260648101829052620014a79085907f23b872dd000000000000000000000000000000000000000000000000000000009060840162002240565b60408051600481526024810182526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167f06fdde03000000000000000000000000000000000000000000000000000000001790529051606091600091829173ffffffffffffffffffffffffffffffffffffffff861691620029dd9190620038e6565b600060405180830381855afa9150503d806000811462002a1a576040519150601f19603f3d011682016040523d82523d6000602084013e62002a1f565b606091505b50915091508162002a66576040518060400160405280600781526020017f4e4f5f4e414d450000000000000000000000000000000000000000000000000081525062001d74565b62001d748162002f21565b60408051600481526024810182526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167f95d89b41000000000000000000000000000000000000000000000000000000001790529051606091600091829173ffffffffffffffffffffffffffffffffffffffff86169162002af59190620038e6565b600060405180830381855afa9150503d806000811462002b32576040519150601f19603f3d011682016040523d82523d6000602084013e62002b37565b606091505b50915091508162002a66576040518060400160405280600981526020017f4e4f5f53594d424f4c000000000000000000000000000000000000000000000081525062001d74565b60408051600481526024810182526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167f313ce5670000000000000000000000000000000000000000000000000000000017905290516000918291829173ffffffffffffffffffffffffffffffffffffffff86169162002c019190620038e6565b600060405180830381855afa9150503d806000811462002c3e576040519150601f19603f3d011682016040523d82523d6000602084013e62002c43565b606091505b509150915081801562002c57575080516020145b62002c6457601262001d74565b8080602001905181019062001d74919062004012565b60018055565b60685460ff1662002cbd576040517f5386698100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b606880547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff001690556040517f1e5e34eea33501aecf2ebec9fe0e884a40804275ea7fe10b2ba084c8374308b390600090a1565b600881901c60008181526069602052604081208054600160ff861690811b91821892839055929091908183169003620009c9576040517f646cf55800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600062002dd9826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff16620031119092919063ffffffff16565b80519091501562001f22578080602001905181019062002dfa919062004032565b62001f22576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e60448201527f6f74207375636365656400000000000000000000000000000000000000000000606482015260840162001324565b600054610100900460ff1662002c7a576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602b60248201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960448201527f6e697469616c697a696e67000000000000000000000000000000000000000000606482015260840162001324565b6060604082511062002f435781806020019051810190620007a2919062004052565b8151602003620030d35760005b60208110801562002f9b575082818151811062002f715762002f7162003b8a565b01602001517fff000000000000000000000000000000000000000000000000000000000000001615155b1562002fb6578062002fad8162003be8565b91505062002f50565b8060000362002ffa57505060408051808201909152601281527f4e4f545f56414c49445f454e434f44494e4700000000000000000000000000006020820152919050565b60008167ffffffffffffffff81111562003018576200301862003891565b6040519080825280601f01601f19166020018201604052801562003043576020820181803683370190505b50905060005b82811015620030cb5784818151811062003067576200306762003b8a565b602001015160f81c60f81b82828151811062003087576200308762003b8a565b60200101907effffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916908160001a90535080620030c28162003be8565b91505062003049565b509392505050565b505060408051808201909152601281527f4e4f545f56414c49445f454e434f44494e470000000000000000000000000000602082015290565b919050565b606062001d748484600085856000808673ffffffffffffffffffffffffffffffffffffffff168587604051620031489190620038e6565b60006040518083038185875af1925050503d806000811462003187576040519150601f19603f3d011682016040523d82523d6000602084013e6200318c565b606091505b50915091506200319f87838387620031aa565b979650505050505050565b60608315620032455782516000036200323d5773ffffffffffffffffffffffffffffffffffffffff85163b6200323d576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000604482015260640162001324565b508162001d74565b62001d7483838151156200325c5781518083602001fd5b806040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401620013249190620040d2565b611b6680620040e883390190565b803563ffffffff811681146200310c57600080fd5b73ffffffffffffffffffffffffffffffffffffffff81168114620032d857600080fd5b50565b60008060408385031215620032ef57600080fd5b620032fa83620032a0565b915060208301356200330c81620032b5565b809150509250929050565b8015158114620032d857600080fd5b60008083601f8401126200333957600080fd5b50813567ffffffffffffffff8111156200335257600080fd5b6020830191508360208285010111156200336b57600080fd5b9250929050565b6000806000806000608086880312156200338b57600080fd5b6200339686620032a0565b94506020860135620033a881620032b5565b93506040860135620033ba8162003317565b9250606086013567ffffffffffffffff811115620033d757600080fd5b620033e58882890162003326565b969995985093965092949392505050565b806104008101831015620007a257600080fd5b60008060008060008060008060008060006105208c8e0312156200342c57600080fd5b620034388d8d620033f6565b9a50620034496104008d01620032a0565b99506104208c013598506104408c013597506200346a6104608d01620032a0565b96506104808c01356200347d81620032b5565b95506200348e6104a08d01620032a0565b94506104c08c0135620034a181620032b5565b93506104e08c013592506105008c013567ffffffffffffffff811115620034c757600080fd5b620034d58e828f0162003326565b915080935050809150509295989b509295989b9093969950565b6000602082840312156200350257600080fd5b81356200350f81620032b5565b9392505050565b60ff81168114620032d857600080fd5b600080600080600080600060e0888a0312156200354257600080fd5b87356200354f8162003516565b96506200355f60208901620032a0565b955060408801356200357181620032b5565b94506200358160608901620032a0565b935060808801356200359381620032b5565b9699959850939692959460a0840135945060c09093013592915050565b600080600060608486031215620035c657600080fd5b620035d184620032a0565b92506020840135620035e381620032b5565b91506040840135620035f581620032b5565b809150509250925092565b6000602082840312156200361357600080fd5b5035919050565b600080600080600080600060a0888a0312156200363657600080fd5b6200364188620032a0565b965060208801356200365381620032b5565b9550604088013567ffffffffffffffff808211156200367157600080fd5b6200367f8b838c0162003326565b909750955060608a01359150808211156200369957600080fd5b50620036a88a828b0162003326565b9094509250506080880135620036be8162003516565b8091505092959891949750929550565b600080600080600080600060c0888a031215620036ea57600080fd5b620036f588620032a0565b965060208801356200370781620032b5565b95506040880135945060608801356200372081620032b5565b93506080880135620037328162003317565b925060a088013567ffffffffffffffff8111156200374f57600080fd5b6200375d8a828b0162003326565b989b979a50959850939692959293505050565b60008060008061046085870312156200378857600080fd5b843593506200379b8660208701620033f6565b9250620037ac6104208601620032a0565b939692955092936104400135925050565b8183528181602085013750600060208284010152600060207fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0601f840116840101905092915050565b600061010060ff8c16835263ffffffff808c16602085015273ffffffffffffffffffffffffffffffffffffffff808c166040860152818b166060860152808a166080860152508760a08501528160c0850152620038678285018789620037bd565b925080851660e085015250509a9950505050505050505050565b8183823760009101908152919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b60005b83811015620038dd578181015183820152602001620038c3565b50506000910152565b60008251620038fa818460208701620038c0565b9190910192915050565b604051601f82017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe016810167ffffffffffffffff811182821017156200394e576200394e62003891565b604052919050565b600067ffffffffffffffff82111562003973576200397362003891565b50601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe01660200190565b600082601f830112620039b157600080fd5b8135620039c8620039c28262003956565b62003904565b818152846020838601011115620039de57600080fd5b816020850160208301376000918101602001919091529392505050565b60008060006060848603121562003a1157600080fd5b833567ffffffffffffffff8082111562003a2a57600080fd5b62003a38878388016200399f565b9450602086013591508082111562003a4f57600080fd5b5062003a5e868287016200399f565b9250506040840135620035f58162003516565b6000815180845262003a8b816020860160208601620038c0565b601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0169290920160200192915050565b60608152600062003ad2606083018662003a71565b828103602084015262003ae6818662003a71565b91505060ff83166040830152949350505050565b63ffffffff86168152600073ffffffffffffffffffffffffffffffffffffffff8087166020840152808616604084015250608060608301526200319f608083018486620037bd565b73ffffffffffffffffffffffffffffffffffffffff8516815263ffffffff8416602082015260606040820152600062003b80606083018486620037bd565b9695505050505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff820362003c1c5762003c1c62003bb9565b5060010190565b60608152600062003c39606083018789620037bd565b828103602084015262003c4e818688620037bd565b91505060ff831660408301529695505050505050565b6000835162003c78818460208801620038c0565b83519083019062003c8e818360208801620038c0565b01949350505050565b60006020828403121562003caa57600080fd5b5051919050565b81810381811115620007a257620007a262003bb9565b600061010060ff8b16835263ffffffff808b16602085015273ffffffffffffffffffffffffffffffffffffffff808b166040860152818a1660608601528089166080860152508660a08501528160c085015262003d278285018762003a71565b925080851660e085015250509998505050505050505050565b600181815b8085111562003d9f57817fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0482111562003d835762003d8362003bb9565b8085161562003d9157918102915b93841c939080029062003d45565b509250929050565b60008262003db857506001620007a2565b8162003dc757506000620007a2565b816001811462003de0576002811462003deb5762003e0b565b6001915050620007a2565b60ff84111562003dff5762003dff62003bb9565b50506001821b620007a2565b5060208310610133831016604e8410600b841016171562003e30575081810a620007a2565b62003e3c838362003d40565b807fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0482111562003e715762003e7162003bb9565b029392505050565b60006200350f838362003da7565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052600160045260246000fd5b6000808585111562003ec757600080fd5b8386111562003ed557600080fd5b5050820193919092039150565b7fffffffff00000000000000000000000000000000000000000000000000000000813581811691600485101562003f235780818660040360031b1b83161692505b505092915050565b600080600080600080600060e0888a03121562003f4757600080fd5b873562003f5481620032b5565b9650602088013562003f6681620032b5565b955060408801359450606088013593506080880135620035938162003516565b600080600080600080600080610100898b03121562003fa457600080fd5b883562003fb181620032b5565b9750602089013562003fc381620032b5565b96506040890135955060608901359450608089013562003fe38162003317565b935060a089013562003ff58162003516565b979a969950949793969295929450505060c08201359160e0013590565b6000602082840312156200402557600080fd5b81516200350f8162003516565b6000602082840312156200404557600080fd5b81516200350f8162003317565b6000602082840312156200406557600080fd5b815167ffffffffffffffff8111156200407d57600080fd5b8201601f810184136200408f57600080fd5b8051620040a0620039c28262003956565b818152856020838501011115620040b657600080fd5b620040c9826020830160208601620038c0565b95945050505050565b6020815260006200350f602083018462003a7156fe6101006040523480156200001257600080fd5b5060405162001b6638038062001b6683398101604081905262000035916200028d565b82826003620000458382620003a1565b506004620000548282620003a1565b50503360c0525060ff811660e052466080819052620000739062000080565b60a052506200046d915050565b60007f8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f620000ad6200012e565b805160209182012060408051808201825260018152603160f81b90840152805192830193909352918101919091527fc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc66060820152608081018390523060a082015260c001604051602081830303815290604052805190602001209050919050565b6060600380546200013f9062000312565b80601f01602080910402602001604051908101604052809291908181526020018280546200016d9062000312565b8015620001be5780601f106200019257610100808354040283529160200191620001be565b820191906000526020600020905b815481529060010190602001808311620001a057829003601f168201915b5050505050905090565b634e487b7160e01b600052604160045260246000fd5b600082601f830112620001f057600080fd5b81516001600160401b03808211156200020d576200020d620001c8565b604051601f8301601f19908116603f01168101908282118183101715620002385762000238620001c8565b816040528381526020925086838588010111156200025557600080fd5b600091505b838210156200027957858201830151818301840152908201906200025a565b600093810190920192909252949350505050565b600080600060608486031215620002a357600080fd5b83516001600160401b0380821115620002bb57600080fd5b620002c987838801620001de565b94506020860151915080821115620002e057600080fd5b50620002ef86828701620001de565b925050604084015160ff811681146200030757600080fd5b809150509250925092565b600181811c908216806200032757607f821691505b6020821081036200034857634e487b7160e01b600052602260045260246000fd5b50919050565b601f8211156200039c57600081815260208120601f850160051c81016020861015620003775750805b601f850160051c820191505b81811015620003985782815560010162000383565b5050505b505050565b81516001600160401b03811115620003bd57620003bd620001c8565b620003d581620003ce845462000312565b846200034e565b602080601f8311600181146200040d5760008415620003f45750858301515b600019600386901b1c1916600185901b17855562000398565b600085815260208120601f198616915b828110156200043e578886015182559484019460019091019084016200041d565b50858210156200045d5787850151600019600388901b60f8161c191681555b5050505050600190811b01905550565b60805160a05160c05160e0516116aa620004bc6000396000610237015260008181610307015281816105c001526106a70152600061053a015260008181610379015261050401526116aa6000f3fe608060405234801561001057600080fd5b50600436106101775760003560e01c806370a08231116100d8578063a457c2d71161008c578063d505accf11610066578063d505accf1461039b578063dd62ed3e146103ae578063ffa1ad74146103f457600080fd5b8063a457c2d71461034e578063a9059cbb14610361578063cd0d00961461037457600080fd5b806395d89b41116100bd57806395d89b41146102e75780639dc29fac146102ef578063a3c573eb1461030257600080fd5b806370a08231146102915780637ecebe00146102c757600080fd5b806330adf81f1161012f5780633644e515116101145780633644e51514610261578063395093511461026957806340c10f191461027c57600080fd5b806330adf81f14610209578063313ce5671461023057600080fd5b806318160ddd1161016057806318160ddd146101bd57806320606b70146101cf57806323b872dd146101f657600080fd5b806306fdde031461017c578063095ea7b31461019a575b600080fd5b610184610430565b60405161019191906113e4565b60405180910390f35b6101ad6101a8366004611479565b6104c2565b6040519015158152602001610191565b6002545b604051908152602001610191565b6101c17f8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f81565b6101ad6102043660046114a3565b6104dc565b6101c17f6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c981565b60405160ff7f0000000000000000000000000000000000000000000000000000000000000000168152602001610191565b6101c1610500565b6101ad610277366004611479565b61055c565b61028f61028a366004611479565b6105a8565b005b6101c161029f3660046114df565b73ffffffffffffffffffffffffffffffffffffffff1660009081526020819052604090205490565b6101c16102d53660046114df565b60056020526000908152604090205481565b610184610680565b61028f6102fd366004611479565b61068f565b6103297f000000000000000000000000000000000000000000000000000000000000000081565b60405173ffffffffffffffffffffffffffffffffffffffff9091168152602001610191565b6101ad61035c366004611479565b61075e565b6101ad61036f366004611479565b61082f565b6101c17f000000000000000000000000000000000000000000000000000000000000000081565b61028f6103a9366004611501565b61083d565b6101c16103bc366004611574565b73ffffffffffffffffffffffffffffffffffffffff918216600090815260016020908152604080832093909416825291909152205490565b6101846040518060400160405280600181526020017f310000000000000000000000000000000000000000000000000000000000000081525081565b60606003805461043f906115a7565b80601f016020809104026020016040519081016040528092919081815260200182805461046b906115a7565b80156104b85780601f1061048d576101008083540402835291602001916104b8565b820191906000526020600020905b81548152906001019060200180831161049b57829003601f168201915b5050505050905090565b6000336104d0818585610b73565b60019150505b92915050565b6000336104ea858285610d27565b6104f5858585610dfe565b506001949350505050565b60007f00000000000000000000000000000000000000000000000000000000000000004614610537576105324661106d565b905090565b507f000000000000000000000000000000000000000000000000000000000000000090565b33600081815260016020908152604080832073ffffffffffffffffffffffffffffffffffffffff871684529091528120549091906104d090829086906105a3908790611629565b610b73565b3373ffffffffffffffffffffffffffffffffffffffff7f00000000000000000000000000000000000000000000000000000000000000001614610672576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152603060248201527f546f6b656e577261707065643a3a6f6e6c794272696467653a204e6f7420506f60448201527f6c79676f6e5a6b45564d4272696467650000000000000000000000000000000060648201526084015b60405180910390fd5b61067c8282611135565b5050565b60606004805461043f906115a7565b3373ffffffffffffffffffffffffffffffffffffffff7f00000000000000000000000000000000000000000000000000000000000000001614610754576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152603060248201527f546f6b656e577261707065643a3a6f6e6c794272696467653a204e6f7420506f60448201527f6c79676f6e5a6b45564d427269646765000000000000000000000000000000006064820152608401610669565b61067c8282611228565b33600081815260016020908152604080832073ffffffffffffffffffffffffffffffffffffffff8716845290915281205490919083811015610822576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602560248201527f45524332303a2064656372656173656420616c6c6f77616e63652062656c6f7760448201527f207a65726f0000000000000000000000000000000000000000000000000000006064820152608401610669565b6104f58286868403610b73565b6000336104d0818585610dfe565b834211156108cc576040517f08c379a0000000000000000000000000000000000000000000000000000000008152602060048201526024808201527f546f6b656e577261707065643a3a7065726d69743a204578706972656420706560448201527f726d6974000000000000000000000000000000000000000000000000000000006064820152608401610669565b73ffffffffffffffffffffffffffffffffffffffff8716600090815260056020526040812080547f6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9918a918a918a9190866109268361163c565b9091555060408051602081019690965273ffffffffffffffffffffffffffffffffffffffff94851690860152929091166060840152608083015260a082015260c0810186905260e0016040516020818303038152906040528051906020012090506000610991610500565b6040517f19010000000000000000000000000000000000000000000000000000000000006020820152602281019190915260428101839052606201604080517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe08184030181528282528051602091820120600080855291840180845281905260ff89169284019290925260608301879052608083018690529092509060019060a0016020604051602081039080840390855afa158015610a55573d6000803e3d6000fd5b50506040517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0015191505073ffffffffffffffffffffffffffffffffffffffff811615801590610ad057508973ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff16145b610b5c576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602760248201527f546f6b656e577261707065643a3a7065726d69743a20496e76616c696420736960448201527f676e6174757265000000000000000000000000000000000000000000000000006064820152608401610669565b610b678a8a8a610b73565b50505050505050505050565b73ffffffffffffffffffffffffffffffffffffffff8316610c15576040517f08c379a0000000000000000000000000000000000000000000000000000000008152602060048201526024808201527f45524332303a20617070726f76652066726f6d20746865207a65726f2061646460448201527f72657373000000000000000000000000000000000000000000000000000000006064820152608401610669565b73ffffffffffffffffffffffffffffffffffffffff8216610cb8576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602260248201527f45524332303a20617070726f766520746f20746865207a65726f20616464726560448201527f73730000000000000000000000000000000000000000000000000000000000006064820152608401610669565b73ffffffffffffffffffffffffffffffffffffffff83811660008181526001602090815260408083209487168084529482529182902085905590518481527f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92591015b60405180910390a3505050565b73ffffffffffffffffffffffffffffffffffffffff8381166000908152600160209081526040808320938616835292905220547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8114610df85781811015610deb576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601d60248201527f45524332303a20696e73756666696369656e7420616c6c6f77616e63650000006044820152606401610669565b610df88484848403610b73565b50505050565b73ffffffffffffffffffffffffffffffffffffffff8316610ea1576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602560248201527f45524332303a207472616e736665722066726f6d20746865207a65726f20616460448201527f64726573730000000000000000000000000000000000000000000000000000006064820152608401610669565b73ffffffffffffffffffffffffffffffffffffffff8216610f44576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602360248201527f45524332303a207472616e7366657220746f20746865207a65726f206164647260448201527f65737300000000000000000000000000000000000000000000000000000000006064820152608401610669565b73ffffffffffffffffffffffffffffffffffffffff831660009081526020819052604090205481811015610ffa576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602660248201527f45524332303a207472616e7366657220616d6f756e742065786365656473206260448201527f616c616e636500000000000000000000000000000000000000000000000000006064820152608401610669565b73ffffffffffffffffffffffffffffffffffffffff848116600081815260208181526040808320878703905593871680835291849020805487019055925185815290927fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef910160405180910390a3610df8565b60007f8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f611098610430565b8051602091820120604080518082018252600181527f310000000000000000000000000000000000000000000000000000000000000090840152805192830193909352918101919091527fc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc66060820152608081018390523060a082015260c001604051602081830303815290604052805190602001209050919050565b73ffffffffffffffffffffffffffffffffffffffff82166111b2576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601f60248201527f45524332303a206d696e7420746f20746865207a65726f2061646472657373006044820152606401610669565b80600260008282546111c49190611629565b909155505073ffffffffffffffffffffffffffffffffffffffff8216600081815260208181526040808320805486019055518481527fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef910160405180910390a35050565b73ffffffffffffffffffffffffffffffffffffffff82166112cb576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602160248201527f45524332303a206275726e2066726f6d20746865207a65726f2061646472657360448201527f73000000000000000000000000000000000000000000000000000000000000006064820152608401610669565b73ffffffffffffffffffffffffffffffffffffffff821660009081526020819052604090205481811015611381576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602260248201527f45524332303a206275726e20616d6f756e7420657863656564732062616c616e60448201527f63650000000000000000000000000000000000000000000000000000000000006064820152608401610669565b73ffffffffffffffffffffffffffffffffffffffff83166000818152602081815260408083208686039055600280548790039055518581529192917fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef9101610d1a565b600060208083528351808285015260005b81811015611411578581018301518582016040015282016113f5565b5060006040828601015260407fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0601f8301168501019250505092915050565b803573ffffffffffffffffffffffffffffffffffffffff8116811461147457600080fd5b919050565b6000806040838503121561148c57600080fd5b61149583611450565b946020939093013593505050565b6000806000606084860312156114b857600080fd5b6114c184611450565b92506114cf60208501611450565b9150604084013590509250925092565b6000602082840312156114f157600080fd5b6114fa82611450565b9392505050565b600080600080600080600060e0888a03121561151c57600080fd5b61152588611450565b965061153360208901611450565b95506040880135945060608801359350608088013560ff8116811461155757600080fd5b9699959850939692959460a0840135945060c09093013592915050565b6000806040838503121561158757600080fd5b61159083611450565b915061159e60208401611450565b90509250929050565b600181811c908216806115bb57607f821691505b6020821081036115f4577f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b50919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b808201808211156104d6576104d66115fa565b60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff820361166d5761166d6115fa565b506001019056fea26469706673582212208d88fee561cff7120d381c345cfc534cef8229a272dc5809d4bbb685ad67141164736f6c63430008110033a2646970667358221220d9b3ca7b13ec80ac58634ddf0ecebe71e209a71f532614949b9e720413f50c8364736f6c63430008110033", +} + +// OldpolygonzkevmbridgeABI is the input ABI used to generate the binding from. +// Deprecated: Use OldpolygonzkevmbridgeMetaData.ABI instead. +var OldpolygonzkevmbridgeABI = OldpolygonzkevmbridgeMetaData.ABI + +// OldpolygonzkevmbridgeBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use OldpolygonzkevmbridgeMetaData.Bin instead. +var OldpolygonzkevmbridgeBin = OldpolygonzkevmbridgeMetaData.Bin + +// DeployOldpolygonzkevmbridge deploys a new Ethereum contract, binding an instance of Oldpolygonzkevmbridge to it. +func DeployOldpolygonzkevmbridge(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Oldpolygonzkevmbridge, error) { + parsed, err := OldpolygonzkevmbridgeMetaData.GetAbi() + if err != nil { + return common.Address{}, nil, nil, err + } + if parsed == nil { + return common.Address{}, nil, nil, errors.New("GetABI returned nil") + } + + address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex(OldpolygonzkevmbridgeBin), backend) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &Oldpolygonzkevmbridge{OldpolygonzkevmbridgeCaller: OldpolygonzkevmbridgeCaller{contract: contract}, OldpolygonzkevmbridgeTransactor: OldpolygonzkevmbridgeTransactor{contract: contract}, OldpolygonzkevmbridgeFilterer: OldpolygonzkevmbridgeFilterer{contract: contract}}, nil +} + +// Oldpolygonzkevmbridge is an auto generated Go binding around an Ethereum contract. +type Oldpolygonzkevmbridge struct { + OldpolygonzkevmbridgeCaller // Read-only binding to the contract + OldpolygonzkevmbridgeTransactor // Write-only binding to the contract + OldpolygonzkevmbridgeFilterer // Log filterer for contract events +} + +// OldpolygonzkevmbridgeCaller is an auto generated read-only Go binding around an Ethereum contract. +type OldpolygonzkevmbridgeCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// OldpolygonzkevmbridgeTransactor is an auto generated write-only Go binding around an Ethereum contract. +type OldpolygonzkevmbridgeTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// OldpolygonzkevmbridgeFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type OldpolygonzkevmbridgeFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// OldpolygonzkevmbridgeSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type OldpolygonzkevmbridgeSession struct { + Contract *Oldpolygonzkevmbridge // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// OldpolygonzkevmbridgeCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type OldpolygonzkevmbridgeCallerSession struct { + Contract *OldpolygonzkevmbridgeCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// OldpolygonzkevmbridgeTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type OldpolygonzkevmbridgeTransactorSession struct { + Contract *OldpolygonzkevmbridgeTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// OldpolygonzkevmbridgeRaw is an auto generated low-level Go binding around an Ethereum contract. +type OldpolygonzkevmbridgeRaw struct { + Contract *Oldpolygonzkevmbridge // Generic contract binding to access the raw methods on +} + +// OldpolygonzkevmbridgeCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type OldpolygonzkevmbridgeCallerRaw struct { + Contract *OldpolygonzkevmbridgeCaller // Generic read-only contract binding to access the raw methods on +} + +// OldpolygonzkevmbridgeTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type OldpolygonzkevmbridgeTransactorRaw struct { + Contract *OldpolygonzkevmbridgeTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewOldpolygonzkevmbridge creates a new instance of Oldpolygonzkevmbridge, bound to a specific deployed contract. +func NewOldpolygonzkevmbridge(address common.Address, backend bind.ContractBackend) (*Oldpolygonzkevmbridge, error) { + contract, err := bindOldpolygonzkevmbridge(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &Oldpolygonzkevmbridge{OldpolygonzkevmbridgeCaller: OldpolygonzkevmbridgeCaller{contract: contract}, OldpolygonzkevmbridgeTransactor: OldpolygonzkevmbridgeTransactor{contract: contract}, OldpolygonzkevmbridgeFilterer: OldpolygonzkevmbridgeFilterer{contract: contract}}, nil +} + +// NewOldpolygonzkevmbridgeCaller creates a new read-only instance of Oldpolygonzkevmbridge, bound to a specific deployed contract. +func NewOldpolygonzkevmbridgeCaller(address common.Address, caller bind.ContractCaller) (*OldpolygonzkevmbridgeCaller, error) { + contract, err := bindOldpolygonzkevmbridge(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &OldpolygonzkevmbridgeCaller{contract: contract}, nil +} + +// NewOldpolygonzkevmbridgeTransactor creates a new write-only instance of Oldpolygonzkevmbridge, bound to a specific deployed contract. +func NewOldpolygonzkevmbridgeTransactor(address common.Address, transactor bind.ContractTransactor) (*OldpolygonzkevmbridgeTransactor, error) { + contract, err := bindOldpolygonzkevmbridge(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &OldpolygonzkevmbridgeTransactor{contract: contract}, nil +} + +// NewOldpolygonzkevmbridgeFilterer creates a new log filterer instance of Oldpolygonzkevmbridge, bound to a specific deployed contract. +func NewOldpolygonzkevmbridgeFilterer(address common.Address, filterer bind.ContractFilterer) (*OldpolygonzkevmbridgeFilterer, error) { + contract, err := bindOldpolygonzkevmbridge(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &OldpolygonzkevmbridgeFilterer{contract: contract}, nil +} + +// bindOldpolygonzkevmbridge binds a generic wrapper to an already deployed contract. +func bindOldpolygonzkevmbridge(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := OldpolygonzkevmbridgeMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Oldpolygonzkevmbridge.Contract.OldpolygonzkevmbridgeCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Oldpolygonzkevmbridge.Contract.OldpolygonzkevmbridgeTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Oldpolygonzkevmbridge.Contract.OldpolygonzkevmbridgeTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Oldpolygonzkevmbridge.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Oldpolygonzkevmbridge.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Oldpolygonzkevmbridge.Contract.contract.Transact(opts, method, params...) +} + +// ClaimedBitMap is a free data retrieval call binding the contract method 0xee25560b. +// +// Solidity: function claimedBitMap(uint256 ) view returns(uint256) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeCaller) ClaimedBitMap(opts *bind.CallOpts, arg0 *big.Int) (*big.Int, error) { + var out []interface{} + err := _Oldpolygonzkevmbridge.contract.Call(opts, &out, "claimedBitMap", arg0) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// ClaimedBitMap is a free data retrieval call binding the contract method 0xee25560b. +// +// Solidity: function claimedBitMap(uint256 ) view returns(uint256) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeSession) ClaimedBitMap(arg0 *big.Int) (*big.Int, error) { + return _Oldpolygonzkevmbridge.Contract.ClaimedBitMap(&_Oldpolygonzkevmbridge.CallOpts, arg0) +} + +// ClaimedBitMap is a free data retrieval call binding the contract method 0xee25560b. +// +// Solidity: function claimedBitMap(uint256 ) view returns(uint256) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeCallerSession) ClaimedBitMap(arg0 *big.Int) (*big.Int, error) { + return _Oldpolygonzkevmbridge.Contract.ClaimedBitMap(&_Oldpolygonzkevmbridge.CallOpts, arg0) +} + +// DepositCount is a free data retrieval call binding the contract method 0x2dfdf0b5. +// +// Solidity: function depositCount() view returns(uint256) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeCaller) DepositCount(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _Oldpolygonzkevmbridge.contract.Call(opts, &out, "depositCount") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// DepositCount is a free data retrieval call binding the contract method 0x2dfdf0b5. +// +// Solidity: function depositCount() view returns(uint256) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeSession) DepositCount() (*big.Int, error) { + return _Oldpolygonzkevmbridge.Contract.DepositCount(&_Oldpolygonzkevmbridge.CallOpts) +} + +// DepositCount is a free data retrieval call binding the contract method 0x2dfdf0b5. +// +// Solidity: function depositCount() view returns(uint256) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeCallerSession) DepositCount() (*big.Int, error) { + return _Oldpolygonzkevmbridge.Contract.DepositCount(&_Oldpolygonzkevmbridge.CallOpts) +} + +// GetDepositRoot is a free data retrieval call binding the contract method 0x3ae05047. +// +// Solidity: function getDepositRoot() view returns(bytes32) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeCaller) GetDepositRoot(opts *bind.CallOpts) ([32]byte, error) { + var out []interface{} + err := _Oldpolygonzkevmbridge.contract.Call(opts, &out, "getDepositRoot") + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// GetDepositRoot is a free data retrieval call binding the contract method 0x3ae05047. +// +// Solidity: function getDepositRoot() view returns(bytes32) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeSession) GetDepositRoot() ([32]byte, error) { + return _Oldpolygonzkevmbridge.Contract.GetDepositRoot(&_Oldpolygonzkevmbridge.CallOpts) +} + +// GetDepositRoot is a free data retrieval call binding the contract method 0x3ae05047. +// +// Solidity: function getDepositRoot() view returns(bytes32) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeCallerSession) GetDepositRoot() ([32]byte, error) { + return _Oldpolygonzkevmbridge.Contract.GetDepositRoot(&_Oldpolygonzkevmbridge.CallOpts) +} + +// GetLeafValue is a free data retrieval call binding the contract method 0x3e197043. +// +// Solidity: function getLeafValue(uint8 leafType, uint32 originNetwork, address originAddress, uint32 destinationNetwork, address destinationAddress, uint256 amount, bytes32 metadataHash) pure returns(bytes32) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeCaller) GetLeafValue(opts *bind.CallOpts, leafType uint8, originNetwork uint32, originAddress common.Address, destinationNetwork uint32, destinationAddress common.Address, amount *big.Int, metadataHash [32]byte) ([32]byte, error) { + var out []interface{} + err := _Oldpolygonzkevmbridge.contract.Call(opts, &out, "getLeafValue", leafType, originNetwork, originAddress, destinationNetwork, destinationAddress, amount, metadataHash) + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// GetLeafValue is a free data retrieval call binding the contract method 0x3e197043. +// +// Solidity: function getLeafValue(uint8 leafType, uint32 originNetwork, address originAddress, uint32 destinationNetwork, address destinationAddress, uint256 amount, bytes32 metadataHash) pure returns(bytes32) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeSession) GetLeafValue(leafType uint8, originNetwork uint32, originAddress common.Address, destinationNetwork uint32, destinationAddress common.Address, amount *big.Int, metadataHash [32]byte) ([32]byte, error) { + return _Oldpolygonzkevmbridge.Contract.GetLeafValue(&_Oldpolygonzkevmbridge.CallOpts, leafType, originNetwork, originAddress, destinationNetwork, destinationAddress, amount, metadataHash) +} + +// GetLeafValue is a free data retrieval call binding the contract method 0x3e197043. +// +// Solidity: function getLeafValue(uint8 leafType, uint32 originNetwork, address originAddress, uint32 destinationNetwork, address destinationAddress, uint256 amount, bytes32 metadataHash) pure returns(bytes32) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeCallerSession) GetLeafValue(leafType uint8, originNetwork uint32, originAddress common.Address, destinationNetwork uint32, destinationAddress common.Address, amount *big.Int, metadataHash [32]byte) ([32]byte, error) { + return _Oldpolygonzkevmbridge.Contract.GetLeafValue(&_Oldpolygonzkevmbridge.CallOpts, leafType, originNetwork, originAddress, destinationNetwork, destinationAddress, amount, metadataHash) +} + +// GetTokenWrappedAddress is a free data retrieval call binding the contract method 0x22e95f2c. +// +// Solidity: function getTokenWrappedAddress(uint32 originNetwork, address originTokenAddress) view returns(address) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeCaller) GetTokenWrappedAddress(opts *bind.CallOpts, originNetwork uint32, originTokenAddress common.Address) (common.Address, error) { + var out []interface{} + err := _Oldpolygonzkevmbridge.contract.Call(opts, &out, "getTokenWrappedAddress", originNetwork, originTokenAddress) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// GetTokenWrappedAddress is a free data retrieval call binding the contract method 0x22e95f2c. +// +// Solidity: function getTokenWrappedAddress(uint32 originNetwork, address originTokenAddress) view returns(address) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeSession) GetTokenWrappedAddress(originNetwork uint32, originTokenAddress common.Address) (common.Address, error) { + return _Oldpolygonzkevmbridge.Contract.GetTokenWrappedAddress(&_Oldpolygonzkevmbridge.CallOpts, originNetwork, originTokenAddress) +} + +// GetTokenWrappedAddress is a free data retrieval call binding the contract method 0x22e95f2c. +// +// Solidity: function getTokenWrappedAddress(uint32 originNetwork, address originTokenAddress) view returns(address) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeCallerSession) GetTokenWrappedAddress(originNetwork uint32, originTokenAddress common.Address) (common.Address, error) { + return _Oldpolygonzkevmbridge.Contract.GetTokenWrappedAddress(&_Oldpolygonzkevmbridge.CallOpts, originNetwork, originTokenAddress) +} + +// GlobalExitRootManager is a free data retrieval call binding the contract method 0xd02103ca. +// +// Solidity: function globalExitRootManager() view returns(address) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeCaller) GlobalExitRootManager(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Oldpolygonzkevmbridge.contract.Call(opts, &out, "globalExitRootManager") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// GlobalExitRootManager is a free data retrieval call binding the contract method 0xd02103ca. +// +// Solidity: function globalExitRootManager() view returns(address) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeSession) GlobalExitRootManager() (common.Address, error) { + return _Oldpolygonzkevmbridge.Contract.GlobalExitRootManager(&_Oldpolygonzkevmbridge.CallOpts) +} + +// GlobalExitRootManager is a free data retrieval call binding the contract method 0xd02103ca. +// +// Solidity: function globalExitRootManager() view returns(address) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeCallerSession) GlobalExitRootManager() (common.Address, error) { + return _Oldpolygonzkevmbridge.Contract.GlobalExitRootManager(&_Oldpolygonzkevmbridge.CallOpts) +} + +// IsClaimed is a free data retrieval call binding the contract method 0x9e34070f. +// +// Solidity: function isClaimed(uint256 index) view returns(bool) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeCaller) IsClaimed(opts *bind.CallOpts, index *big.Int) (bool, error) { + var out []interface{} + err := _Oldpolygonzkevmbridge.contract.Call(opts, &out, "isClaimed", index) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// IsClaimed is a free data retrieval call binding the contract method 0x9e34070f. +// +// Solidity: function isClaimed(uint256 index) view returns(bool) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeSession) IsClaimed(index *big.Int) (bool, error) { + return _Oldpolygonzkevmbridge.Contract.IsClaimed(&_Oldpolygonzkevmbridge.CallOpts, index) +} + +// IsClaimed is a free data retrieval call binding the contract method 0x9e34070f. +// +// Solidity: function isClaimed(uint256 index) view returns(bool) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeCallerSession) IsClaimed(index *big.Int) (bool, error) { + return _Oldpolygonzkevmbridge.Contract.IsClaimed(&_Oldpolygonzkevmbridge.CallOpts, index) +} + +// IsEmergencyState is a free data retrieval call binding the contract method 0x15064c96. +// +// Solidity: function isEmergencyState() view returns(bool) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeCaller) IsEmergencyState(opts *bind.CallOpts) (bool, error) { + var out []interface{} + err := _Oldpolygonzkevmbridge.contract.Call(opts, &out, "isEmergencyState") + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// IsEmergencyState is a free data retrieval call binding the contract method 0x15064c96. +// +// Solidity: function isEmergencyState() view returns(bool) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeSession) IsEmergencyState() (bool, error) { + return _Oldpolygonzkevmbridge.Contract.IsEmergencyState(&_Oldpolygonzkevmbridge.CallOpts) +} + +// IsEmergencyState is a free data retrieval call binding the contract method 0x15064c96. +// +// Solidity: function isEmergencyState() view returns(bool) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeCallerSession) IsEmergencyState() (bool, error) { + return _Oldpolygonzkevmbridge.Contract.IsEmergencyState(&_Oldpolygonzkevmbridge.CallOpts) +} + +// LastUpdatedDepositCount is a free data retrieval call binding the contract method 0xbe5831c7. +// +// Solidity: function lastUpdatedDepositCount() view returns(uint32) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeCaller) LastUpdatedDepositCount(opts *bind.CallOpts) (uint32, error) { + var out []interface{} + err := _Oldpolygonzkevmbridge.contract.Call(opts, &out, "lastUpdatedDepositCount") + + if err != nil { + return *new(uint32), err + } + + out0 := *abi.ConvertType(out[0], new(uint32)).(*uint32) + + return out0, err + +} + +// LastUpdatedDepositCount is a free data retrieval call binding the contract method 0xbe5831c7. +// +// Solidity: function lastUpdatedDepositCount() view returns(uint32) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeSession) LastUpdatedDepositCount() (uint32, error) { + return _Oldpolygonzkevmbridge.Contract.LastUpdatedDepositCount(&_Oldpolygonzkevmbridge.CallOpts) +} + +// LastUpdatedDepositCount is a free data retrieval call binding the contract method 0xbe5831c7. +// +// Solidity: function lastUpdatedDepositCount() view returns(uint32) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeCallerSession) LastUpdatedDepositCount() (uint32, error) { + return _Oldpolygonzkevmbridge.Contract.LastUpdatedDepositCount(&_Oldpolygonzkevmbridge.CallOpts) +} + +// NetworkID is a free data retrieval call binding the contract method 0xbab161bf. +// +// Solidity: function networkID() view returns(uint32) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeCaller) NetworkID(opts *bind.CallOpts) (uint32, error) { + var out []interface{} + err := _Oldpolygonzkevmbridge.contract.Call(opts, &out, "networkID") + + if err != nil { + return *new(uint32), err + } + + out0 := *abi.ConvertType(out[0], new(uint32)).(*uint32) + + return out0, err + +} + +// NetworkID is a free data retrieval call binding the contract method 0xbab161bf. +// +// Solidity: function networkID() view returns(uint32) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeSession) NetworkID() (uint32, error) { + return _Oldpolygonzkevmbridge.Contract.NetworkID(&_Oldpolygonzkevmbridge.CallOpts) +} + +// NetworkID is a free data retrieval call binding the contract method 0xbab161bf. +// +// Solidity: function networkID() view returns(uint32) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeCallerSession) NetworkID() (uint32, error) { + return _Oldpolygonzkevmbridge.Contract.NetworkID(&_Oldpolygonzkevmbridge.CallOpts) +} + +// PolygonZkEVMaddress is a free data retrieval call binding the contract method 0x34ac9cf2. +// +// Solidity: function polygonZkEVMaddress() view returns(address) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeCaller) PolygonZkEVMaddress(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Oldpolygonzkevmbridge.contract.Call(opts, &out, "polygonZkEVMaddress") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// PolygonZkEVMaddress is a free data retrieval call binding the contract method 0x34ac9cf2. +// +// Solidity: function polygonZkEVMaddress() view returns(address) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeSession) PolygonZkEVMaddress() (common.Address, error) { + return _Oldpolygonzkevmbridge.Contract.PolygonZkEVMaddress(&_Oldpolygonzkevmbridge.CallOpts) +} + +// PolygonZkEVMaddress is a free data retrieval call binding the contract method 0x34ac9cf2. +// +// Solidity: function polygonZkEVMaddress() view returns(address) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeCallerSession) PolygonZkEVMaddress() (common.Address, error) { + return _Oldpolygonzkevmbridge.Contract.PolygonZkEVMaddress(&_Oldpolygonzkevmbridge.CallOpts) +} + +// PrecalculatedWrapperAddress is a free data retrieval call binding the contract method 0xaaa13cc2. +// +// Solidity: function precalculatedWrapperAddress(uint32 originNetwork, address originTokenAddress, string name, string symbol, uint8 decimals) view returns(address) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeCaller) PrecalculatedWrapperAddress(opts *bind.CallOpts, originNetwork uint32, originTokenAddress common.Address, name string, symbol string, decimals uint8) (common.Address, error) { + var out []interface{} + err := _Oldpolygonzkevmbridge.contract.Call(opts, &out, "precalculatedWrapperAddress", originNetwork, originTokenAddress, name, symbol, decimals) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// PrecalculatedWrapperAddress is a free data retrieval call binding the contract method 0xaaa13cc2. +// +// Solidity: function precalculatedWrapperAddress(uint32 originNetwork, address originTokenAddress, string name, string symbol, uint8 decimals) view returns(address) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeSession) PrecalculatedWrapperAddress(originNetwork uint32, originTokenAddress common.Address, name string, symbol string, decimals uint8) (common.Address, error) { + return _Oldpolygonzkevmbridge.Contract.PrecalculatedWrapperAddress(&_Oldpolygonzkevmbridge.CallOpts, originNetwork, originTokenAddress, name, symbol, decimals) +} + +// PrecalculatedWrapperAddress is a free data retrieval call binding the contract method 0xaaa13cc2. +// +// Solidity: function precalculatedWrapperAddress(uint32 originNetwork, address originTokenAddress, string name, string symbol, uint8 decimals) view returns(address) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeCallerSession) PrecalculatedWrapperAddress(originNetwork uint32, originTokenAddress common.Address, name string, symbol string, decimals uint8) (common.Address, error) { + return _Oldpolygonzkevmbridge.Contract.PrecalculatedWrapperAddress(&_Oldpolygonzkevmbridge.CallOpts, originNetwork, originTokenAddress, name, symbol, decimals) +} + +// TokenInfoToWrappedToken is a free data retrieval call binding the contract method 0x81b1c174. +// +// Solidity: function tokenInfoToWrappedToken(bytes32 ) view returns(address) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeCaller) TokenInfoToWrappedToken(opts *bind.CallOpts, arg0 [32]byte) (common.Address, error) { + var out []interface{} + err := _Oldpolygonzkevmbridge.contract.Call(opts, &out, "tokenInfoToWrappedToken", arg0) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// TokenInfoToWrappedToken is a free data retrieval call binding the contract method 0x81b1c174. +// +// Solidity: function tokenInfoToWrappedToken(bytes32 ) view returns(address) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeSession) TokenInfoToWrappedToken(arg0 [32]byte) (common.Address, error) { + return _Oldpolygonzkevmbridge.Contract.TokenInfoToWrappedToken(&_Oldpolygonzkevmbridge.CallOpts, arg0) +} + +// TokenInfoToWrappedToken is a free data retrieval call binding the contract method 0x81b1c174. +// +// Solidity: function tokenInfoToWrappedToken(bytes32 ) view returns(address) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeCallerSession) TokenInfoToWrappedToken(arg0 [32]byte) (common.Address, error) { + return _Oldpolygonzkevmbridge.Contract.TokenInfoToWrappedToken(&_Oldpolygonzkevmbridge.CallOpts, arg0) +} + +// VerifyMerkleProof is a free data retrieval call binding the contract method 0xfb570834. +// +// Solidity: function verifyMerkleProof(bytes32 leafHash, bytes32[32] smtProof, uint32 index, bytes32 root) pure returns(bool) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeCaller) VerifyMerkleProof(opts *bind.CallOpts, leafHash [32]byte, smtProof [32][32]byte, index uint32, root [32]byte) (bool, error) { + var out []interface{} + err := _Oldpolygonzkevmbridge.contract.Call(opts, &out, "verifyMerkleProof", leafHash, smtProof, index, root) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// VerifyMerkleProof is a free data retrieval call binding the contract method 0xfb570834. +// +// Solidity: function verifyMerkleProof(bytes32 leafHash, bytes32[32] smtProof, uint32 index, bytes32 root) pure returns(bool) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeSession) VerifyMerkleProof(leafHash [32]byte, smtProof [32][32]byte, index uint32, root [32]byte) (bool, error) { + return _Oldpolygonzkevmbridge.Contract.VerifyMerkleProof(&_Oldpolygonzkevmbridge.CallOpts, leafHash, smtProof, index, root) +} + +// VerifyMerkleProof is a free data retrieval call binding the contract method 0xfb570834. +// +// Solidity: function verifyMerkleProof(bytes32 leafHash, bytes32[32] smtProof, uint32 index, bytes32 root) pure returns(bool) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeCallerSession) VerifyMerkleProof(leafHash [32]byte, smtProof [32][32]byte, index uint32, root [32]byte) (bool, error) { + return _Oldpolygonzkevmbridge.Contract.VerifyMerkleProof(&_Oldpolygonzkevmbridge.CallOpts, leafHash, smtProof, index, root) +} + +// WrappedTokenToTokenInfo is a free data retrieval call binding the contract method 0x318aee3d. +// +// Solidity: function wrappedTokenToTokenInfo(address ) view returns(uint32 originNetwork, address originTokenAddress) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeCaller) WrappedTokenToTokenInfo(opts *bind.CallOpts, arg0 common.Address) (struct { + OriginNetwork uint32 + OriginTokenAddress common.Address +}, error) { + var out []interface{} + err := _Oldpolygonzkevmbridge.contract.Call(opts, &out, "wrappedTokenToTokenInfo", arg0) + + outstruct := new(struct { + OriginNetwork uint32 + OriginTokenAddress common.Address + }) + if err != nil { + return *outstruct, err + } + + outstruct.OriginNetwork = *abi.ConvertType(out[0], new(uint32)).(*uint32) + outstruct.OriginTokenAddress = *abi.ConvertType(out[1], new(common.Address)).(*common.Address) + + return *outstruct, err + +} + +// WrappedTokenToTokenInfo is a free data retrieval call binding the contract method 0x318aee3d. +// +// Solidity: function wrappedTokenToTokenInfo(address ) view returns(uint32 originNetwork, address originTokenAddress) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeSession) WrappedTokenToTokenInfo(arg0 common.Address) (struct { + OriginNetwork uint32 + OriginTokenAddress common.Address +}, error) { + return _Oldpolygonzkevmbridge.Contract.WrappedTokenToTokenInfo(&_Oldpolygonzkevmbridge.CallOpts, arg0) +} + +// WrappedTokenToTokenInfo is a free data retrieval call binding the contract method 0x318aee3d. +// +// Solidity: function wrappedTokenToTokenInfo(address ) view returns(uint32 originNetwork, address originTokenAddress) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeCallerSession) WrappedTokenToTokenInfo(arg0 common.Address) (struct { + OriginNetwork uint32 + OriginTokenAddress common.Address +}, error) { + return _Oldpolygonzkevmbridge.Contract.WrappedTokenToTokenInfo(&_Oldpolygonzkevmbridge.CallOpts, arg0) +} + +// ActivateEmergencyState is a paid mutator transaction binding the contract method 0x2072f6c5. +// +// Solidity: function activateEmergencyState() returns() +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeTransactor) ActivateEmergencyState(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Oldpolygonzkevmbridge.contract.Transact(opts, "activateEmergencyState") +} + +// ActivateEmergencyState is a paid mutator transaction binding the contract method 0x2072f6c5. +// +// Solidity: function activateEmergencyState() returns() +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeSession) ActivateEmergencyState() (*types.Transaction, error) { + return _Oldpolygonzkevmbridge.Contract.ActivateEmergencyState(&_Oldpolygonzkevmbridge.TransactOpts) +} + +// ActivateEmergencyState is a paid mutator transaction binding the contract method 0x2072f6c5. +// +// Solidity: function activateEmergencyState() returns() +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeTransactorSession) ActivateEmergencyState() (*types.Transaction, error) { + return _Oldpolygonzkevmbridge.Contract.ActivateEmergencyState(&_Oldpolygonzkevmbridge.TransactOpts) +} + +// BridgeAsset is a paid mutator transaction binding the contract method 0xcd586579. +// +// Solidity: function bridgeAsset(uint32 destinationNetwork, address destinationAddress, uint256 amount, address token, bool forceUpdateGlobalExitRoot, bytes permitData) payable returns() +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeTransactor) BridgeAsset(opts *bind.TransactOpts, destinationNetwork uint32, destinationAddress common.Address, amount *big.Int, token common.Address, forceUpdateGlobalExitRoot bool, permitData []byte) (*types.Transaction, error) { + return _Oldpolygonzkevmbridge.contract.Transact(opts, "bridgeAsset", destinationNetwork, destinationAddress, amount, token, forceUpdateGlobalExitRoot, permitData) +} + +// BridgeAsset is a paid mutator transaction binding the contract method 0xcd586579. +// +// Solidity: function bridgeAsset(uint32 destinationNetwork, address destinationAddress, uint256 amount, address token, bool forceUpdateGlobalExitRoot, bytes permitData) payable returns() +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeSession) BridgeAsset(destinationNetwork uint32, destinationAddress common.Address, amount *big.Int, token common.Address, forceUpdateGlobalExitRoot bool, permitData []byte) (*types.Transaction, error) { + return _Oldpolygonzkevmbridge.Contract.BridgeAsset(&_Oldpolygonzkevmbridge.TransactOpts, destinationNetwork, destinationAddress, amount, token, forceUpdateGlobalExitRoot, permitData) +} + +// BridgeAsset is a paid mutator transaction binding the contract method 0xcd586579. +// +// Solidity: function bridgeAsset(uint32 destinationNetwork, address destinationAddress, uint256 amount, address token, bool forceUpdateGlobalExitRoot, bytes permitData) payable returns() +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeTransactorSession) BridgeAsset(destinationNetwork uint32, destinationAddress common.Address, amount *big.Int, token common.Address, forceUpdateGlobalExitRoot bool, permitData []byte) (*types.Transaction, error) { + return _Oldpolygonzkevmbridge.Contract.BridgeAsset(&_Oldpolygonzkevmbridge.TransactOpts, destinationNetwork, destinationAddress, amount, token, forceUpdateGlobalExitRoot, permitData) +} + +// BridgeMessage is a paid mutator transaction binding the contract method 0x240ff378. +// +// Solidity: function bridgeMessage(uint32 destinationNetwork, address destinationAddress, bool forceUpdateGlobalExitRoot, bytes metadata) payable returns() +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeTransactor) BridgeMessage(opts *bind.TransactOpts, destinationNetwork uint32, destinationAddress common.Address, forceUpdateGlobalExitRoot bool, metadata []byte) (*types.Transaction, error) { + return _Oldpolygonzkevmbridge.contract.Transact(opts, "bridgeMessage", destinationNetwork, destinationAddress, forceUpdateGlobalExitRoot, metadata) +} + +// BridgeMessage is a paid mutator transaction binding the contract method 0x240ff378. +// +// Solidity: function bridgeMessage(uint32 destinationNetwork, address destinationAddress, bool forceUpdateGlobalExitRoot, bytes metadata) payable returns() +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeSession) BridgeMessage(destinationNetwork uint32, destinationAddress common.Address, forceUpdateGlobalExitRoot bool, metadata []byte) (*types.Transaction, error) { + return _Oldpolygonzkevmbridge.Contract.BridgeMessage(&_Oldpolygonzkevmbridge.TransactOpts, destinationNetwork, destinationAddress, forceUpdateGlobalExitRoot, metadata) +} + +// BridgeMessage is a paid mutator transaction binding the contract method 0x240ff378. +// +// Solidity: function bridgeMessage(uint32 destinationNetwork, address destinationAddress, bool forceUpdateGlobalExitRoot, bytes metadata) payable returns() +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeTransactorSession) BridgeMessage(destinationNetwork uint32, destinationAddress common.Address, forceUpdateGlobalExitRoot bool, metadata []byte) (*types.Transaction, error) { + return _Oldpolygonzkevmbridge.Contract.BridgeMessage(&_Oldpolygonzkevmbridge.TransactOpts, destinationNetwork, destinationAddress, forceUpdateGlobalExitRoot, metadata) +} + +// ClaimAsset is a paid mutator transaction binding the contract method 0x2cffd02e. +// +// Solidity: function claimAsset(bytes32[32] smtProof, uint32 index, bytes32 mainnetExitRoot, bytes32 rollupExitRoot, uint32 originNetwork, address originTokenAddress, uint32 destinationNetwork, address destinationAddress, uint256 amount, bytes metadata) returns() +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeTransactor) ClaimAsset(opts *bind.TransactOpts, smtProof [32][32]byte, index uint32, mainnetExitRoot [32]byte, rollupExitRoot [32]byte, originNetwork uint32, originTokenAddress common.Address, destinationNetwork uint32, destinationAddress common.Address, amount *big.Int, metadata []byte) (*types.Transaction, error) { + return _Oldpolygonzkevmbridge.contract.Transact(opts, "claimAsset", smtProof, index, mainnetExitRoot, rollupExitRoot, originNetwork, originTokenAddress, destinationNetwork, destinationAddress, amount, metadata) +} + +// ClaimAsset is a paid mutator transaction binding the contract method 0x2cffd02e. +// +// Solidity: function claimAsset(bytes32[32] smtProof, uint32 index, bytes32 mainnetExitRoot, bytes32 rollupExitRoot, uint32 originNetwork, address originTokenAddress, uint32 destinationNetwork, address destinationAddress, uint256 amount, bytes metadata) returns() +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeSession) ClaimAsset(smtProof [32][32]byte, index uint32, mainnetExitRoot [32]byte, rollupExitRoot [32]byte, originNetwork uint32, originTokenAddress common.Address, destinationNetwork uint32, destinationAddress common.Address, amount *big.Int, metadata []byte) (*types.Transaction, error) { + return _Oldpolygonzkevmbridge.Contract.ClaimAsset(&_Oldpolygonzkevmbridge.TransactOpts, smtProof, index, mainnetExitRoot, rollupExitRoot, originNetwork, originTokenAddress, destinationNetwork, destinationAddress, amount, metadata) +} + +// ClaimAsset is a paid mutator transaction binding the contract method 0x2cffd02e. +// +// Solidity: function claimAsset(bytes32[32] smtProof, uint32 index, bytes32 mainnetExitRoot, bytes32 rollupExitRoot, uint32 originNetwork, address originTokenAddress, uint32 destinationNetwork, address destinationAddress, uint256 amount, bytes metadata) returns() +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeTransactorSession) ClaimAsset(smtProof [32][32]byte, index uint32, mainnetExitRoot [32]byte, rollupExitRoot [32]byte, originNetwork uint32, originTokenAddress common.Address, destinationNetwork uint32, destinationAddress common.Address, amount *big.Int, metadata []byte) (*types.Transaction, error) { + return _Oldpolygonzkevmbridge.Contract.ClaimAsset(&_Oldpolygonzkevmbridge.TransactOpts, smtProof, index, mainnetExitRoot, rollupExitRoot, originNetwork, originTokenAddress, destinationNetwork, destinationAddress, amount, metadata) +} + +// ClaimMessage is a paid mutator transaction binding the contract method 0x2d2c9d94. +// +// Solidity: function claimMessage(bytes32[32] smtProof, uint32 index, bytes32 mainnetExitRoot, bytes32 rollupExitRoot, uint32 originNetwork, address originAddress, uint32 destinationNetwork, address destinationAddress, uint256 amount, bytes metadata) returns() +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeTransactor) ClaimMessage(opts *bind.TransactOpts, smtProof [32][32]byte, index uint32, mainnetExitRoot [32]byte, rollupExitRoot [32]byte, originNetwork uint32, originAddress common.Address, destinationNetwork uint32, destinationAddress common.Address, amount *big.Int, metadata []byte) (*types.Transaction, error) { + return _Oldpolygonzkevmbridge.contract.Transact(opts, "claimMessage", smtProof, index, mainnetExitRoot, rollupExitRoot, originNetwork, originAddress, destinationNetwork, destinationAddress, amount, metadata) +} + +// ClaimMessage is a paid mutator transaction binding the contract method 0x2d2c9d94. +// +// Solidity: function claimMessage(bytes32[32] smtProof, uint32 index, bytes32 mainnetExitRoot, bytes32 rollupExitRoot, uint32 originNetwork, address originAddress, uint32 destinationNetwork, address destinationAddress, uint256 amount, bytes metadata) returns() +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeSession) ClaimMessage(smtProof [32][32]byte, index uint32, mainnetExitRoot [32]byte, rollupExitRoot [32]byte, originNetwork uint32, originAddress common.Address, destinationNetwork uint32, destinationAddress common.Address, amount *big.Int, metadata []byte) (*types.Transaction, error) { + return _Oldpolygonzkevmbridge.Contract.ClaimMessage(&_Oldpolygonzkevmbridge.TransactOpts, smtProof, index, mainnetExitRoot, rollupExitRoot, originNetwork, originAddress, destinationNetwork, destinationAddress, amount, metadata) +} + +// ClaimMessage is a paid mutator transaction binding the contract method 0x2d2c9d94. +// +// Solidity: function claimMessage(bytes32[32] smtProof, uint32 index, bytes32 mainnetExitRoot, bytes32 rollupExitRoot, uint32 originNetwork, address originAddress, uint32 destinationNetwork, address destinationAddress, uint256 amount, bytes metadata) returns() +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeTransactorSession) ClaimMessage(smtProof [32][32]byte, index uint32, mainnetExitRoot [32]byte, rollupExitRoot [32]byte, originNetwork uint32, originAddress common.Address, destinationNetwork uint32, destinationAddress common.Address, amount *big.Int, metadata []byte) (*types.Transaction, error) { + return _Oldpolygonzkevmbridge.Contract.ClaimMessage(&_Oldpolygonzkevmbridge.TransactOpts, smtProof, index, mainnetExitRoot, rollupExitRoot, originNetwork, originAddress, destinationNetwork, destinationAddress, amount, metadata) +} + +// DeactivateEmergencyState is a paid mutator transaction binding the contract method 0xdbc16976. +// +// Solidity: function deactivateEmergencyState() returns() +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeTransactor) DeactivateEmergencyState(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Oldpolygonzkevmbridge.contract.Transact(opts, "deactivateEmergencyState") +} + +// DeactivateEmergencyState is a paid mutator transaction binding the contract method 0xdbc16976. +// +// Solidity: function deactivateEmergencyState() returns() +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeSession) DeactivateEmergencyState() (*types.Transaction, error) { + return _Oldpolygonzkevmbridge.Contract.DeactivateEmergencyState(&_Oldpolygonzkevmbridge.TransactOpts) +} + +// DeactivateEmergencyState is a paid mutator transaction binding the contract method 0xdbc16976. +// +// Solidity: function deactivateEmergencyState() returns() +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeTransactorSession) DeactivateEmergencyState() (*types.Transaction, error) { + return _Oldpolygonzkevmbridge.Contract.DeactivateEmergencyState(&_Oldpolygonzkevmbridge.TransactOpts) +} + +// Initialize is a paid mutator transaction binding the contract method 0x647c576c. +// +// Solidity: function initialize(uint32 _networkID, address _globalExitRootManager, address _polygonZkEVMaddress) returns() +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeTransactor) Initialize(opts *bind.TransactOpts, _networkID uint32, _globalExitRootManager common.Address, _polygonZkEVMaddress common.Address) (*types.Transaction, error) { + return _Oldpolygonzkevmbridge.contract.Transact(opts, "initialize", _networkID, _globalExitRootManager, _polygonZkEVMaddress) +} + +// Initialize is a paid mutator transaction binding the contract method 0x647c576c. +// +// Solidity: function initialize(uint32 _networkID, address _globalExitRootManager, address _polygonZkEVMaddress) returns() +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeSession) Initialize(_networkID uint32, _globalExitRootManager common.Address, _polygonZkEVMaddress common.Address) (*types.Transaction, error) { + return _Oldpolygonzkevmbridge.Contract.Initialize(&_Oldpolygonzkevmbridge.TransactOpts, _networkID, _globalExitRootManager, _polygonZkEVMaddress) +} + +// Initialize is a paid mutator transaction binding the contract method 0x647c576c. +// +// Solidity: function initialize(uint32 _networkID, address _globalExitRootManager, address _polygonZkEVMaddress) returns() +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeTransactorSession) Initialize(_networkID uint32, _globalExitRootManager common.Address, _polygonZkEVMaddress common.Address) (*types.Transaction, error) { + return _Oldpolygonzkevmbridge.Contract.Initialize(&_Oldpolygonzkevmbridge.TransactOpts, _networkID, _globalExitRootManager, _polygonZkEVMaddress) +} + +// UpdateGlobalExitRoot is a paid mutator transaction binding the contract method 0x79e2cf97. +// +// Solidity: function updateGlobalExitRoot() returns() +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeTransactor) UpdateGlobalExitRoot(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Oldpolygonzkevmbridge.contract.Transact(opts, "updateGlobalExitRoot") +} + +// UpdateGlobalExitRoot is a paid mutator transaction binding the contract method 0x79e2cf97. +// +// Solidity: function updateGlobalExitRoot() returns() +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeSession) UpdateGlobalExitRoot() (*types.Transaction, error) { + return _Oldpolygonzkevmbridge.Contract.UpdateGlobalExitRoot(&_Oldpolygonzkevmbridge.TransactOpts) +} + +// UpdateGlobalExitRoot is a paid mutator transaction binding the contract method 0x79e2cf97. +// +// Solidity: function updateGlobalExitRoot() returns() +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeTransactorSession) UpdateGlobalExitRoot() (*types.Transaction, error) { + return _Oldpolygonzkevmbridge.Contract.UpdateGlobalExitRoot(&_Oldpolygonzkevmbridge.TransactOpts) +} + +// OldpolygonzkevmbridgeBridgeEventIterator is returned from FilterBridgeEvent and is used to iterate over the raw logs and unpacked data for BridgeEvent events raised by the Oldpolygonzkevmbridge contract. +type OldpolygonzkevmbridgeBridgeEventIterator struct { + Event *OldpolygonzkevmbridgeBridgeEvent // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *OldpolygonzkevmbridgeBridgeEventIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmbridgeBridgeEvent) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmbridgeBridgeEvent) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *OldpolygonzkevmbridgeBridgeEventIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *OldpolygonzkevmbridgeBridgeEventIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// OldpolygonzkevmbridgeBridgeEvent represents a BridgeEvent event raised by the Oldpolygonzkevmbridge contract. +type OldpolygonzkevmbridgeBridgeEvent struct { + LeafType uint8 + OriginNetwork uint32 + OriginAddress common.Address + DestinationNetwork uint32 + DestinationAddress common.Address + Amount *big.Int + Metadata []byte + DepositCount uint32 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterBridgeEvent is a free log retrieval operation binding the contract event 0x501781209a1f8899323b96b4ef08b168df93e0a90c673d1e4cce39366cb62f9b. +// +// Solidity: event BridgeEvent(uint8 leafType, uint32 originNetwork, address originAddress, uint32 destinationNetwork, address destinationAddress, uint256 amount, bytes metadata, uint32 depositCount) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeFilterer) FilterBridgeEvent(opts *bind.FilterOpts) (*OldpolygonzkevmbridgeBridgeEventIterator, error) { + + logs, sub, err := _Oldpolygonzkevmbridge.contract.FilterLogs(opts, "BridgeEvent") + if err != nil { + return nil, err + } + return &OldpolygonzkevmbridgeBridgeEventIterator{contract: _Oldpolygonzkevmbridge.contract, event: "BridgeEvent", logs: logs, sub: sub}, nil +} + +// WatchBridgeEvent is a free log subscription operation binding the contract event 0x501781209a1f8899323b96b4ef08b168df93e0a90c673d1e4cce39366cb62f9b. +// +// Solidity: event BridgeEvent(uint8 leafType, uint32 originNetwork, address originAddress, uint32 destinationNetwork, address destinationAddress, uint256 amount, bytes metadata, uint32 depositCount) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeFilterer) WatchBridgeEvent(opts *bind.WatchOpts, sink chan<- *OldpolygonzkevmbridgeBridgeEvent) (event.Subscription, error) { + + logs, sub, err := _Oldpolygonzkevmbridge.contract.WatchLogs(opts, "BridgeEvent") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(OldpolygonzkevmbridgeBridgeEvent) + if err := _Oldpolygonzkevmbridge.contract.UnpackLog(event, "BridgeEvent", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseBridgeEvent is a log parse operation binding the contract event 0x501781209a1f8899323b96b4ef08b168df93e0a90c673d1e4cce39366cb62f9b. +// +// Solidity: event BridgeEvent(uint8 leafType, uint32 originNetwork, address originAddress, uint32 destinationNetwork, address destinationAddress, uint256 amount, bytes metadata, uint32 depositCount) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeFilterer) ParseBridgeEvent(log types.Log) (*OldpolygonzkevmbridgeBridgeEvent, error) { + event := new(OldpolygonzkevmbridgeBridgeEvent) + if err := _Oldpolygonzkevmbridge.contract.UnpackLog(event, "BridgeEvent", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// OldpolygonzkevmbridgeClaimEventIterator is returned from FilterClaimEvent and is used to iterate over the raw logs and unpacked data for ClaimEvent events raised by the Oldpolygonzkevmbridge contract. +type OldpolygonzkevmbridgeClaimEventIterator struct { + Event *OldpolygonzkevmbridgeClaimEvent // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *OldpolygonzkevmbridgeClaimEventIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmbridgeClaimEvent) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmbridgeClaimEvent) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *OldpolygonzkevmbridgeClaimEventIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *OldpolygonzkevmbridgeClaimEventIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// OldpolygonzkevmbridgeClaimEvent represents a ClaimEvent event raised by the Oldpolygonzkevmbridge contract. +type OldpolygonzkevmbridgeClaimEvent struct { + Index uint32 + OriginNetwork uint32 + OriginAddress common.Address + DestinationAddress common.Address + Amount *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterClaimEvent is a free log retrieval operation binding the contract event 0x25308c93ceeed162da955b3f7ce3e3f93606579e40fb92029faa9efe27545983. +// +// Solidity: event ClaimEvent(uint32 index, uint32 originNetwork, address originAddress, address destinationAddress, uint256 amount) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeFilterer) FilterClaimEvent(opts *bind.FilterOpts) (*OldpolygonzkevmbridgeClaimEventIterator, error) { + + logs, sub, err := _Oldpolygonzkevmbridge.contract.FilterLogs(opts, "ClaimEvent") + if err != nil { + return nil, err + } + return &OldpolygonzkevmbridgeClaimEventIterator{contract: _Oldpolygonzkevmbridge.contract, event: "ClaimEvent", logs: logs, sub: sub}, nil +} + +// WatchClaimEvent is a free log subscription operation binding the contract event 0x25308c93ceeed162da955b3f7ce3e3f93606579e40fb92029faa9efe27545983. +// +// Solidity: event ClaimEvent(uint32 index, uint32 originNetwork, address originAddress, address destinationAddress, uint256 amount) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeFilterer) WatchClaimEvent(opts *bind.WatchOpts, sink chan<- *OldpolygonzkevmbridgeClaimEvent) (event.Subscription, error) { + + logs, sub, err := _Oldpolygonzkevmbridge.contract.WatchLogs(opts, "ClaimEvent") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(OldpolygonzkevmbridgeClaimEvent) + if err := _Oldpolygonzkevmbridge.contract.UnpackLog(event, "ClaimEvent", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseClaimEvent is a log parse operation binding the contract event 0x25308c93ceeed162da955b3f7ce3e3f93606579e40fb92029faa9efe27545983. +// +// Solidity: event ClaimEvent(uint32 index, uint32 originNetwork, address originAddress, address destinationAddress, uint256 amount) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeFilterer) ParseClaimEvent(log types.Log) (*OldpolygonzkevmbridgeClaimEvent, error) { + event := new(OldpolygonzkevmbridgeClaimEvent) + if err := _Oldpolygonzkevmbridge.contract.UnpackLog(event, "ClaimEvent", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// OldpolygonzkevmbridgeEmergencyStateActivatedIterator is returned from FilterEmergencyStateActivated and is used to iterate over the raw logs and unpacked data for EmergencyStateActivated events raised by the Oldpolygonzkevmbridge contract. +type OldpolygonzkevmbridgeEmergencyStateActivatedIterator struct { + Event *OldpolygonzkevmbridgeEmergencyStateActivated // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *OldpolygonzkevmbridgeEmergencyStateActivatedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmbridgeEmergencyStateActivated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmbridgeEmergencyStateActivated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *OldpolygonzkevmbridgeEmergencyStateActivatedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *OldpolygonzkevmbridgeEmergencyStateActivatedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// OldpolygonzkevmbridgeEmergencyStateActivated represents a EmergencyStateActivated event raised by the Oldpolygonzkevmbridge contract. +type OldpolygonzkevmbridgeEmergencyStateActivated struct { + Raw types.Log // Blockchain specific contextual infos +} + +// FilterEmergencyStateActivated is a free log retrieval operation binding the contract event 0x2261efe5aef6fedc1fd1550b25facc9181745623049c7901287030b9ad1a5497. +// +// Solidity: event EmergencyStateActivated() +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeFilterer) FilterEmergencyStateActivated(opts *bind.FilterOpts) (*OldpolygonzkevmbridgeEmergencyStateActivatedIterator, error) { + + logs, sub, err := _Oldpolygonzkevmbridge.contract.FilterLogs(opts, "EmergencyStateActivated") + if err != nil { + return nil, err + } + return &OldpolygonzkevmbridgeEmergencyStateActivatedIterator{contract: _Oldpolygonzkevmbridge.contract, event: "EmergencyStateActivated", logs: logs, sub: sub}, nil +} + +// WatchEmergencyStateActivated is a free log subscription operation binding the contract event 0x2261efe5aef6fedc1fd1550b25facc9181745623049c7901287030b9ad1a5497. +// +// Solidity: event EmergencyStateActivated() +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeFilterer) WatchEmergencyStateActivated(opts *bind.WatchOpts, sink chan<- *OldpolygonzkevmbridgeEmergencyStateActivated) (event.Subscription, error) { + + logs, sub, err := _Oldpolygonzkevmbridge.contract.WatchLogs(opts, "EmergencyStateActivated") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(OldpolygonzkevmbridgeEmergencyStateActivated) + if err := _Oldpolygonzkevmbridge.contract.UnpackLog(event, "EmergencyStateActivated", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseEmergencyStateActivated is a log parse operation binding the contract event 0x2261efe5aef6fedc1fd1550b25facc9181745623049c7901287030b9ad1a5497. +// +// Solidity: event EmergencyStateActivated() +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeFilterer) ParseEmergencyStateActivated(log types.Log) (*OldpolygonzkevmbridgeEmergencyStateActivated, error) { + event := new(OldpolygonzkevmbridgeEmergencyStateActivated) + if err := _Oldpolygonzkevmbridge.contract.UnpackLog(event, "EmergencyStateActivated", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// OldpolygonzkevmbridgeEmergencyStateDeactivatedIterator is returned from FilterEmergencyStateDeactivated and is used to iterate over the raw logs and unpacked data for EmergencyStateDeactivated events raised by the Oldpolygonzkevmbridge contract. +type OldpolygonzkevmbridgeEmergencyStateDeactivatedIterator struct { + Event *OldpolygonzkevmbridgeEmergencyStateDeactivated // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *OldpolygonzkevmbridgeEmergencyStateDeactivatedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmbridgeEmergencyStateDeactivated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmbridgeEmergencyStateDeactivated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *OldpolygonzkevmbridgeEmergencyStateDeactivatedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *OldpolygonzkevmbridgeEmergencyStateDeactivatedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// OldpolygonzkevmbridgeEmergencyStateDeactivated represents a EmergencyStateDeactivated event raised by the Oldpolygonzkevmbridge contract. +type OldpolygonzkevmbridgeEmergencyStateDeactivated struct { + Raw types.Log // Blockchain specific contextual infos +} + +// FilterEmergencyStateDeactivated is a free log retrieval operation binding the contract event 0x1e5e34eea33501aecf2ebec9fe0e884a40804275ea7fe10b2ba084c8374308b3. +// +// Solidity: event EmergencyStateDeactivated() +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeFilterer) FilterEmergencyStateDeactivated(opts *bind.FilterOpts) (*OldpolygonzkevmbridgeEmergencyStateDeactivatedIterator, error) { + + logs, sub, err := _Oldpolygonzkevmbridge.contract.FilterLogs(opts, "EmergencyStateDeactivated") + if err != nil { + return nil, err + } + return &OldpolygonzkevmbridgeEmergencyStateDeactivatedIterator{contract: _Oldpolygonzkevmbridge.contract, event: "EmergencyStateDeactivated", logs: logs, sub: sub}, nil +} + +// WatchEmergencyStateDeactivated is a free log subscription operation binding the contract event 0x1e5e34eea33501aecf2ebec9fe0e884a40804275ea7fe10b2ba084c8374308b3. +// +// Solidity: event EmergencyStateDeactivated() +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeFilterer) WatchEmergencyStateDeactivated(opts *bind.WatchOpts, sink chan<- *OldpolygonzkevmbridgeEmergencyStateDeactivated) (event.Subscription, error) { + + logs, sub, err := _Oldpolygonzkevmbridge.contract.WatchLogs(opts, "EmergencyStateDeactivated") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(OldpolygonzkevmbridgeEmergencyStateDeactivated) + if err := _Oldpolygonzkevmbridge.contract.UnpackLog(event, "EmergencyStateDeactivated", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseEmergencyStateDeactivated is a log parse operation binding the contract event 0x1e5e34eea33501aecf2ebec9fe0e884a40804275ea7fe10b2ba084c8374308b3. +// +// Solidity: event EmergencyStateDeactivated() +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeFilterer) ParseEmergencyStateDeactivated(log types.Log) (*OldpolygonzkevmbridgeEmergencyStateDeactivated, error) { + event := new(OldpolygonzkevmbridgeEmergencyStateDeactivated) + if err := _Oldpolygonzkevmbridge.contract.UnpackLog(event, "EmergencyStateDeactivated", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// OldpolygonzkevmbridgeInitializedIterator is returned from FilterInitialized and is used to iterate over the raw logs and unpacked data for Initialized events raised by the Oldpolygonzkevmbridge contract. +type OldpolygonzkevmbridgeInitializedIterator struct { + Event *OldpolygonzkevmbridgeInitialized // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *OldpolygonzkevmbridgeInitializedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmbridgeInitialized) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmbridgeInitialized) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *OldpolygonzkevmbridgeInitializedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *OldpolygonzkevmbridgeInitializedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// OldpolygonzkevmbridgeInitialized represents a Initialized event raised by the Oldpolygonzkevmbridge contract. +type OldpolygonzkevmbridgeInitialized struct { + Version uint8 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterInitialized is a free log retrieval operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeFilterer) FilterInitialized(opts *bind.FilterOpts) (*OldpolygonzkevmbridgeInitializedIterator, error) { + + logs, sub, err := _Oldpolygonzkevmbridge.contract.FilterLogs(opts, "Initialized") + if err != nil { + return nil, err + } + return &OldpolygonzkevmbridgeInitializedIterator{contract: _Oldpolygonzkevmbridge.contract, event: "Initialized", logs: logs, sub: sub}, nil +} + +// WatchInitialized is a free log subscription operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *OldpolygonzkevmbridgeInitialized) (event.Subscription, error) { + + logs, sub, err := _Oldpolygonzkevmbridge.contract.WatchLogs(opts, "Initialized") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(OldpolygonzkevmbridgeInitialized) + if err := _Oldpolygonzkevmbridge.contract.UnpackLog(event, "Initialized", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseInitialized is a log parse operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeFilterer) ParseInitialized(log types.Log) (*OldpolygonzkevmbridgeInitialized, error) { + event := new(OldpolygonzkevmbridgeInitialized) + if err := _Oldpolygonzkevmbridge.contract.UnpackLog(event, "Initialized", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// OldpolygonzkevmbridgeNewWrappedTokenIterator is returned from FilterNewWrappedToken and is used to iterate over the raw logs and unpacked data for NewWrappedToken events raised by the Oldpolygonzkevmbridge contract. +type OldpolygonzkevmbridgeNewWrappedTokenIterator struct { + Event *OldpolygonzkevmbridgeNewWrappedToken // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *OldpolygonzkevmbridgeNewWrappedTokenIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmbridgeNewWrappedToken) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmbridgeNewWrappedToken) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *OldpolygonzkevmbridgeNewWrappedTokenIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *OldpolygonzkevmbridgeNewWrappedTokenIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// OldpolygonzkevmbridgeNewWrappedToken represents a NewWrappedToken event raised by the Oldpolygonzkevmbridge contract. +type OldpolygonzkevmbridgeNewWrappedToken struct { + OriginNetwork uint32 + OriginTokenAddress common.Address + WrappedTokenAddress common.Address + Metadata []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterNewWrappedToken is a free log retrieval operation binding the contract event 0x490e59a1701b938786ac72570a1efeac994a3dbe96e2e883e19e902ace6e6a39. +// +// Solidity: event NewWrappedToken(uint32 originNetwork, address originTokenAddress, address wrappedTokenAddress, bytes metadata) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeFilterer) FilterNewWrappedToken(opts *bind.FilterOpts) (*OldpolygonzkevmbridgeNewWrappedTokenIterator, error) { + + logs, sub, err := _Oldpolygonzkevmbridge.contract.FilterLogs(opts, "NewWrappedToken") + if err != nil { + return nil, err + } + return &OldpolygonzkevmbridgeNewWrappedTokenIterator{contract: _Oldpolygonzkevmbridge.contract, event: "NewWrappedToken", logs: logs, sub: sub}, nil +} + +// WatchNewWrappedToken is a free log subscription operation binding the contract event 0x490e59a1701b938786ac72570a1efeac994a3dbe96e2e883e19e902ace6e6a39. +// +// Solidity: event NewWrappedToken(uint32 originNetwork, address originTokenAddress, address wrappedTokenAddress, bytes metadata) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeFilterer) WatchNewWrappedToken(opts *bind.WatchOpts, sink chan<- *OldpolygonzkevmbridgeNewWrappedToken) (event.Subscription, error) { + + logs, sub, err := _Oldpolygonzkevmbridge.contract.WatchLogs(opts, "NewWrappedToken") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(OldpolygonzkevmbridgeNewWrappedToken) + if err := _Oldpolygonzkevmbridge.contract.UnpackLog(event, "NewWrappedToken", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseNewWrappedToken is a log parse operation binding the contract event 0x490e59a1701b938786ac72570a1efeac994a3dbe96e2e883e19e902ace6e6a39. +// +// Solidity: event NewWrappedToken(uint32 originNetwork, address originTokenAddress, address wrappedTokenAddress, bytes metadata) +func (_Oldpolygonzkevmbridge *OldpolygonzkevmbridgeFilterer) ParseNewWrappedToken(log types.Log) (*OldpolygonzkevmbridgeNewWrappedToken, error) { + event := new(OldpolygonzkevmbridgeNewWrappedToken) + if err := _Oldpolygonzkevmbridge.contract.UnpackLog(event, "NewWrappedToken", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/etherman/smartcontracts/oldpolygonzkevmglobalexitroot/oldpolygonzkevmglobalexitroot.go b/etherman/smartcontracts/oldpolygonzkevmglobalexitroot/oldpolygonzkevmglobalexitroot.go new file mode 100644 index 0000000..2ee6235 --- /dev/null +++ b/etherman/smartcontracts/oldpolygonzkevmglobalexitroot/oldpolygonzkevmglobalexitroot.go @@ -0,0 +1,563 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package oldpolygonzkevmglobalexitroot + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// OldpolygonzkevmglobalexitrootMetaData contains all meta data concerning the Oldpolygonzkevmglobalexitroot contract. +var OldpolygonzkevmglobalexitrootMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_rollupManager\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_bridgeAddress\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"OnlyAllowedContracts\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"mainnetExitRoot\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"rollupExitRoot\",\"type\":\"bytes32\"}],\"name\":\"UpdateGlobalExitRoot\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"bridgeAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getLastGlobalExitRoot\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"globalExitRootMap\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"lastMainnetExitRoot\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"lastRollupExitRoot\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"rollupManager\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"newRoot\",\"type\":\"bytes32\"}],\"name\":\"updateExitRoot\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", + Bin: "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", +} + +// OldpolygonzkevmglobalexitrootABI is the input ABI used to generate the binding from. +// Deprecated: Use OldpolygonzkevmglobalexitrootMetaData.ABI instead. +var OldpolygonzkevmglobalexitrootABI = OldpolygonzkevmglobalexitrootMetaData.ABI + +// OldpolygonzkevmglobalexitrootBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use OldpolygonzkevmglobalexitrootMetaData.Bin instead. +var OldpolygonzkevmglobalexitrootBin = OldpolygonzkevmglobalexitrootMetaData.Bin + +// DeployOldpolygonzkevmglobalexitroot deploys a new Ethereum contract, binding an instance of Oldpolygonzkevmglobalexitroot to it. +func DeployOldpolygonzkevmglobalexitroot(auth *bind.TransactOpts, backend bind.ContractBackend, _rollupManager common.Address, _bridgeAddress common.Address) (common.Address, *types.Transaction, *Oldpolygonzkevmglobalexitroot, error) { + parsed, err := OldpolygonzkevmglobalexitrootMetaData.GetAbi() + if err != nil { + return common.Address{}, nil, nil, err + } + if parsed == nil { + return common.Address{}, nil, nil, errors.New("GetABI returned nil") + } + + address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex(OldpolygonzkevmglobalexitrootBin), backend, _rollupManager, _bridgeAddress) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &Oldpolygonzkevmglobalexitroot{OldpolygonzkevmglobalexitrootCaller: OldpolygonzkevmglobalexitrootCaller{contract: contract}, OldpolygonzkevmglobalexitrootTransactor: OldpolygonzkevmglobalexitrootTransactor{contract: contract}, OldpolygonzkevmglobalexitrootFilterer: OldpolygonzkevmglobalexitrootFilterer{contract: contract}}, nil +} + +// Oldpolygonzkevmglobalexitroot is an auto generated Go binding around an Ethereum contract. +type Oldpolygonzkevmglobalexitroot struct { + OldpolygonzkevmglobalexitrootCaller // Read-only binding to the contract + OldpolygonzkevmglobalexitrootTransactor // Write-only binding to the contract + OldpolygonzkevmglobalexitrootFilterer // Log filterer for contract events +} + +// OldpolygonzkevmglobalexitrootCaller is an auto generated read-only Go binding around an Ethereum contract. +type OldpolygonzkevmglobalexitrootCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// OldpolygonzkevmglobalexitrootTransactor is an auto generated write-only Go binding around an Ethereum contract. +type OldpolygonzkevmglobalexitrootTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// OldpolygonzkevmglobalexitrootFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type OldpolygonzkevmglobalexitrootFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// OldpolygonzkevmglobalexitrootSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type OldpolygonzkevmglobalexitrootSession struct { + Contract *Oldpolygonzkevmglobalexitroot // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// OldpolygonzkevmglobalexitrootCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type OldpolygonzkevmglobalexitrootCallerSession struct { + Contract *OldpolygonzkevmglobalexitrootCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// OldpolygonzkevmglobalexitrootTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type OldpolygonzkevmglobalexitrootTransactorSession struct { + Contract *OldpolygonzkevmglobalexitrootTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// OldpolygonzkevmglobalexitrootRaw is an auto generated low-level Go binding around an Ethereum contract. +type OldpolygonzkevmglobalexitrootRaw struct { + Contract *Oldpolygonzkevmglobalexitroot // Generic contract binding to access the raw methods on +} + +// OldpolygonzkevmglobalexitrootCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type OldpolygonzkevmglobalexitrootCallerRaw struct { + Contract *OldpolygonzkevmglobalexitrootCaller // Generic read-only contract binding to access the raw methods on +} + +// OldpolygonzkevmglobalexitrootTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type OldpolygonzkevmglobalexitrootTransactorRaw struct { + Contract *OldpolygonzkevmglobalexitrootTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewOldpolygonzkevmglobalexitroot creates a new instance of Oldpolygonzkevmglobalexitroot, bound to a specific deployed contract. +func NewOldpolygonzkevmglobalexitroot(address common.Address, backend bind.ContractBackend) (*Oldpolygonzkevmglobalexitroot, error) { + contract, err := bindOldpolygonzkevmglobalexitroot(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &Oldpolygonzkevmglobalexitroot{OldpolygonzkevmglobalexitrootCaller: OldpolygonzkevmglobalexitrootCaller{contract: contract}, OldpolygonzkevmglobalexitrootTransactor: OldpolygonzkevmglobalexitrootTransactor{contract: contract}, OldpolygonzkevmglobalexitrootFilterer: OldpolygonzkevmglobalexitrootFilterer{contract: contract}}, nil +} + +// NewOldpolygonzkevmglobalexitrootCaller creates a new read-only instance of Oldpolygonzkevmglobalexitroot, bound to a specific deployed contract. +func NewOldpolygonzkevmglobalexitrootCaller(address common.Address, caller bind.ContractCaller) (*OldpolygonzkevmglobalexitrootCaller, error) { + contract, err := bindOldpolygonzkevmglobalexitroot(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &OldpolygonzkevmglobalexitrootCaller{contract: contract}, nil +} + +// NewOldpolygonzkevmglobalexitrootTransactor creates a new write-only instance of Oldpolygonzkevmglobalexitroot, bound to a specific deployed contract. +func NewOldpolygonzkevmglobalexitrootTransactor(address common.Address, transactor bind.ContractTransactor) (*OldpolygonzkevmglobalexitrootTransactor, error) { + contract, err := bindOldpolygonzkevmglobalexitroot(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &OldpolygonzkevmglobalexitrootTransactor{contract: contract}, nil +} + +// NewOldpolygonzkevmglobalexitrootFilterer creates a new log filterer instance of Oldpolygonzkevmglobalexitroot, bound to a specific deployed contract. +func NewOldpolygonzkevmglobalexitrootFilterer(address common.Address, filterer bind.ContractFilterer) (*OldpolygonzkevmglobalexitrootFilterer, error) { + contract, err := bindOldpolygonzkevmglobalexitroot(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &OldpolygonzkevmglobalexitrootFilterer{contract: contract}, nil +} + +// bindOldpolygonzkevmglobalexitroot binds a generic wrapper to an already deployed contract. +func bindOldpolygonzkevmglobalexitroot(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := OldpolygonzkevmglobalexitrootMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Oldpolygonzkevmglobalexitroot *OldpolygonzkevmglobalexitrootRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Oldpolygonzkevmglobalexitroot.Contract.OldpolygonzkevmglobalexitrootCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Oldpolygonzkevmglobalexitroot *OldpolygonzkevmglobalexitrootRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Oldpolygonzkevmglobalexitroot.Contract.OldpolygonzkevmglobalexitrootTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Oldpolygonzkevmglobalexitroot *OldpolygonzkevmglobalexitrootRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Oldpolygonzkevmglobalexitroot.Contract.OldpolygonzkevmglobalexitrootTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Oldpolygonzkevmglobalexitroot *OldpolygonzkevmglobalexitrootCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Oldpolygonzkevmglobalexitroot.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Oldpolygonzkevmglobalexitroot *OldpolygonzkevmglobalexitrootTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Oldpolygonzkevmglobalexitroot.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Oldpolygonzkevmglobalexitroot *OldpolygonzkevmglobalexitrootTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Oldpolygonzkevmglobalexitroot.Contract.contract.Transact(opts, method, params...) +} + +// BridgeAddress is a free data retrieval call binding the contract method 0xa3c573eb. +// +// Solidity: function bridgeAddress() view returns(address) +func (_Oldpolygonzkevmglobalexitroot *OldpolygonzkevmglobalexitrootCaller) BridgeAddress(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Oldpolygonzkevmglobalexitroot.contract.Call(opts, &out, "bridgeAddress") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// BridgeAddress is a free data retrieval call binding the contract method 0xa3c573eb. +// +// Solidity: function bridgeAddress() view returns(address) +func (_Oldpolygonzkevmglobalexitroot *OldpolygonzkevmglobalexitrootSession) BridgeAddress() (common.Address, error) { + return _Oldpolygonzkevmglobalexitroot.Contract.BridgeAddress(&_Oldpolygonzkevmglobalexitroot.CallOpts) +} + +// BridgeAddress is a free data retrieval call binding the contract method 0xa3c573eb. +// +// Solidity: function bridgeAddress() view returns(address) +func (_Oldpolygonzkevmglobalexitroot *OldpolygonzkevmglobalexitrootCallerSession) BridgeAddress() (common.Address, error) { + return _Oldpolygonzkevmglobalexitroot.Contract.BridgeAddress(&_Oldpolygonzkevmglobalexitroot.CallOpts) +} + +// GetLastGlobalExitRoot is a free data retrieval call binding the contract method 0x3ed691ef. +// +// Solidity: function getLastGlobalExitRoot() view returns(bytes32) +func (_Oldpolygonzkevmglobalexitroot *OldpolygonzkevmglobalexitrootCaller) GetLastGlobalExitRoot(opts *bind.CallOpts) ([32]byte, error) { + var out []interface{} + err := _Oldpolygonzkevmglobalexitroot.contract.Call(opts, &out, "getLastGlobalExitRoot") + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// GetLastGlobalExitRoot is a free data retrieval call binding the contract method 0x3ed691ef. +// +// Solidity: function getLastGlobalExitRoot() view returns(bytes32) +func (_Oldpolygonzkevmglobalexitroot *OldpolygonzkevmglobalexitrootSession) GetLastGlobalExitRoot() ([32]byte, error) { + return _Oldpolygonzkevmglobalexitroot.Contract.GetLastGlobalExitRoot(&_Oldpolygonzkevmglobalexitroot.CallOpts) +} + +// GetLastGlobalExitRoot is a free data retrieval call binding the contract method 0x3ed691ef. +// +// Solidity: function getLastGlobalExitRoot() view returns(bytes32) +func (_Oldpolygonzkevmglobalexitroot *OldpolygonzkevmglobalexitrootCallerSession) GetLastGlobalExitRoot() ([32]byte, error) { + return _Oldpolygonzkevmglobalexitroot.Contract.GetLastGlobalExitRoot(&_Oldpolygonzkevmglobalexitroot.CallOpts) +} + +// GlobalExitRootMap is a free data retrieval call binding the contract method 0x257b3632. +// +// Solidity: function globalExitRootMap(bytes32 ) view returns(uint256) +func (_Oldpolygonzkevmglobalexitroot *OldpolygonzkevmglobalexitrootCaller) GlobalExitRootMap(opts *bind.CallOpts, arg0 [32]byte) (*big.Int, error) { + var out []interface{} + err := _Oldpolygonzkevmglobalexitroot.contract.Call(opts, &out, "globalExitRootMap", arg0) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// GlobalExitRootMap is a free data retrieval call binding the contract method 0x257b3632. +// +// Solidity: function globalExitRootMap(bytes32 ) view returns(uint256) +func (_Oldpolygonzkevmglobalexitroot *OldpolygonzkevmglobalexitrootSession) GlobalExitRootMap(arg0 [32]byte) (*big.Int, error) { + return _Oldpolygonzkevmglobalexitroot.Contract.GlobalExitRootMap(&_Oldpolygonzkevmglobalexitroot.CallOpts, arg0) +} + +// GlobalExitRootMap is a free data retrieval call binding the contract method 0x257b3632. +// +// Solidity: function globalExitRootMap(bytes32 ) view returns(uint256) +func (_Oldpolygonzkevmglobalexitroot *OldpolygonzkevmglobalexitrootCallerSession) GlobalExitRootMap(arg0 [32]byte) (*big.Int, error) { + return _Oldpolygonzkevmglobalexitroot.Contract.GlobalExitRootMap(&_Oldpolygonzkevmglobalexitroot.CallOpts, arg0) +} + +// LastMainnetExitRoot is a free data retrieval call binding the contract method 0x319cf735. +// +// Solidity: function lastMainnetExitRoot() view returns(bytes32) +func (_Oldpolygonzkevmglobalexitroot *OldpolygonzkevmglobalexitrootCaller) LastMainnetExitRoot(opts *bind.CallOpts) ([32]byte, error) { + var out []interface{} + err := _Oldpolygonzkevmglobalexitroot.contract.Call(opts, &out, "lastMainnetExitRoot") + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// LastMainnetExitRoot is a free data retrieval call binding the contract method 0x319cf735. +// +// Solidity: function lastMainnetExitRoot() view returns(bytes32) +func (_Oldpolygonzkevmglobalexitroot *OldpolygonzkevmglobalexitrootSession) LastMainnetExitRoot() ([32]byte, error) { + return _Oldpolygonzkevmglobalexitroot.Contract.LastMainnetExitRoot(&_Oldpolygonzkevmglobalexitroot.CallOpts) +} + +// LastMainnetExitRoot is a free data retrieval call binding the contract method 0x319cf735. +// +// Solidity: function lastMainnetExitRoot() view returns(bytes32) +func (_Oldpolygonzkevmglobalexitroot *OldpolygonzkevmglobalexitrootCallerSession) LastMainnetExitRoot() ([32]byte, error) { + return _Oldpolygonzkevmglobalexitroot.Contract.LastMainnetExitRoot(&_Oldpolygonzkevmglobalexitroot.CallOpts) +} + +// LastRollupExitRoot is a free data retrieval call binding the contract method 0x01fd9044. +// +// Solidity: function lastRollupExitRoot() view returns(bytes32) +func (_Oldpolygonzkevmglobalexitroot *OldpolygonzkevmglobalexitrootCaller) LastRollupExitRoot(opts *bind.CallOpts) ([32]byte, error) { + var out []interface{} + err := _Oldpolygonzkevmglobalexitroot.contract.Call(opts, &out, "lastRollupExitRoot") + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// LastRollupExitRoot is a free data retrieval call binding the contract method 0x01fd9044. +// +// Solidity: function lastRollupExitRoot() view returns(bytes32) +func (_Oldpolygonzkevmglobalexitroot *OldpolygonzkevmglobalexitrootSession) LastRollupExitRoot() ([32]byte, error) { + return _Oldpolygonzkevmglobalexitroot.Contract.LastRollupExitRoot(&_Oldpolygonzkevmglobalexitroot.CallOpts) +} + +// LastRollupExitRoot is a free data retrieval call binding the contract method 0x01fd9044. +// +// Solidity: function lastRollupExitRoot() view returns(bytes32) +func (_Oldpolygonzkevmglobalexitroot *OldpolygonzkevmglobalexitrootCallerSession) LastRollupExitRoot() ([32]byte, error) { + return _Oldpolygonzkevmglobalexitroot.Contract.LastRollupExitRoot(&_Oldpolygonzkevmglobalexitroot.CallOpts) +} + +// RollupManager is a free data retrieval call binding the contract method 0x49b7b802. +// +// Solidity: function rollupManager() view returns(address) +func (_Oldpolygonzkevmglobalexitroot *OldpolygonzkevmglobalexitrootCaller) RollupManager(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Oldpolygonzkevmglobalexitroot.contract.Call(opts, &out, "rollupManager") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// RollupManager is a free data retrieval call binding the contract method 0x49b7b802. +// +// Solidity: function rollupManager() view returns(address) +func (_Oldpolygonzkevmglobalexitroot *OldpolygonzkevmglobalexitrootSession) RollupManager() (common.Address, error) { + return _Oldpolygonzkevmglobalexitroot.Contract.RollupManager(&_Oldpolygonzkevmglobalexitroot.CallOpts) +} + +// RollupManager is a free data retrieval call binding the contract method 0x49b7b802. +// +// Solidity: function rollupManager() view returns(address) +func (_Oldpolygonzkevmglobalexitroot *OldpolygonzkevmglobalexitrootCallerSession) RollupManager() (common.Address, error) { + return _Oldpolygonzkevmglobalexitroot.Contract.RollupManager(&_Oldpolygonzkevmglobalexitroot.CallOpts) +} + +// UpdateExitRoot is a paid mutator transaction binding the contract method 0x33d6247d. +// +// Solidity: function updateExitRoot(bytes32 newRoot) returns() +func (_Oldpolygonzkevmglobalexitroot *OldpolygonzkevmglobalexitrootTransactor) UpdateExitRoot(opts *bind.TransactOpts, newRoot [32]byte) (*types.Transaction, error) { + return _Oldpolygonzkevmglobalexitroot.contract.Transact(opts, "updateExitRoot", newRoot) +} + +// UpdateExitRoot is a paid mutator transaction binding the contract method 0x33d6247d. +// +// Solidity: function updateExitRoot(bytes32 newRoot) returns() +func (_Oldpolygonzkevmglobalexitroot *OldpolygonzkevmglobalexitrootSession) UpdateExitRoot(newRoot [32]byte) (*types.Transaction, error) { + return _Oldpolygonzkevmglobalexitroot.Contract.UpdateExitRoot(&_Oldpolygonzkevmglobalexitroot.TransactOpts, newRoot) +} + +// UpdateExitRoot is a paid mutator transaction binding the contract method 0x33d6247d. +// +// Solidity: function updateExitRoot(bytes32 newRoot) returns() +func (_Oldpolygonzkevmglobalexitroot *OldpolygonzkevmglobalexitrootTransactorSession) UpdateExitRoot(newRoot [32]byte) (*types.Transaction, error) { + return _Oldpolygonzkevmglobalexitroot.Contract.UpdateExitRoot(&_Oldpolygonzkevmglobalexitroot.TransactOpts, newRoot) +} + +// OldpolygonzkevmglobalexitrootUpdateGlobalExitRootIterator is returned from FilterUpdateGlobalExitRoot and is used to iterate over the raw logs and unpacked data for UpdateGlobalExitRoot events raised by the Oldpolygonzkevmglobalexitroot contract. +type OldpolygonzkevmglobalexitrootUpdateGlobalExitRootIterator struct { + Event *OldpolygonzkevmglobalexitrootUpdateGlobalExitRoot // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *OldpolygonzkevmglobalexitrootUpdateGlobalExitRootIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmglobalexitrootUpdateGlobalExitRoot) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(OldpolygonzkevmglobalexitrootUpdateGlobalExitRoot) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *OldpolygonzkevmglobalexitrootUpdateGlobalExitRootIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *OldpolygonzkevmglobalexitrootUpdateGlobalExitRootIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// OldpolygonzkevmglobalexitrootUpdateGlobalExitRoot represents a UpdateGlobalExitRoot event raised by the Oldpolygonzkevmglobalexitroot contract. +type OldpolygonzkevmglobalexitrootUpdateGlobalExitRoot struct { + MainnetExitRoot [32]byte + RollupExitRoot [32]byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterUpdateGlobalExitRoot is a free log retrieval operation binding the contract event 0x61014378f82a0d809aefaf87a8ac9505b89c321808287a6e7810f29304c1fce3. +// +// Solidity: event UpdateGlobalExitRoot(bytes32 indexed mainnetExitRoot, bytes32 indexed rollupExitRoot) +func (_Oldpolygonzkevmglobalexitroot *OldpolygonzkevmglobalexitrootFilterer) FilterUpdateGlobalExitRoot(opts *bind.FilterOpts, mainnetExitRoot [][32]byte, rollupExitRoot [][32]byte) (*OldpolygonzkevmglobalexitrootUpdateGlobalExitRootIterator, error) { + + var mainnetExitRootRule []interface{} + for _, mainnetExitRootItem := range mainnetExitRoot { + mainnetExitRootRule = append(mainnetExitRootRule, mainnetExitRootItem) + } + var rollupExitRootRule []interface{} + for _, rollupExitRootItem := range rollupExitRoot { + rollupExitRootRule = append(rollupExitRootRule, rollupExitRootItem) + } + + logs, sub, err := _Oldpolygonzkevmglobalexitroot.contract.FilterLogs(opts, "UpdateGlobalExitRoot", mainnetExitRootRule, rollupExitRootRule) + if err != nil { + return nil, err + } + return &OldpolygonzkevmglobalexitrootUpdateGlobalExitRootIterator{contract: _Oldpolygonzkevmglobalexitroot.contract, event: "UpdateGlobalExitRoot", logs: logs, sub: sub}, nil +} + +// WatchUpdateGlobalExitRoot is a free log subscription operation binding the contract event 0x61014378f82a0d809aefaf87a8ac9505b89c321808287a6e7810f29304c1fce3. +// +// Solidity: event UpdateGlobalExitRoot(bytes32 indexed mainnetExitRoot, bytes32 indexed rollupExitRoot) +func (_Oldpolygonzkevmglobalexitroot *OldpolygonzkevmglobalexitrootFilterer) WatchUpdateGlobalExitRoot(opts *bind.WatchOpts, sink chan<- *OldpolygonzkevmglobalexitrootUpdateGlobalExitRoot, mainnetExitRoot [][32]byte, rollupExitRoot [][32]byte) (event.Subscription, error) { + + var mainnetExitRootRule []interface{} + for _, mainnetExitRootItem := range mainnetExitRoot { + mainnetExitRootRule = append(mainnetExitRootRule, mainnetExitRootItem) + } + var rollupExitRootRule []interface{} + for _, rollupExitRootItem := range rollupExitRoot { + rollupExitRootRule = append(rollupExitRootRule, rollupExitRootItem) + } + + logs, sub, err := _Oldpolygonzkevmglobalexitroot.contract.WatchLogs(opts, "UpdateGlobalExitRoot", mainnetExitRootRule, rollupExitRootRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(OldpolygonzkevmglobalexitrootUpdateGlobalExitRoot) + if err := _Oldpolygonzkevmglobalexitroot.contract.UnpackLog(event, "UpdateGlobalExitRoot", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseUpdateGlobalExitRoot is a log parse operation binding the contract event 0x61014378f82a0d809aefaf87a8ac9505b89c321808287a6e7810f29304c1fce3. +// +// Solidity: event UpdateGlobalExitRoot(bytes32 indexed mainnetExitRoot, bytes32 indexed rollupExitRoot) +func (_Oldpolygonzkevmglobalexitroot *OldpolygonzkevmglobalexitrootFilterer) ParseUpdateGlobalExitRoot(log types.Log) (*OldpolygonzkevmglobalexitrootUpdateGlobalExitRoot, error) { + event := new(OldpolygonzkevmglobalexitrootUpdateGlobalExitRoot) + if err := _Oldpolygonzkevmglobalexitroot.contract.UnpackLog(event, "UpdateGlobalExitRoot", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/etherman/smartcontracts/pol/pol.go b/etherman/smartcontracts/pol/pol.go new file mode 100644 index 0000000..3729033 --- /dev/null +++ b/etherman/smartcontracts/pol/pol.go @@ -0,0 +1,1504 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package pol + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// PolMetaData contains all meta data concerning the Pol contract. +var PolMetaData = &bind.MetaData{ + ABI: "[{\"constant\":true,\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"spender\",\"type\":\"address\"},{\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"from\",\"type\":\"address\"},{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"name\":\"\",\"type\":\"uint8\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"spender\",\"type\":\"address\"},{\"name\":\"addedValue\",\"type\":\"uint256\"}],\"name\":\"increaseAllowance\",\"outputs\":[{\"name\":\"success\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"unpause\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"account\",\"type\":\"address\"}],\"name\":\"isPauser\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"paused\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"renouncePauser\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"account\",\"type\":\"address\"}],\"name\":\"addPauser\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"pause\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"spender\",\"type\":\"address\"},{\"name\":\"subtractedValue\",\"type\":\"uint256\"}],\"name\":\"decreaseAllowance\",\"outputs\":[{\"name\":\"success\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"owner\",\"type\":\"address\"},{\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"name\":\"name\",\"type\":\"string\"},{\"name\":\"symbol\",\"type\":\"string\"},{\"name\":\"decimals\",\"type\":\"uint8\"},{\"name\":\"totalSupply\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"account\",\"type\":\"address\"}],\"name\":\"Paused\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"account\",\"type\":\"address\"}],\"name\":\"Unpaused\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"account\",\"type\":\"address\"}],\"name\":\"PauserAdded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"account\",\"type\":\"address\"}],\"name\":\"PauserRemoved\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"}]", + Bin: "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", +} + +// PolABI is the input ABI used to generate the binding from. +// Deprecated: Use PolMetaData.ABI instead. +var PolABI = PolMetaData.ABI + +// PolBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use PolMetaData.Bin instead. +var PolBin = PolMetaData.Bin + +// DeployPol deploys a new Ethereum contract, binding an instance of Pol to it. +func DeployPol(auth *bind.TransactOpts, backend bind.ContractBackend, name string, symbol string, decimals uint8, totalSupply *big.Int) (common.Address, *types.Transaction, *Pol, error) { + parsed, err := PolMetaData.GetAbi() + if err != nil { + return common.Address{}, nil, nil, err + } + if parsed == nil { + return common.Address{}, nil, nil, errors.New("GetABI returned nil") + } + + address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex(PolBin), backend, name, symbol, decimals, totalSupply) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &Pol{PolCaller: PolCaller{contract: contract}, PolTransactor: PolTransactor{contract: contract}, PolFilterer: PolFilterer{contract: contract}}, nil +} + +// Pol is an auto generated Go binding around an Ethereum contract. +type Pol struct { + PolCaller // Read-only binding to the contract + PolTransactor // Write-only binding to the contract + PolFilterer // Log filterer for contract events +} + +// PolCaller is an auto generated read-only Go binding around an Ethereum contract. +type PolCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// PolTransactor is an auto generated write-only Go binding around an Ethereum contract. +type PolTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// PolFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type PolFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// PolSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type PolSession struct { + Contract *Pol // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// PolCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type PolCallerSession struct { + Contract *PolCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// PolTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type PolTransactorSession struct { + Contract *PolTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// PolRaw is an auto generated low-level Go binding around an Ethereum contract. +type PolRaw struct { + Contract *Pol // Generic contract binding to access the raw methods on +} + +// PolCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type PolCallerRaw struct { + Contract *PolCaller // Generic read-only contract binding to access the raw methods on +} + +// PolTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type PolTransactorRaw struct { + Contract *PolTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewPol creates a new instance of Pol, bound to a specific deployed contract. +func NewPol(address common.Address, backend bind.ContractBackend) (*Pol, error) { + contract, err := bindPol(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &Pol{PolCaller: PolCaller{contract: contract}, PolTransactor: PolTransactor{contract: contract}, PolFilterer: PolFilterer{contract: contract}}, nil +} + +// NewPolCaller creates a new read-only instance of Pol, bound to a specific deployed contract. +func NewPolCaller(address common.Address, caller bind.ContractCaller) (*PolCaller, error) { + contract, err := bindPol(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &PolCaller{contract: contract}, nil +} + +// NewPolTransactor creates a new write-only instance of Pol, bound to a specific deployed contract. +func NewPolTransactor(address common.Address, transactor bind.ContractTransactor) (*PolTransactor, error) { + contract, err := bindPol(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &PolTransactor{contract: contract}, nil +} + +// NewPolFilterer creates a new log filterer instance of Pol, bound to a specific deployed contract. +func NewPolFilterer(address common.Address, filterer bind.ContractFilterer) (*PolFilterer, error) { + contract, err := bindPol(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &PolFilterer{contract: contract}, nil +} + +// bindPol binds a generic wrapper to an already deployed contract. +func bindPol(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := PolMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Pol *PolRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Pol.Contract.PolCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Pol *PolRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Pol.Contract.PolTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Pol *PolRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Pol.Contract.PolTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Pol *PolCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Pol.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Pol *PolTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Pol.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Pol *PolTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Pol.Contract.contract.Transact(opts, method, params...) +} + +// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. +// +// Solidity: function allowance(address owner, address spender) view returns(uint256) +func (_Pol *PolCaller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) { + var out []interface{} + err := _Pol.contract.Call(opts, &out, "allowance", owner, spender) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. +// +// Solidity: function allowance(address owner, address spender) view returns(uint256) +func (_Pol *PolSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { + return _Pol.Contract.Allowance(&_Pol.CallOpts, owner, spender) +} + +// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. +// +// Solidity: function allowance(address owner, address spender) view returns(uint256) +func (_Pol *PolCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { + return _Pol.Contract.Allowance(&_Pol.CallOpts, owner, spender) +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address owner) view returns(uint256) +func (_Pol *PolCaller) BalanceOf(opts *bind.CallOpts, owner common.Address) (*big.Int, error) { + var out []interface{} + err := _Pol.contract.Call(opts, &out, "balanceOf", owner) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address owner) view returns(uint256) +func (_Pol *PolSession) BalanceOf(owner common.Address) (*big.Int, error) { + return _Pol.Contract.BalanceOf(&_Pol.CallOpts, owner) +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address owner) view returns(uint256) +func (_Pol *PolCallerSession) BalanceOf(owner common.Address) (*big.Int, error) { + return _Pol.Contract.BalanceOf(&_Pol.CallOpts, owner) +} + +// Decimals is a free data retrieval call binding the contract method 0x313ce567. +// +// Solidity: function decimals() view returns(uint8) +func (_Pol *PolCaller) Decimals(opts *bind.CallOpts) (uint8, error) { + var out []interface{} + err := _Pol.contract.Call(opts, &out, "decimals") + + if err != nil { + return *new(uint8), err + } + + out0 := *abi.ConvertType(out[0], new(uint8)).(*uint8) + + return out0, err + +} + +// Decimals is a free data retrieval call binding the contract method 0x313ce567. +// +// Solidity: function decimals() view returns(uint8) +func (_Pol *PolSession) Decimals() (uint8, error) { + return _Pol.Contract.Decimals(&_Pol.CallOpts) +} + +// Decimals is a free data retrieval call binding the contract method 0x313ce567. +// +// Solidity: function decimals() view returns(uint8) +func (_Pol *PolCallerSession) Decimals() (uint8, error) { + return _Pol.Contract.Decimals(&_Pol.CallOpts) +} + +// IsPauser is a free data retrieval call binding the contract method 0x46fbf68e. +// +// Solidity: function isPauser(address account) view returns(bool) +func (_Pol *PolCaller) IsPauser(opts *bind.CallOpts, account common.Address) (bool, error) { + var out []interface{} + err := _Pol.contract.Call(opts, &out, "isPauser", account) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// IsPauser is a free data retrieval call binding the contract method 0x46fbf68e. +// +// Solidity: function isPauser(address account) view returns(bool) +func (_Pol *PolSession) IsPauser(account common.Address) (bool, error) { + return _Pol.Contract.IsPauser(&_Pol.CallOpts, account) +} + +// IsPauser is a free data retrieval call binding the contract method 0x46fbf68e. +// +// Solidity: function isPauser(address account) view returns(bool) +func (_Pol *PolCallerSession) IsPauser(account common.Address) (bool, error) { + return _Pol.Contract.IsPauser(&_Pol.CallOpts, account) +} + +// Name is a free data retrieval call binding the contract method 0x06fdde03. +// +// Solidity: function name() view returns(string) +func (_Pol *PolCaller) Name(opts *bind.CallOpts) (string, error) { + var out []interface{} + err := _Pol.contract.Call(opts, &out, "name") + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// Name is a free data retrieval call binding the contract method 0x06fdde03. +// +// Solidity: function name() view returns(string) +func (_Pol *PolSession) Name() (string, error) { + return _Pol.Contract.Name(&_Pol.CallOpts) +} + +// Name is a free data retrieval call binding the contract method 0x06fdde03. +// +// Solidity: function name() view returns(string) +func (_Pol *PolCallerSession) Name() (string, error) { + return _Pol.Contract.Name(&_Pol.CallOpts) +} + +// Paused is a free data retrieval call binding the contract method 0x5c975abb. +// +// Solidity: function paused() view returns(bool) +func (_Pol *PolCaller) Paused(opts *bind.CallOpts) (bool, error) { + var out []interface{} + err := _Pol.contract.Call(opts, &out, "paused") + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// Paused is a free data retrieval call binding the contract method 0x5c975abb. +// +// Solidity: function paused() view returns(bool) +func (_Pol *PolSession) Paused() (bool, error) { + return _Pol.Contract.Paused(&_Pol.CallOpts) +} + +// Paused is a free data retrieval call binding the contract method 0x5c975abb. +// +// Solidity: function paused() view returns(bool) +func (_Pol *PolCallerSession) Paused() (bool, error) { + return _Pol.Contract.Paused(&_Pol.CallOpts) +} + +// Symbol is a free data retrieval call binding the contract method 0x95d89b41. +// +// Solidity: function symbol() view returns(string) +func (_Pol *PolCaller) Symbol(opts *bind.CallOpts) (string, error) { + var out []interface{} + err := _Pol.contract.Call(opts, &out, "symbol") + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// Symbol is a free data retrieval call binding the contract method 0x95d89b41. +// +// Solidity: function symbol() view returns(string) +func (_Pol *PolSession) Symbol() (string, error) { + return _Pol.Contract.Symbol(&_Pol.CallOpts) +} + +// Symbol is a free data retrieval call binding the contract method 0x95d89b41. +// +// Solidity: function symbol() view returns(string) +func (_Pol *PolCallerSession) Symbol() (string, error) { + return _Pol.Contract.Symbol(&_Pol.CallOpts) +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_Pol *PolCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _Pol.contract.Call(opts, &out, "totalSupply") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_Pol *PolSession) TotalSupply() (*big.Int, error) { + return _Pol.Contract.TotalSupply(&_Pol.CallOpts) +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_Pol *PolCallerSession) TotalSupply() (*big.Int, error) { + return _Pol.Contract.TotalSupply(&_Pol.CallOpts) +} + +// AddPauser is a paid mutator transaction binding the contract method 0x82dc1ec4. +// +// Solidity: function addPauser(address account) returns() +func (_Pol *PolTransactor) AddPauser(opts *bind.TransactOpts, account common.Address) (*types.Transaction, error) { + return _Pol.contract.Transact(opts, "addPauser", account) +} + +// AddPauser is a paid mutator transaction binding the contract method 0x82dc1ec4. +// +// Solidity: function addPauser(address account) returns() +func (_Pol *PolSession) AddPauser(account common.Address) (*types.Transaction, error) { + return _Pol.Contract.AddPauser(&_Pol.TransactOpts, account) +} + +// AddPauser is a paid mutator transaction binding the contract method 0x82dc1ec4. +// +// Solidity: function addPauser(address account) returns() +func (_Pol *PolTransactorSession) AddPauser(account common.Address) (*types.Transaction, error) { + return _Pol.Contract.AddPauser(&_Pol.TransactOpts, account) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address spender, uint256 value) returns(bool) +func (_Pol *PolTransactor) Approve(opts *bind.TransactOpts, spender common.Address, value *big.Int) (*types.Transaction, error) { + return _Pol.contract.Transact(opts, "approve", spender, value) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address spender, uint256 value) returns(bool) +func (_Pol *PolSession) Approve(spender common.Address, value *big.Int) (*types.Transaction, error) { + return _Pol.Contract.Approve(&_Pol.TransactOpts, spender, value) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address spender, uint256 value) returns(bool) +func (_Pol *PolTransactorSession) Approve(spender common.Address, value *big.Int) (*types.Transaction, error) { + return _Pol.Contract.Approve(&_Pol.TransactOpts, spender, value) +} + +// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. +// +// Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool success) +func (_Pol *PolTransactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { + return _Pol.contract.Transact(opts, "decreaseAllowance", spender, subtractedValue) +} + +// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. +// +// Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool success) +func (_Pol *PolSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { + return _Pol.Contract.DecreaseAllowance(&_Pol.TransactOpts, spender, subtractedValue) +} + +// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. +// +// Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool success) +func (_Pol *PolTransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { + return _Pol.Contract.DecreaseAllowance(&_Pol.TransactOpts, spender, subtractedValue) +} + +// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. +// +// Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool success) +func (_Pol *PolTransactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error) { + return _Pol.contract.Transact(opts, "increaseAllowance", spender, addedValue) +} + +// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. +// +// Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool success) +func (_Pol *PolSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) { + return _Pol.Contract.IncreaseAllowance(&_Pol.TransactOpts, spender, addedValue) +} + +// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. +// +// Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool success) +func (_Pol *PolTransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) { + return _Pol.Contract.IncreaseAllowance(&_Pol.TransactOpts, spender, addedValue) +} + +// Pause is a paid mutator transaction binding the contract method 0x8456cb59. +// +// Solidity: function pause() returns() +func (_Pol *PolTransactor) Pause(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Pol.contract.Transact(opts, "pause") +} + +// Pause is a paid mutator transaction binding the contract method 0x8456cb59. +// +// Solidity: function pause() returns() +func (_Pol *PolSession) Pause() (*types.Transaction, error) { + return _Pol.Contract.Pause(&_Pol.TransactOpts) +} + +// Pause is a paid mutator transaction binding the contract method 0x8456cb59. +// +// Solidity: function pause() returns() +func (_Pol *PolTransactorSession) Pause() (*types.Transaction, error) { + return _Pol.Contract.Pause(&_Pol.TransactOpts) +} + +// RenouncePauser is a paid mutator transaction binding the contract method 0x6ef8d66d. +// +// Solidity: function renouncePauser() returns() +func (_Pol *PolTransactor) RenouncePauser(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Pol.contract.Transact(opts, "renouncePauser") +} + +// RenouncePauser is a paid mutator transaction binding the contract method 0x6ef8d66d. +// +// Solidity: function renouncePauser() returns() +func (_Pol *PolSession) RenouncePauser() (*types.Transaction, error) { + return _Pol.Contract.RenouncePauser(&_Pol.TransactOpts) +} + +// RenouncePauser is a paid mutator transaction binding the contract method 0x6ef8d66d. +// +// Solidity: function renouncePauser() returns() +func (_Pol *PolTransactorSession) RenouncePauser() (*types.Transaction, error) { + return _Pol.Contract.RenouncePauser(&_Pol.TransactOpts) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address to, uint256 value) returns(bool) +func (_Pol *PolTransactor) Transfer(opts *bind.TransactOpts, to common.Address, value *big.Int) (*types.Transaction, error) { + return _Pol.contract.Transact(opts, "transfer", to, value) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address to, uint256 value) returns(bool) +func (_Pol *PolSession) Transfer(to common.Address, value *big.Int) (*types.Transaction, error) { + return _Pol.Contract.Transfer(&_Pol.TransactOpts, to, value) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address to, uint256 value) returns(bool) +func (_Pol *PolTransactorSession) Transfer(to common.Address, value *big.Int) (*types.Transaction, error) { + return _Pol.Contract.Transfer(&_Pol.TransactOpts, to, value) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address from, address to, uint256 value) returns(bool) +func (_Pol *PolTransactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, value *big.Int) (*types.Transaction, error) { + return _Pol.contract.Transact(opts, "transferFrom", from, to, value) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address from, address to, uint256 value) returns(bool) +func (_Pol *PolSession) TransferFrom(from common.Address, to common.Address, value *big.Int) (*types.Transaction, error) { + return _Pol.Contract.TransferFrom(&_Pol.TransactOpts, from, to, value) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address from, address to, uint256 value) returns(bool) +func (_Pol *PolTransactorSession) TransferFrom(from common.Address, to common.Address, value *big.Int) (*types.Transaction, error) { + return _Pol.Contract.TransferFrom(&_Pol.TransactOpts, from, to, value) +} + +// Unpause is a paid mutator transaction binding the contract method 0x3f4ba83a. +// +// Solidity: function unpause() returns() +func (_Pol *PolTransactor) Unpause(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Pol.contract.Transact(opts, "unpause") +} + +// Unpause is a paid mutator transaction binding the contract method 0x3f4ba83a. +// +// Solidity: function unpause() returns() +func (_Pol *PolSession) Unpause() (*types.Transaction, error) { + return _Pol.Contract.Unpause(&_Pol.TransactOpts) +} + +// Unpause is a paid mutator transaction binding the contract method 0x3f4ba83a. +// +// Solidity: function unpause() returns() +func (_Pol *PolTransactorSession) Unpause() (*types.Transaction, error) { + return _Pol.Contract.Unpause(&_Pol.TransactOpts) +} + +// PolApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the Pol contract. +type PolApprovalIterator struct { + Event *PolApproval // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PolApprovalIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PolApproval) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PolApproval) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PolApprovalIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolApprovalIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolApproval represents a Approval event raised by the Pol contract. +type PolApproval struct { + Owner common.Address + Spender common.Address + Value *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) +func (_Pol *PolFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*PolApprovalIterator, error) { + + var ownerRule []interface{} + for _, ownerItem := range owner { + ownerRule = append(ownerRule, ownerItem) + } + var spenderRule []interface{} + for _, spenderItem := range spender { + spenderRule = append(spenderRule, spenderItem) + } + + logs, sub, err := _Pol.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule) + if err != nil { + return nil, err + } + return &PolApprovalIterator{contract: _Pol.contract, event: "Approval", logs: logs, sub: sub}, nil +} + +// WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) +func (_Pol *PolFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *PolApproval, owner []common.Address, spender []common.Address) (event.Subscription, error) { + + var ownerRule []interface{} + for _, ownerItem := range owner { + ownerRule = append(ownerRule, ownerItem) + } + var spenderRule []interface{} + for _, spenderItem := range spender { + spenderRule = append(spenderRule, spenderItem) + } + + logs, sub, err := _Pol.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PolApproval) + if err := _Pol.contract.UnpackLog(event, "Approval", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) +func (_Pol *PolFilterer) ParseApproval(log types.Log) (*PolApproval, error) { + event := new(PolApproval) + if err := _Pol.contract.UnpackLog(event, "Approval", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PolPausedIterator is returned from FilterPaused and is used to iterate over the raw logs and unpacked data for Paused events raised by the Pol contract. +type PolPausedIterator struct { + Event *PolPaused // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PolPausedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PolPaused) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PolPaused) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PolPausedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolPausedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolPaused represents a Paused event raised by the Pol contract. +type PolPaused struct { + Account common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterPaused is a free log retrieval operation binding the contract event 0x62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a258. +// +// Solidity: event Paused(address account) +func (_Pol *PolFilterer) FilterPaused(opts *bind.FilterOpts) (*PolPausedIterator, error) { + + logs, sub, err := _Pol.contract.FilterLogs(opts, "Paused") + if err != nil { + return nil, err + } + return &PolPausedIterator{contract: _Pol.contract, event: "Paused", logs: logs, sub: sub}, nil +} + +// WatchPaused is a free log subscription operation binding the contract event 0x62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a258. +// +// Solidity: event Paused(address account) +func (_Pol *PolFilterer) WatchPaused(opts *bind.WatchOpts, sink chan<- *PolPaused) (event.Subscription, error) { + + logs, sub, err := _Pol.contract.WatchLogs(opts, "Paused") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PolPaused) + if err := _Pol.contract.UnpackLog(event, "Paused", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParsePaused is a log parse operation binding the contract event 0x62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a258. +// +// Solidity: event Paused(address account) +func (_Pol *PolFilterer) ParsePaused(log types.Log) (*PolPaused, error) { + event := new(PolPaused) + if err := _Pol.contract.UnpackLog(event, "Paused", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PolPauserAddedIterator is returned from FilterPauserAdded and is used to iterate over the raw logs and unpacked data for PauserAdded events raised by the Pol contract. +type PolPauserAddedIterator struct { + Event *PolPauserAdded // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PolPauserAddedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PolPauserAdded) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PolPauserAdded) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PolPauserAddedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolPauserAddedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolPauserAdded represents a PauserAdded event raised by the Pol contract. +type PolPauserAdded struct { + Account common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterPauserAdded is a free log retrieval operation binding the contract event 0x6719d08c1888103bea251a4ed56406bd0c3e69723c8a1686e017e7bbe159b6f8. +// +// Solidity: event PauserAdded(address indexed account) +func (_Pol *PolFilterer) FilterPauserAdded(opts *bind.FilterOpts, account []common.Address) (*PolPauserAddedIterator, error) { + + var accountRule []interface{} + for _, accountItem := range account { + accountRule = append(accountRule, accountItem) + } + + logs, sub, err := _Pol.contract.FilterLogs(opts, "PauserAdded", accountRule) + if err != nil { + return nil, err + } + return &PolPauserAddedIterator{contract: _Pol.contract, event: "PauserAdded", logs: logs, sub: sub}, nil +} + +// WatchPauserAdded is a free log subscription operation binding the contract event 0x6719d08c1888103bea251a4ed56406bd0c3e69723c8a1686e017e7bbe159b6f8. +// +// Solidity: event PauserAdded(address indexed account) +func (_Pol *PolFilterer) WatchPauserAdded(opts *bind.WatchOpts, sink chan<- *PolPauserAdded, account []common.Address) (event.Subscription, error) { + + var accountRule []interface{} + for _, accountItem := range account { + accountRule = append(accountRule, accountItem) + } + + logs, sub, err := _Pol.contract.WatchLogs(opts, "PauserAdded", accountRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PolPauserAdded) + if err := _Pol.contract.UnpackLog(event, "PauserAdded", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParsePauserAdded is a log parse operation binding the contract event 0x6719d08c1888103bea251a4ed56406bd0c3e69723c8a1686e017e7bbe159b6f8. +// +// Solidity: event PauserAdded(address indexed account) +func (_Pol *PolFilterer) ParsePauserAdded(log types.Log) (*PolPauserAdded, error) { + event := new(PolPauserAdded) + if err := _Pol.contract.UnpackLog(event, "PauserAdded", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PolPauserRemovedIterator is returned from FilterPauserRemoved and is used to iterate over the raw logs and unpacked data for PauserRemoved events raised by the Pol contract. +type PolPauserRemovedIterator struct { + Event *PolPauserRemoved // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PolPauserRemovedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PolPauserRemoved) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PolPauserRemoved) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PolPauserRemovedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolPauserRemovedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolPauserRemoved represents a PauserRemoved event raised by the Pol contract. +type PolPauserRemoved struct { + Account common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterPauserRemoved is a free log retrieval operation binding the contract event 0xcd265ebaf09df2871cc7bd4133404a235ba12eff2041bb89d9c714a2621c7c7e. +// +// Solidity: event PauserRemoved(address indexed account) +func (_Pol *PolFilterer) FilterPauserRemoved(opts *bind.FilterOpts, account []common.Address) (*PolPauserRemovedIterator, error) { + + var accountRule []interface{} + for _, accountItem := range account { + accountRule = append(accountRule, accountItem) + } + + logs, sub, err := _Pol.contract.FilterLogs(opts, "PauserRemoved", accountRule) + if err != nil { + return nil, err + } + return &PolPauserRemovedIterator{contract: _Pol.contract, event: "PauserRemoved", logs: logs, sub: sub}, nil +} + +// WatchPauserRemoved is a free log subscription operation binding the contract event 0xcd265ebaf09df2871cc7bd4133404a235ba12eff2041bb89d9c714a2621c7c7e. +// +// Solidity: event PauserRemoved(address indexed account) +func (_Pol *PolFilterer) WatchPauserRemoved(opts *bind.WatchOpts, sink chan<- *PolPauserRemoved, account []common.Address) (event.Subscription, error) { + + var accountRule []interface{} + for _, accountItem := range account { + accountRule = append(accountRule, accountItem) + } + + logs, sub, err := _Pol.contract.WatchLogs(opts, "PauserRemoved", accountRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PolPauserRemoved) + if err := _Pol.contract.UnpackLog(event, "PauserRemoved", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParsePauserRemoved is a log parse operation binding the contract event 0xcd265ebaf09df2871cc7bd4133404a235ba12eff2041bb89d9c714a2621c7c7e. +// +// Solidity: event PauserRemoved(address indexed account) +func (_Pol *PolFilterer) ParsePauserRemoved(log types.Log) (*PolPauserRemoved, error) { + event := new(PolPauserRemoved) + if err := _Pol.contract.UnpackLog(event, "PauserRemoved", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PolTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the Pol contract. +type PolTransferIterator struct { + Event *PolTransfer // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PolTransferIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PolTransfer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PolTransfer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PolTransferIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolTransferIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolTransfer represents a Transfer event raised by the Pol contract. +type PolTransfer struct { + From common.Address + To common.Address + Value *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_Pol *PolFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*PolTransferIterator, error) { + + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _Pol.contract.FilterLogs(opts, "Transfer", fromRule, toRule) + if err != nil { + return nil, err + } + return &PolTransferIterator{contract: _Pol.contract, event: "Transfer", logs: logs, sub: sub}, nil +} + +// WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_Pol *PolFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *PolTransfer, from []common.Address, to []common.Address) (event.Subscription, error) { + + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _Pol.contract.WatchLogs(opts, "Transfer", fromRule, toRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PolTransfer) + if err := _Pol.contract.UnpackLog(event, "Transfer", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_Pol *PolFilterer) ParseTransfer(log types.Log) (*PolTransfer, error) { + event := new(PolTransfer) + if err := _Pol.contract.UnpackLog(event, "Transfer", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PolUnpausedIterator is returned from FilterUnpaused and is used to iterate over the raw logs and unpacked data for Unpaused events raised by the Pol contract. +type PolUnpausedIterator struct { + Event *PolUnpaused // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PolUnpausedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PolUnpaused) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PolUnpaused) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PolUnpausedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolUnpausedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolUnpaused represents a Unpaused event raised by the Pol contract. +type PolUnpaused struct { + Account common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterUnpaused is a free log retrieval operation binding the contract event 0x5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa. +// +// Solidity: event Unpaused(address account) +func (_Pol *PolFilterer) FilterUnpaused(opts *bind.FilterOpts) (*PolUnpausedIterator, error) { + + logs, sub, err := _Pol.contract.FilterLogs(opts, "Unpaused") + if err != nil { + return nil, err + } + return &PolUnpausedIterator{contract: _Pol.contract, event: "Unpaused", logs: logs, sub: sub}, nil +} + +// WatchUnpaused is a free log subscription operation binding the contract event 0x5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa. +// +// Solidity: event Unpaused(address account) +func (_Pol *PolFilterer) WatchUnpaused(opts *bind.WatchOpts, sink chan<- *PolUnpaused) (event.Subscription, error) { + + logs, sub, err := _Pol.contract.WatchLogs(opts, "Unpaused") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PolUnpaused) + if err := _Pol.contract.UnpackLog(event, "Unpaused", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseUnpaused is a log parse operation binding the contract event 0x5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa. +// +// Solidity: event Unpaused(address account) +func (_Pol *PolFilterer) ParseUnpaused(log types.Log) (*PolUnpaused, error) { + event := new(PolUnpaused) + if err := _Pol.contract.UnpackLog(event, "Unpaused", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/etherman/smartcontracts/polygonrollupmanager/polygonrollupmanager.go b/etherman/smartcontracts/polygonrollupmanager/polygonrollupmanager.go new file mode 100644 index 0000000..b72b18e --- /dev/null +++ b/etherman/smartcontracts/polygonrollupmanager/polygonrollupmanager.go @@ -0,0 +1,5027 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package polygonrollupmanager + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// LegacyZKEVMStateVariablesPendingState is an auto generated low-level Go binding around an user-defined struct. +type LegacyZKEVMStateVariablesPendingState struct { + Timestamp uint64 + LastVerifiedBatch uint64 + ExitRoot [32]byte + StateRoot [32]byte +} + +// LegacyZKEVMStateVariablesSequencedBatchData is an auto generated low-level Go binding around an user-defined struct. +type LegacyZKEVMStateVariablesSequencedBatchData struct { + AccInputHash [32]byte + SequencedTimestamp uint64 + PreviousLastBatchSequenced uint64 +} + +// PolygonrollupmanagerMetaData contains all meta data concerning the Polygonrollupmanager contract. +var PolygonrollupmanagerMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[{\"internalType\":\"contractIPolygonZkEVMGlobalExitRoot\",\"name\":\"_globalExitRootManager\",\"type\":\"address\"},{\"internalType\":\"contractIERC20Upgradeable\",\"name\":\"_pol\",\"type\":\"address\"},{\"internalType\":\"contractIPolygonZkEVMBridge\",\"name\":\"_bridgeAddress\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"AccessControlOnlyCanRenounceRolesForSelf\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"AddressDoNotHaveRequiredRole\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"AllzkEVMSequencedBatchesMustBeVerified\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"BatchFeeOutOfRange\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ChainIDAlreadyExist\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ExceedMaxVerifyBatches\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FinalNumBatchBelowLastVerifiedBatch\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FinalNumBatchDoesNotMatchPendingState\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FinalPendingStateNumInvalid\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"HaltTimeoutNotExpired\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InitBatchMustMatchCurrentForkID\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InitNumBatchAboveLastVerifiedBatch\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InitNumBatchDoesNotMatchPendingState\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidProof\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidRangeBatchTimeTarget\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidRangeMultiplierBatchFee\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"MustSequenceSomeBatch\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NewAccInputHashDoesNotExist\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NewPendingStateTimeoutMustBeLower\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NewStateRootNotInsidePrime\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NewTrustedAggregatorTimeoutMustBeLower\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OldAccInputHashDoesNotExist\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OldStateRootDoesNotExist\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OnlyEmergencyState\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OnlyNotEmergencyState\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"PendingStateDoesNotExist\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"PendingStateInvalid\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"PendingStateNotConsolidable\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"RollupMustExist\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"RollupTypeDoesNotExist\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"RollupTypeObsolete\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SenderMustBeRollup\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"StoredRootMustBeDifferentThanNewRoot\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TrustedAggregatorTimeoutNotExpired\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"UpdateNotCompatible\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"UpdateToSameRollupTypeID\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint32\",\"name\":\"rollupID\",\"type\":\"uint32\"},{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"forkID\",\"type\":\"uint64\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"rollupAddress\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"chainID\",\"type\":\"uint64\"},{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"rollupCompatibilityID\",\"type\":\"uint8\"},{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"lastVerifiedBatchBeforeUpgrade\",\"type\":\"uint64\"}],\"name\":\"AddExistingRollup\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint32\",\"name\":\"rollupTypeID\",\"type\":\"uint32\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"consensusImplementation\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"verifier\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"forkID\",\"type\":\"uint64\"},{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"rollupCompatibilityID\",\"type\":\"uint8\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"genesis\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"description\",\"type\":\"string\"}],\"name\":\"AddNewRollupType\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint32\",\"name\":\"rollupID\",\"type\":\"uint32\"},{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"numBatch\",\"type\":\"uint64\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"stateRoot\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"exitRoot\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"pendingStateNum\",\"type\":\"uint64\"}],\"name\":\"ConsolidatePendingState\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint32\",\"name\":\"rollupID\",\"type\":\"uint32\"},{\"indexed\":false,\"internalType\":\"uint32\",\"name\":\"rollupTypeID\",\"type\":\"uint32\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"rollupAddress\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"chainID\",\"type\":\"uint64\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"gasTokenAddress\",\"type\":\"address\"}],\"name\":\"CreateNewRollup\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[],\"name\":\"EmergencyStateActivated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[],\"name\":\"EmergencyStateDeactivated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint32\",\"name\":\"rollupTypeID\",\"type\":\"uint32\"}],\"name\":\"ObsoleteRollupType\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint32\",\"name\":\"rollupID\",\"type\":\"uint32\"},{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"lastBatchSequenced\",\"type\":\"uint64\"}],\"name\":\"OnSequenceBatches\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint32\",\"name\":\"rollupID\",\"type\":\"uint32\"},{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"numBatch\",\"type\":\"uint64\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"stateRoot\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"exitRoot\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"aggregator\",\"type\":\"address\"}],\"name\":\"OverridePendingState\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"storedStateRoot\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"provedStateRoot\",\"type\":\"bytes32\"}],\"name\":\"ProveNonDeterministicPendingState\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"previousAdminRole\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"newAdminRole\",\"type\":\"bytes32\"}],\"name\":\"RoleAdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"RoleGranted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"RoleRevoked\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"newBatchFee\",\"type\":\"uint256\"}],\"name\":\"SetBatchFee\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint16\",\"name\":\"newMultiplierBatchFee\",\"type\":\"uint16\"}],\"name\":\"SetMultiplierBatchFee\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"newPendingStateTimeout\",\"type\":\"uint64\"}],\"name\":\"SetPendingStateTimeout\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newTrustedAggregator\",\"type\":\"address\"}],\"name\":\"SetTrustedAggregator\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"newTrustedAggregatorTimeout\",\"type\":\"uint64\"}],\"name\":\"SetTrustedAggregatorTimeout\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"newVerifyBatchTimeTarget\",\"type\":\"uint64\"}],\"name\":\"SetVerifyBatchTimeTarget\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint32\",\"name\":\"rollupID\",\"type\":\"uint32\"},{\"indexed\":false,\"internalType\":\"uint32\",\"name\":\"newRollupTypeID\",\"type\":\"uint32\"},{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"lastVerifiedBatchBeforeUpgrade\",\"type\":\"uint64\"}],\"name\":\"UpdateRollup\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint32\",\"name\":\"rollupID\",\"type\":\"uint32\"},{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"numBatch\",\"type\":\"uint64\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"stateRoot\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"exitRoot\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"aggregator\",\"type\":\"address\"}],\"name\":\"VerifyBatches\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint32\",\"name\":\"rollupID\",\"type\":\"uint32\"},{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"numBatch\",\"type\":\"uint64\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"stateRoot\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"exitRoot\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"aggregator\",\"type\":\"address\"}],\"name\":\"VerifyBatchesTrustedAggregator\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"DEFAULT_ADMIN_ROLE\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"activateEmergencyState\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractIPolygonRollupBase\",\"name\":\"rollupAddress\",\"type\":\"address\"},{\"internalType\":\"contractIVerifierRollup\",\"name\":\"verifier\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"forkID\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"chainID\",\"type\":\"uint64\"},{\"internalType\":\"bytes32\",\"name\":\"genesis\",\"type\":\"bytes32\"},{\"internalType\":\"uint8\",\"name\":\"rollupCompatibilityID\",\"type\":\"uint8\"}],\"name\":\"addExistingRollup\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"consensusImplementation\",\"type\":\"address\"},{\"internalType\":\"contractIVerifierRollup\",\"name\":\"verifier\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"forkID\",\"type\":\"uint64\"},{\"internalType\":\"uint8\",\"name\":\"rollupCompatibilityID\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"genesis\",\"type\":\"bytes32\"},{\"internalType\":\"string\",\"name\":\"description\",\"type\":\"string\"}],\"name\":\"addNewRollupType\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"bridgeAddress\",\"outputs\":[{\"internalType\":\"contractIPolygonZkEVMBridge\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"calculateRewardPerBatch\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint64\",\"name\":\"chainID\",\"type\":\"uint64\"}],\"name\":\"chainIDToRollupID\",\"outputs\":[{\"internalType\":\"uint32\",\"name\":\"rollupID\",\"type\":\"uint32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"rollupID\",\"type\":\"uint32\"},{\"internalType\":\"uint64\",\"name\":\"pendingStateNum\",\"type\":\"uint64\"}],\"name\":\"consolidatePendingState\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"rollupTypeID\",\"type\":\"uint32\"},{\"internalType\":\"uint64\",\"name\":\"chainID\",\"type\":\"uint64\"},{\"internalType\":\"address\",\"name\":\"admin\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"sequencer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"gasTokenAddress\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"sequencerURL\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"networkName\",\"type\":\"string\"}],\"name\":\"createNewRollup\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"deactivateEmergencyState\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getBatchFee\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getForcedBatchFee\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"rollupID\",\"type\":\"uint32\"},{\"internalType\":\"uint64\",\"name\":\"initNumBatch\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"finalNewBatch\",\"type\":\"uint64\"},{\"internalType\":\"bytes32\",\"name\":\"newLocalExitRoot\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"oldStateRoot\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"newStateRoot\",\"type\":\"bytes32\"}],\"name\":\"getInputSnarkBytes\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"rollupID\",\"type\":\"uint32\"}],\"name\":\"getLastVerifiedBatch\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"}],\"name\":\"getRoleAdmin\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"rollupID\",\"type\":\"uint32\"},{\"internalType\":\"uint64\",\"name\":\"batchNum\",\"type\":\"uint64\"}],\"name\":\"getRollupBatchNumToStateRoot\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getRollupExitRoot\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"rollupID\",\"type\":\"uint32\"},{\"internalType\":\"uint64\",\"name\":\"batchNum\",\"type\":\"uint64\"}],\"name\":\"getRollupPendingStateTransitions\",\"outputs\":[{\"components\":[{\"internalType\":\"uint64\",\"name\":\"timestamp\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"lastVerifiedBatch\",\"type\":\"uint64\"},{\"internalType\":\"bytes32\",\"name\":\"exitRoot\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"stateRoot\",\"type\":\"bytes32\"}],\"internalType\":\"structLegacyZKEVMStateVariables.PendingState\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"rollupID\",\"type\":\"uint32\"},{\"internalType\":\"uint64\",\"name\":\"batchNum\",\"type\":\"uint64\"}],\"name\":\"getRollupSequencedBatches\",\"outputs\":[{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"accInputHash\",\"type\":\"bytes32\"},{\"internalType\":\"uint64\",\"name\":\"sequencedTimestamp\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"previousLastBatchSequenced\",\"type\":\"uint64\"}],\"internalType\":\"structLegacyZKEVMStateVariables.SequencedBatchData\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"globalExitRootManager\",\"outputs\":[{\"internalType\":\"contractIPolygonZkEVMGlobalExitRoot\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"grantRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"hasRole\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"trustedAggregator\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"_pendingStateTimeout\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"_trustedAggregatorTimeout\",\"type\":\"uint64\"},{\"internalType\":\"address\",\"name\":\"admin\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"timelock\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"emergencyCouncil\",\"type\":\"address\"},{\"internalType\":\"contractPolygonZkEVMV2Existent\",\"name\":\"polygonZkEVM\",\"type\":\"address\"},{\"internalType\":\"contractIVerifierRollup\",\"name\":\"zkEVMVerifier\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"zkEVMForkID\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"zkEVMChainID\",\"type\":\"uint64\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"isEmergencyState\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"rollupID\",\"type\":\"uint32\"},{\"internalType\":\"uint64\",\"name\":\"pendingStateNum\",\"type\":\"uint64\"}],\"name\":\"isPendingStateConsolidable\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"lastAggregationTimestamp\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"multiplierBatchFee\",\"outputs\":[{\"internalType\":\"uint16\",\"name\":\"\",\"type\":\"uint16\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"rollupTypeID\",\"type\":\"uint32\"}],\"name\":\"obsoleteRollupType\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint64\",\"name\":\"newSequencedBatches\",\"type\":\"uint64\"},{\"internalType\":\"bytes32\",\"name\":\"newAccInputHash\",\"type\":\"bytes32\"}],\"name\":\"onSequenceBatches\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"rollupID\",\"type\":\"uint32\"},{\"internalType\":\"uint64\",\"name\":\"initPendingStateNum\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"finalPendingStateNum\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"initNumBatch\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"finalNewBatch\",\"type\":\"uint64\"},{\"internalType\":\"bytes32\",\"name\":\"newLocalExitRoot\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"newStateRoot\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32[24]\",\"name\":\"proof\",\"type\":\"bytes32[24]\"}],\"name\":\"overridePendingState\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pendingStateTimeout\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pol\",\"outputs\":[{\"internalType\":\"contractIERC20Upgradeable\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"rollupID\",\"type\":\"uint32\"},{\"internalType\":\"uint64\",\"name\":\"initPendingStateNum\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"finalPendingStateNum\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"initNumBatch\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"finalNewBatch\",\"type\":\"uint64\"},{\"internalType\":\"bytes32\",\"name\":\"newLocalExitRoot\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"newStateRoot\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32[24]\",\"name\":\"proof\",\"type\":\"bytes32[24]\"}],\"name\":\"proveNonDeterministicPendingState\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"renounceRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"revokeRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"rollupAddress\",\"type\":\"address\"}],\"name\":\"rollupAddressToID\",\"outputs\":[{\"internalType\":\"uint32\",\"name\":\"rollupID\",\"type\":\"uint32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"rollupCount\",\"outputs\":[{\"internalType\":\"uint32\",\"name\":\"\",\"type\":\"uint32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"rollupID\",\"type\":\"uint32\"}],\"name\":\"rollupIDToRollupData\",\"outputs\":[{\"internalType\":\"contractIPolygonRollupBase\",\"name\":\"rollupContract\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"chainID\",\"type\":\"uint64\"},{\"internalType\":\"contractIVerifierRollup\",\"name\":\"verifier\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"forkID\",\"type\":\"uint64\"},{\"internalType\":\"bytes32\",\"name\":\"lastLocalExitRoot\",\"type\":\"bytes32\"},{\"internalType\":\"uint64\",\"name\":\"lastBatchSequenced\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"lastVerifiedBatch\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"lastPendingState\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"lastPendingStateConsolidated\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"lastVerifiedBatchBeforeUpgrade\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"rollupTypeID\",\"type\":\"uint64\"},{\"internalType\":\"uint8\",\"name\":\"rollupCompatibilityID\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"rollupTypeCount\",\"outputs\":[{\"internalType\":\"uint32\",\"name\":\"\",\"type\":\"uint32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"rollupTypeID\",\"type\":\"uint32\"}],\"name\":\"rollupTypeMap\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"consensusImplementation\",\"type\":\"address\"},{\"internalType\":\"contractIVerifierRollup\",\"name\":\"verifier\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"forkID\",\"type\":\"uint64\"},{\"internalType\":\"uint8\",\"name\":\"rollupCompatibilityID\",\"type\":\"uint8\"},{\"internalType\":\"bool\",\"name\":\"obsolete\",\"type\":\"bool\"},{\"internalType\":\"bytes32\",\"name\":\"genesis\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"newBatchFee\",\"type\":\"uint256\"}],\"name\":\"setBatchFee\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint16\",\"name\":\"newMultiplierBatchFee\",\"type\":\"uint16\"}],\"name\":\"setMultiplierBatchFee\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint64\",\"name\":\"newPendingStateTimeout\",\"type\":\"uint64\"}],\"name\":\"setPendingStateTimeout\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint64\",\"name\":\"newTrustedAggregatorTimeout\",\"type\":\"uint64\"}],\"name\":\"setTrustedAggregatorTimeout\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint64\",\"name\":\"newVerifyBatchTimeTarget\",\"type\":\"uint64\"}],\"name\":\"setVerifyBatchTimeTarget\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalSequencedBatches\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalVerifiedBatches\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"trustedAggregatorTimeout\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractITransparentUpgradeableProxy\",\"name\":\"rollupContract\",\"type\":\"address\"},{\"internalType\":\"uint32\",\"name\":\"newRollupTypeID\",\"type\":\"uint32\"},{\"internalType\":\"bytes\",\"name\":\"upgradeData\",\"type\":\"bytes\"}],\"name\":\"updateRollup\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"verifyBatchTimeTarget\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"rollupID\",\"type\":\"uint32\"},{\"internalType\":\"uint64\",\"name\":\"pendingStateNum\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"initNumBatch\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"finalNewBatch\",\"type\":\"uint64\"},{\"internalType\":\"bytes32\",\"name\":\"newLocalExitRoot\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"newStateRoot\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"beneficiary\",\"type\":\"address\"},{\"internalType\":\"bytes32[24]\",\"name\":\"proof\",\"type\":\"bytes32[24]\"}],\"name\":\"verifyBatches\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"rollupID\",\"type\":\"uint32\"},{\"internalType\":\"uint64\",\"name\":\"pendingStateNum\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"initNumBatch\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"finalNewBatch\",\"type\":\"uint64\"},{\"internalType\":\"bytes32\",\"name\":\"newLocalExitRoot\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"newStateRoot\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"beneficiary\",\"type\":\"address\"},{\"internalType\":\"bytes32[24]\",\"name\":\"proof\",\"type\":\"bytes32[24]\"}],\"name\":\"verifyBatchesTrustedAggregator\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", + Bin: "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", +} + +// PolygonrollupmanagerABI is the input ABI used to generate the binding from. +// Deprecated: Use PolygonrollupmanagerMetaData.ABI instead. +var PolygonrollupmanagerABI = PolygonrollupmanagerMetaData.ABI + +// PolygonrollupmanagerBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use PolygonrollupmanagerMetaData.Bin instead. +var PolygonrollupmanagerBin = PolygonrollupmanagerMetaData.Bin + +// DeployPolygonrollupmanager deploys a new Ethereum contract, binding an instance of Polygonrollupmanager to it. +func DeployPolygonrollupmanager(auth *bind.TransactOpts, backend bind.ContractBackend, _globalExitRootManager common.Address, _pol common.Address, _bridgeAddress common.Address) (common.Address, *types.Transaction, *Polygonrollupmanager, error) { + parsed, err := PolygonrollupmanagerMetaData.GetAbi() + if err != nil { + return common.Address{}, nil, nil, err + } + if parsed == nil { + return common.Address{}, nil, nil, errors.New("GetABI returned nil") + } + + address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex(PolygonrollupmanagerBin), backend, _globalExitRootManager, _pol, _bridgeAddress) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &Polygonrollupmanager{PolygonrollupmanagerCaller: PolygonrollupmanagerCaller{contract: contract}, PolygonrollupmanagerTransactor: PolygonrollupmanagerTransactor{contract: contract}, PolygonrollupmanagerFilterer: PolygonrollupmanagerFilterer{contract: contract}}, nil +} + +// Polygonrollupmanager is an auto generated Go binding around an Ethereum contract. +type Polygonrollupmanager struct { + PolygonrollupmanagerCaller // Read-only binding to the contract + PolygonrollupmanagerTransactor // Write-only binding to the contract + PolygonrollupmanagerFilterer // Log filterer for contract events +} + +// PolygonrollupmanagerCaller is an auto generated read-only Go binding around an Ethereum contract. +type PolygonrollupmanagerCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// PolygonrollupmanagerTransactor is an auto generated write-only Go binding around an Ethereum contract. +type PolygonrollupmanagerTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// PolygonrollupmanagerFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type PolygonrollupmanagerFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// PolygonrollupmanagerSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type PolygonrollupmanagerSession struct { + Contract *Polygonrollupmanager // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// PolygonrollupmanagerCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type PolygonrollupmanagerCallerSession struct { + Contract *PolygonrollupmanagerCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// PolygonrollupmanagerTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type PolygonrollupmanagerTransactorSession struct { + Contract *PolygonrollupmanagerTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// PolygonrollupmanagerRaw is an auto generated low-level Go binding around an Ethereum contract. +type PolygonrollupmanagerRaw struct { + Contract *Polygonrollupmanager // Generic contract binding to access the raw methods on +} + +// PolygonrollupmanagerCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type PolygonrollupmanagerCallerRaw struct { + Contract *PolygonrollupmanagerCaller // Generic read-only contract binding to access the raw methods on +} + +// PolygonrollupmanagerTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type PolygonrollupmanagerTransactorRaw struct { + Contract *PolygonrollupmanagerTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewPolygonrollupmanager creates a new instance of Polygonrollupmanager, bound to a specific deployed contract. +func NewPolygonrollupmanager(address common.Address, backend bind.ContractBackend) (*Polygonrollupmanager, error) { + contract, err := bindPolygonrollupmanager(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &Polygonrollupmanager{PolygonrollupmanagerCaller: PolygonrollupmanagerCaller{contract: contract}, PolygonrollupmanagerTransactor: PolygonrollupmanagerTransactor{contract: contract}, PolygonrollupmanagerFilterer: PolygonrollupmanagerFilterer{contract: contract}}, nil +} + +// NewPolygonrollupmanagerCaller creates a new read-only instance of Polygonrollupmanager, bound to a specific deployed contract. +func NewPolygonrollupmanagerCaller(address common.Address, caller bind.ContractCaller) (*PolygonrollupmanagerCaller, error) { + contract, err := bindPolygonrollupmanager(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &PolygonrollupmanagerCaller{contract: contract}, nil +} + +// NewPolygonrollupmanagerTransactor creates a new write-only instance of Polygonrollupmanager, bound to a specific deployed contract. +func NewPolygonrollupmanagerTransactor(address common.Address, transactor bind.ContractTransactor) (*PolygonrollupmanagerTransactor, error) { + contract, err := bindPolygonrollupmanager(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &PolygonrollupmanagerTransactor{contract: contract}, nil +} + +// NewPolygonrollupmanagerFilterer creates a new log filterer instance of Polygonrollupmanager, bound to a specific deployed contract. +func NewPolygonrollupmanagerFilterer(address common.Address, filterer bind.ContractFilterer) (*PolygonrollupmanagerFilterer, error) { + contract, err := bindPolygonrollupmanager(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &PolygonrollupmanagerFilterer{contract: contract}, nil +} + +// bindPolygonrollupmanager binds a generic wrapper to an already deployed contract. +func bindPolygonrollupmanager(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := PolygonrollupmanagerMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Polygonrollupmanager *PolygonrollupmanagerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Polygonrollupmanager.Contract.PolygonrollupmanagerCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Polygonrollupmanager *PolygonrollupmanagerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Polygonrollupmanager.Contract.PolygonrollupmanagerTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Polygonrollupmanager *PolygonrollupmanagerRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Polygonrollupmanager.Contract.PolygonrollupmanagerTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Polygonrollupmanager *PolygonrollupmanagerCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Polygonrollupmanager.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Polygonrollupmanager *PolygonrollupmanagerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Polygonrollupmanager.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Polygonrollupmanager *PolygonrollupmanagerTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Polygonrollupmanager.Contract.contract.Transact(opts, method, params...) +} + +// DEFAULTADMINROLE is a free data retrieval call binding the contract method 0xa217fddf. +// +// Solidity: function DEFAULT_ADMIN_ROLE() view returns(bytes32) +func (_Polygonrollupmanager *PolygonrollupmanagerCaller) DEFAULTADMINROLE(opts *bind.CallOpts) ([32]byte, error) { + var out []interface{} + err := _Polygonrollupmanager.contract.Call(opts, &out, "DEFAULT_ADMIN_ROLE") + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// DEFAULTADMINROLE is a free data retrieval call binding the contract method 0xa217fddf. +// +// Solidity: function DEFAULT_ADMIN_ROLE() view returns(bytes32) +func (_Polygonrollupmanager *PolygonrollupmanagerSession) DEFAULTADMINROLE() ([32]byte, error) { + return _Polygonrollupmanager.Contract.DEFAULTADMINROLE(&_Polygonrollupmanager.CallOpts) +} + +// DEFAULTADMINROLE is a free data retrieval call binding the contract method 0xa217fddf. +// +// Solidity: function DEFAULT_ADMIN_ROLE() view returns(bytes32) +func (_Polygonrollupmanager *PolygonrollupmanagerCallerSession) DEFAULTADMINROLE() ([32]byte, error) { + return _Polygonrollupmanager.Contract.DEFAULTADMINROLE(&_Polygonrollupmanager.CallOpts) +} + +// BridgeAddress is a free data retrieval call binding the contract method 0xa3c573eb. +// +// Solidity: function bridgeAddress() view returns(address) +func (_Polygonrollupmanager *PolygonrollupmanagerCaller) BridgeAddress(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Polygonrollupmanager.contract.Call(opts, &out, "bridgeAddress") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// BridgeAddress is a free data retrieval call binding the contract method 0xa3c573eb. +// +// Solidity: function bridgeAddress() view returns(address) +func (_Polygonrollupmanager *PolygonrollupmanagerSession) BridgeAddress() (common.Address, error) { + return _Polygonrollupmanager.Contract.BridgeAddress(&_Polygonrollupmanager.CallOpts) +} + +// BridgeAddress is a free data retrieval call binding the contract method 0xa3c573eb. +// +// Solidity: function bridgeAddress() view returns(address) +func (_Polygonrollupmanager *PolygonrollupmanagerCallerSession) BridgeAddress() (common.Address, error) { + return _Polygonrollupmanager.Contract.BridgeAddress(&_Polygonrollupmanager.CallOpts) +} + +// CalculateRewardPerBatch is a free data retrieval call binding the contract method 0x99f5634e. +// +// Solidity: function calculateRewardPerBatch() view returns(uint256) +func (_Polygonrollupmanager *PolygonrollupmanagerCaller) CalculateRewardPerBatch(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _Polygonrollupmanager.contract.Call(opts, &out, "calculateRewardPerBatch") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// CalculateRewardPerBatch is a free data retrieval call binding the contract method 0x99f5634e. +// +// Solidity: function calculateRewardPerBatch() view returns(uint256) +func (_Polygonrollupmanager *PolygonrollupmanagerSession) CalculateRewardPerBatch() (*big.Int, error) { + return _Polygonrollupmanager.Contract.CalculateRewardPerBatch(&_Polygonrollupmanager.CallOpts) +} + +// CalculateRewardPerBatch is a free data retrieval call binding the contract method 0x99f5634e. +// +// Solidity: function calculateRewardPerBatch() view returns(uint256) +func (_Polygonrollupmanager *PolygonrollupmanagerCallerSession) CalculateRewardPerBatch() (*big.Int, error) { + return _Polygonrollupmanager.Contract.CalculateRewardPerBatch(&_Polygonrollupmanager.CallOpts) +} + +// ChainIDToRollupID is a free data retrieval call binding the contract method 0x7fb6e76a. +// +// Solidity: function chainIDToRollupID(uint64 chainID) view returns(uint32 rollupID) +func (_Polygonrollupmanager *PolygonrollupmanagerCaller) ChainIDToRollupID(opts *bind.CallOpts, chainID uint64) (uint32, error) { + var out []interface{} + err := _Polygonrollupmanager.contract.Call(opts, &out, "chainIDToRollupID", chainID) + + if err != nil { + return *new(uint32), err + } + + out0 := *abi.ConvertType(out[0], new(uint32)).(*uint32) + + return out0, err + +} + +// ChainIDToRollupID is a free data retrieval call binding the contract method 0x7fb6e76a. +// +// Solidity: function chainIDToRollupID(uint64 chainID) view returns(uint32 rollupID) +func (_Polygonrollupmanager *PolygonrollupmanagerSession) ChainIDToRollupID(chainID uint64) (uint32, error) { + return _Polygonrollupmanager.Contract.ChainIDToRollupID(&_Polygonrollupmanager.CallOpts, chainID) +} + +// ChainIDToRollupID is a free data retrieval call binding the contract method 0x7fb6e76a. +// +// Solidity: function chainIDToRollupID(uint64 chainID) view returns(uint32 rollupID) +func (_Polygonrollupmanager *PolygonrollupmanagerCallerSession) ChainIDToRollupID(chainID uint64) (uint32, error) { + return _Polygonrollupmanager.Contract.ChainIDToRollupID(&_Polygonrollupmanager.CallOpts, chainID) +} + +// GetBatchFee is a free data retrieval call binding the contract method 0x477fa270. +// +// Solidity: function getBatchFee() view returns(uint256) +func (_Polygonrollupmanager *PolygonrollupmanagerCaller) GetBatchFee(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _Polygonrollupmanager.contract.Call(opts, &out, "getBatchFee") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// GetBatchFee is a free data retrieval call binding the contract method 0x477fa270. +// +// Solidity: function getBatchFee() view returns(uint256) +func (_Polygonrollupmanager *PolygonrollupmanagerSession) GetBatchFee() (*big.Int, error) { + return _Polygonrollupmanager.Contract.GetBatchFee(&_Polygonrollupmanager.CallOpts) +} + +// GetBatchFee is a free data retrieval call binding the contract method 0x477fa270. +// +// Solidity: function getBatchFee() view returns(uint256) +func (_Polygonrollupmanager *PolygonrollupmanagerCallerSession) GetBatchFee() (*big.Int, error) { + return _Polygonrollupmanager.Contract.GetBatchFee(&_Polygonrollupmanager.CallOpts) +} + +// GetForcedBatchFee is a free data retrieval call binding the contract method 0x60469169. +// +// Solidity: function getForcedBatchFee() view returns(uint256) +func (_Polygonrollupmanager *PolygonrollupmanagerCaller) GetForcedBatchFee(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _Polygonrollupmanager.contract.Call(opts, &out, "getForcedBatchFee") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// GetForcedBatchFee is a free data retrieval call binding the contract method 0x60469169. +// +// Solidity: function getForcedBatchFee() view returns(uint256) +func (_Polygonrollupmanager *PolygonrollupmanagerSession) GetForcedBatchFee() (*big.Int, error) { + return _Polygonrollupmanager.Contract.GetForcedBatchFee(&_Polygonrollupmanager.CallOpts) +} + +// GetForcedBatchFee is a free data retrieval call binding the contract method 0x60469169. +// +// Solidity: function getForcedBatchFee() view returns(uint256) +func (_Polygonrollupmanager *PolygonrollupmanagerCallerSession) GetForcedBatchFee() (*big.Int, error) { + return _Polygonrollupmanager.Contract.GetForcedBatchFee(&_Polygonrollupmanager.CallOpts) +} + +// GetInputSnarkBytes is a free data retrieval call binding the contract method 0x7975fcfe. +// +// Solidity: function getInputSnarkBytes(uint32 rollupID, uint64 initNumBatch, uint64 finalNewBatch, bytes32 newLocalExitRoot, bytes32 oldStateRoot, bytes32 newStateRoot) view returns(bytes) +func (_Polygonrollupmanager *PolygonrollupmanagerCaller) GetInputSnarkBytes(opts *bind.CallOpts, rollupID uint32, initNumBatch uint64, finalNewBatch uint64, newLocalExitRoot [32]byte, oldStateRoot [32]byte, newStateRoot [32]byte) ([]byte, error) { + var out []interface{} + err := _Polygonrollupmanager.contract.Call(opts, &out, "getInputSnarkBytes", rollupID, initNumBatch, finalNewBatch, newLocalExitRoot, oldStateRoot, newStateRoot) + + if err != nil { + return *new([]byte), err + } + + out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte) + + return out0, err + +} + +// GetInputSnarkBytes is a free data retrieval call binding the contract method 0x7975fcfe. +// +// Solidity: function getInputSnarkBytes(uint32 rollupID, uint64 initNumBatch, uint64 finalNewBatch, bytes32 newLocalExitRoot, bytes32 oldStateRoot, bytes32 newStateRoot) view returns(bytes) +func (_Polygonrollupmanager *PolygonrollupmanagerSession) GetInputSnarkBytes(rollupID uint32, initNumBatch uint64, finalNewBatch uint64, newLocalExitRoot [32]byte, oldStateRoot [32]byte, newStateRoot [32]byte) ([]byte, error) { + return _Polygonrollupmanager.Contract.GetInputSnarkBytes(&_Polygonrollupmanager.CallOpts, rollupID, initNumBatch, finalNewBatch, newLocalExitRoot, oldStateRoot, newStateRoot) +} + +// GetInputSnarkBytes is a free data retrieval call binding the contract method 0x7975fcfe. +// +// Solidity: function getInputSnarkBytes(uint32 rollupID, uint64 initNumBatch, uint64 finalNewBatch, bytes32 newLocalExitRoot, bytes32 oldStateRoot, bytes32 newStateRoot) view returns(bytes) +func (_Polygonrollupmanager *PolygonrollupmanagerCallerSession) GetInputSnarkBytes(rollupID uint32, initNumBatch uint64, finalNewBatch uint64, newLocalExitRoot [32]byte, oldStateRoot [32]byte, newStateRoot [32]byte) ([]byte, error) { + return _Polygonrollupmanager.Contract.GetInputSnarkBytes(&_Polygonrollupmanager.CallOpts, rollupID, initNumBatch, finalNewBatch, newLocalExitRoot, oldStateRoot, newStateRoot) +} + +// GetLastVerifiedBatch is a free data retrieval call binding the contract method 0x11f6b287. +// +// Solidity: function getLastVerifiedBatch(uint32 rollupID) view returns(uint64) +func (_Polygonrollupmanager *PolygonrollupmanagerCaller) GetLastVerifiedBatch(opts *bind.CallOpts, rollupID uint32) (uint64, error) { + var out []interface{} + err := _Polygonrollupmanager.contract.Call(opts, &out, "getLastVerifiedBatch", rollupID) + + if err != nil { + return *new(uint64), err + } + + out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64) + + return out0, err + +} + +// GetLastVerifiedBatch is a free data retrieval call binding the contract method 0x11f6b287. +// +// Solidity: function getLastVerifiedBatch(uint32 rollupID) view returns(uint64) +func (_Polygonrollupmanager *PolygonrollupmanagerSession) GetLastVerifiedBatch(rollupID uint32) (uint64, error) { + return _Polygonrollupmanager.Contract.GetLastVerifiedBatch(&_Polygonrollupmanager.CallOpts, rollupID) +} + +// GetLastVerifiedBatch is a free data retrieval call binding the contract method 0x11f6b287. +// +// Solidity: function getLastVerifiedBatch(uint32 rollupID) view returns(uint64) +func (_Polygonrollupmanager *PolygonrollupmanagerCallerSession) GetLastVerifiedBatch(rollupID uint32) (uint64, error) { + return _Polygonrollupmanager.Contract.GetLastVerifiedBatch(&_Polygonrollupmanager.CallOpts, rollupID) +} + +// GetRoleAdmin is a free data retrieval call binding the contract method 0x248a9ca3. +// +// Solidity: function getRoleAdmin(bytes32 role) view returns(bytes32) +func (_Polygonrollupmanager *PolygonrollupmanagerCaller) GetRoleAdmin(opts *bind.CallOpts, role [32]byte) ([32]byte, error) { + var out []interface{} + err := _Polygonrollupmanager.contract.Call(opts, &out, "getRoleAdmin", role) + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// GetRoleAdmin is a free data retrieval call binding the contract method 0x248a9ca3. +// +// Solidity: function getRoleAdmin(bytes32 role) view returns(bytes32) +func (_Polygonrollupmanager *PolygonrollupmanagerSession) GetRoleAdmin(role [32]byte) ([32]byte, error) { + return _Polygonrollupmanager.Contract.GetRoleAdmin(&_Polygonrollupmanager.CallOpts, role) +} + +// GetRoleAdmin is a free data retrieval call binding the contract method 0x248a9ca3. +// +// Solidity: function getRoleAdmin(bytes32 role) view returns(bytes32) +func (_Polygonrollupmanager *PolygonrollupmanagerCallerSession) GetRoleAdmin(role [32]byte) ([32]byte, error) { + return _Polygonrollupmanager.Contract.GetRoleAdmin(&_Polygonrollupmanager.CallOpts, role) +} + +// GetRollupBatchNumToStateRoot is a free data retrieval call binding the contract method 0x55a71ee0. +// +// Solidity: function getRollupBatchNumToStateRoot(uint32 rollupID, uint64 batchNum) view returns(bytes32) +func (_Polygonrollupmanager *PolygonrollupmanagerCaller) GetRollupBatchNumToStateRoot(opts *bind.CallOpts, rollupID uint32, batchNum uint64) ([32]byte, error) { + var out []interface{} + err := _Polygonrollupmanager.contract.Call(opts, &out, "getRollupBatchNumToStateRoot", rollupID, batchNum) + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// GetRollupBatchNumToStateRoot is a free data retrieval call binding the contract method 0x55a71ee0. +// +// Solidity: function getRollupBatchNumToStateRoot(uint32 rollupID, uint64 batchNum) view returns(bytes32) +func (_Polygonrollupmanager *PolygonrollupmanagerSession) GetRollupBatchNumToStateRoot(rollupID uint32, batchNum uint64) ([32]byte, error) { + return _Polygonrollupmanager.Contract.GetRollupBatchNumToStateRoot(&_Polygonrollupmanager.CallOpts, rollupID, batchNum) +} + +// GetRollupBatchNumToStateRoot is a free data retrieval call binding the contract method 0x55a71ee0. +// +// Solidity: function getRollupBatchNumToStateRoot(uint32 rollupID, uint64 batchNum) view returns(bytes32) +func (_Polygonrollupmanager *PolygonrollupmanagerCallerSession) GetRollupBatchNumToStateRoot(rollupID uint32, batchNum uint64) ([32]byte, error) { + return _Polygonrollupmanager.Contract.GetRollupBatchNumToStateRoot(&_Polygonrollupmanager.CallOpts, rollupID, batchNum) +} + +// GetRollupExitRoot is a free data retrieval call binding the contract method 0xa2967d99. +// +// Solidity: function getRollupExitRoot() view returns(bytes32) +func (_Polygonrollupmanager *PolygonrollupmanagerCaller) GetRollupExitRoot(opts *bind.CallOpts) ([32]byte, error) { + var out []interface{} + err := _Polygonrollupmanager.contract.Call(opts, &out, "getRollupExitRoot") + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// GetRollupExitRoot is a free data retrieval call binding the contract method 0xa2967d99. +// +// Solidity: function getRollupExitRoot() view returns(bytes32) +func (_Polygonrollupmanager *PolygonrollupmanagerSession) GetRollupExitRoot() ([32]byte, error) { + return _Polygonrollupmanager.Contract.GetRollupExitRoot(&_Polygonrollupmanager.CallOpts) +} + +// GetRollupExitRoot is a free data retrieval call binding the contract method 0xa2967d99. +// +// Solidity: function getRollupExitRoot() view returns(bytes32) +func (_Polygonrollupmanager *PolygonrollupmanagerCallerSession) GetRollupExitRoot() ([32]byte, error) { + return _Polygonrollupmanager.Contract.GetRollupExitRoot(&_Polygonrollupmanager.CallOpts) +} + +// GetRollupPendingStateTransitions is a free data retrieval call binding the contract method 0xb99d0ad7. +// +// Solidity: function getRollupPendingStateTransitions(uint32 rollupID, uint64 batchNum) view returns((uint64,uint64,bytes32,bytes32)) +func (_Polygonrollupmanager *PolygonrollupmanagerCaller) GetRollupPendingStateTransitions(opts *bind.CallOpts, rollupID uint32, batchNum uint64) (LegacyZKEVMStateVariablesPendingState, error) { + var out []interface{} + err := _Polygonrollupmanager.contract.Call(opts, &out, "getRollupPendingStateTransitions", rollupID, batchNum) + + if err != nil { + return *new(LegacyZKEVMStateVariablesPendingState), err + } + + out0 := *abi.ConvertType(out[0], new(LegacyZKEVMStateVariablesPendingState)).(*LegacyZKEVMStateVariablesPendingState) + + return out0, err + +} + +// GetRollupPendingStateTransitions is a free data retrieval call binding the contract method 0xb99d0ad7. +// +// Solidity: function getRollupPendingStateTransitions(uint32 rollupID, uint64 batchNum) view returns((uint64,uint64,bytes32,bytes32)) +func (_Polygonrollupmanager *PolygonrollupmanagerSession) GetRollupPendingStateTransitions(rollupID uint32, batchNum uint64) (LegacyZKEVMStateVariablesPendingState, error) { + return _Polygonrollupmanager.Contract.GetRollupPendingStateTransitions(&_Polygonrollupmanager.CallOpts, rollupID, batchNum) +} + +// GetRollupPendingStateTransitions is a free data retrieval call binding the contract method 0xb99d0ad7. +// +// Solidity: function getRollupPendingStateTransitions(uint32 rollupID, uint64 batchNum) view returns((uint64,uint64,bytes32,bytes32)) +func (_Polygonrollupmanager *PolygonrollupmanagerCallerSession) GetRollupPendingStateTransitions(rollupID uint32, batchNum uint64) (LegacyZKEVMStateVariablesPendingState, error) { + return _Polygonrollupmanager.Contract.GetRollupPendingStateTransitions(&_Polygonrollupmanager.CallOpts, rollupID, batchNum) +} + +// GetRollupSequencedBatches is a free data retrieval call binding the contract method 0x25280169. +// +// Solidity: function getRollupSequencedBatches(uint32 rollupID, uint64 batchNum) view returns((bytes32,uint64,uint64)) +func (_Polygonrollupmanager *PolygonrollupmanagerCaller) GetRollupSequencedBatches(opts *bind.CallOpts, rollupID uint32, batchNum uint64) (LegacyZKEVMStateVariablesSequencedBatchData, error) { + var out []interface{} + err := _Polygonrollupmanager.contract.Call(opts, &out, "getRollupSequencedBatches", rollupID, batchNum) + + if err != nil { + return *new(LegacyZKEVMStateVariablesSequencedBatchData), err + } + + out0 := *abi.ConvertType(out[0], new(LegacyZKEVMStateVariablesSequencedBatchData)).(*LegacyZKEVMStateVariablesSequencedBatchData) + + return out0, err + +} + +// GetRollupSequencedBatches is a free data retrieval call binding the contract method 0x25280169. +// +// Solidity: function getRollupSequencedBatches(uint32 rollupID, uint64 batchNum) view returns((bytes32,uint64,uint64)) +func (_Polygonrollupmanager *PolygonrollupmanagerSession) GetRollupSequencedBatches(rollupID uint32, batchNum uint64) (LegacyZKEVMStateVariablesSequencedBatchData, error) { + return _Polygonrollupmanager.Contract.GetRollupSequencedBatches(&_Polygonrollupmanager.CallOpts, rollupID, batchNum) +} + +// GetRollupSequencedBatches is a free data retrieval call binding the contract method 0x25280169. +// +// Solidity: function getRollupSequencedBatches(uint32 rollupID, uint64 batchNum) view returns((bytes32,uint64,uint64)) +func (_Polygonrollupmanager *PolygonrollupmanagerCallerSession) GetRollupSequencedBatches(rollupID uint32, batchNum uint64) (LegacyZKEVMStateVariablesSequencedBatchData, error) { + return _Polygonrollupmanager.Contract.GetRollupSequencedBatches(&_Polygonrollupmanager.CallOpts, rollupID, batchNum) +} + +// GlobalExitRootManager is a free data retrieval call binding the contract method 0xd02103ca. +// +// Solidity: function globalExitRootManager() view returns(address) +func (_Polygonrollupmanager *PolygonrollupmanagerCaller) GlobalExitRootManager(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Polygonrollupmanager.contract.Call(opts, &out, "globalExitRootManager") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// GlobalExitRootManager is a free data retrieval call binding the contract method 0xd02103ca. +// +// Solidity: function globalExitRootManager() view returns(address) +func (_Polygonrollupmanager *PolygonrollupmanagerSession) GlobalExitRootManager() (common.Address, error) { + return _Polygonrollupmanager.Contract.GlobalExitRootManager(&_Polygonrollupmanager.CallOpts) +} + +// GlobalExitRootManager is a free data retrieval call binding the contract method 0xd02103ca. +// +// Solidity: function globalExitRootManager() view returns(address) +func (_Polygonrollupmanager *PolygonrollupmanagerCallerSession) GlobalExitRootManager() (common.Address, error) { + return _Polygonrollupmanager.Contract.GlobalExitRootManager(&_Polygonrollupmanager.CallOpts) +} + +// HasRole is a free data retrieval call binding the contract method 0x91d14854. +// +// Solidity: function hasRole(bytes32 role, address account) view returns(bool) +func (_Polygonrollupmanager *PolygonrollupmanagerCaller) HasRole(opts *bind.CallOpts, role [32]byte, account common.Address) (bool, error) { + var out []interface{} + err := _Polygonrollupmanager.contract.Call(opts, &out, "hasRole", role, account) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// HasRole is a free data retrieval call binding the contract method 0x91d14854. +// +// Solidity: function hasRole(bytes32 role, address account) view returns(bool) +func (_Polygonrollupmanager *PolygonrollupmanagerSession) HasRole(role [32]byte, account common.Address) (bool, error) { + return _Polygonrollupmanager.Contract.HasRole(&_Polygonrollupmanager.CallOpts, role, account) +} + +// HasRole is a free data retrieval call binding the contract method 0x91d14854. +// +// Solidity: function hasRole(bytes32 role, address account) view returns(bool) +func (_Polygonrollupmanager *PolygonrollupmanagerCallerSession) HasRole(role [32]byte, account common.Address) (bool, error) { + return _Polygonrollupmanager.Contract.HasRole(&_Polygonrollupmanager.CallOpts, role, account) +} + +// IsEmergencyState is a free data retrieval call binding the contract method 0x15064c96. +// +// Solidity: function isEmergencyState() view returns(bool) +func (_Polygonrollupmanager *PolygonrollupmanagerCaller) IsEmergencyState(opts *bind.CallOpts) (bool, error) { + var out []interface{} + err := _Polygonrollupmanager.contract.Call(opts, &out, "isEmergencyState") + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// IsEmergencyState is a free data retrieval call binding the contract method 0x15064c96. +// +// Solidity: function isEmergencyState() view returns(bool) +func (_Polygonrollupmanager *PolygonrollupmanagerSession) IsEmergencyState() (bool, error) { + return _Polygonrollupmanager.Contract.IsEmergencyState(&_Polygonrollupmanager.CallOpts) +} + +// IsEmergencyState is a free data retrieval call binding the contract method 0x15064c96. +// +// Solidity: function isEmergencyState() view returns(bool) +func (_Polygonrollupmanager *PolygonrollupmanagerCallerSession) IsEmergencyState() (bool, error) { + return _Polygonrollupmanager.Contract.IsEmergencyState(&_Polygonrollupmanager.CallOpts) +} + +// IsPendingStateConsolidable is a free data retrieval call binding the contract method 0x080b3111. +// +// Solidity: function isPendingStateConsolidable(uint32 rollupID, uint64 pendingStateNum) view returns(bool) +func (_Polygonrollupmanager *PolygonrollupmanagerCaller) IsPendingStateConsolidable(opts *bind.CallOpts, rollupID uint32, pendingStateNum uint64) (bool, error) { + var out []interface{} + err := _Polygonrollupmanager.contract.Call(opts, &out, "isPendingStateConsolidable", rollupID, pendingStateNum) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// IsPendingStateConsolidable is a free data retrieval call binding the contract method 0x080b3111. +// +// Solidity: function isPendingStateConsolidable(uint32 rollupID, uint64 pendingStateNum) view returns(bool) +func (_Polygonrollupmanager *PolygonrollupmanagerSession) IsPendingStateConsolidable(rollupID uint32, pendingStateNum uint64) (bool, error) { + return _Polygonrollupmanager.Contract.IsPendingStateConsolidable(&_Polygonrollupmanager.CallOpts, rollupID, pendingStateNum) +} + +// IsPendingStateConsolidable is a free data retrieval call binding the contract method 0x080b3111. +// +// Solidity: function isPendingStateConsolidable(uint32 rollupID, uint64 pendingStateNum) view returns(bool) +func (_Polygonrollupmanager *PolygonrollupmanagerCallerSession) IsPendingStateConsolidable(rollupID uint32, pendingStateNum uint64) (bool, error) { + return _Polygonrollupmanager.Contract.IsPendingStateConsolidable(&_Polygonrollupmanager.CallOpts, rollupID, pendingStateNum) +} + +// LastAggregationTimestamp is a free data retrieval call binding the contract method 0xc1acbc34. +// +// Solidity: function lastAggregationTimestamp() view returns(uint64) +func (_Polygonrollupmanager *PolygonrollupmanagerCaller) LastAggregationTimestamp(opts *bind.CallOpts) (uint64, error) { + var out []interface{} + err := _Polygonrollupmanager.contract.Call(opts, &out, "lastAggregationTimestamp") + + if err != nil { + return *new(uint64), err + } + + out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64) + + return out0, err + +} + +// LastAggregationTimestamp is a free data retrieval call binding the contract method 0xc1acbc34. +// +// Solidity: function lastAggregationTimestamp() view returns(uint64) +func (_Polygonrollupmanager *PolygonrollupmanagerSession) LastAggregationTimestamp() (uint64, error) { + return _Polygonrollupmanager.Contract.LastAggregationTimestamp(&_Polygonrollupmanager.CallOpts) +} + +// LastAggregationTimestamp is a free data retrieval call binding the contract method 0xc1acbc34. +// +// Solidity: function lastAggregationTimestamp() view returns(uint64) +func (_Polygonrollupmanager *PolygonrollupmanagerCallerSession) LastAggregationTimestamp() (uint64, error) { + return _Polygonrollupmanager.Contract.LastAggregationTimestamp(&_Polygonrollupmanager.CallOpts) +} + +// MultiplierBatchFee is a free data retrieval call binding the contract method 0xafd23cbe. +// +// Solidity: function multiplierBatchFee() view returns(uint16) +func (_Polygonrollupmanager *PolygonrollupmanagerCaller) MultiplierBatchFee(opts *bind.CallOpts) (uint16, error) { + var out []interface{} + err := _Polygonrollupmanager.contract.Call(opts, &out, "multiplierBatchFee") + + if err != nil { + return *new(uint16), err + } + + out0 := *abi.ConvertType(out[0], new(uint16)).(*uint16) + + return out0, err + +} + +// MultiplierBatchFee is a free data retrieval call binding the contract method 0xafd23cbe. +// +// Solidity: function multiplierBatchFee() view returns(uint16) +func (_Polygonrollupmanager *PolygonrollupmanagerSession) MultiplierBatchFee() (uint16, error) { + return _Polygonrollupmanager.Contract.MultiplierBatchFee(&_Polygonrollupmanager.CallOpts) +} + +// MultiplierBatchFee is a free data retrieval call binding the contract method 0xafd23cbe. +// +// Solidity: function multiplierBatchFee() view returns(uint16) +func (_Polygonrollupmanager *PolygonrollupmanagerCallerSession) MultiplierBatchFee() (uint16, error) { + return _Polygonrollupmanager.Contract.MultiplierBatchFee(&_Polygonrollupmanager.CallOpts) +} + +// PendingStateTimeout is a free data retrieval call binding the contract method 0xd939b315. +// +// Solidity: function pendingStateTimeout() view returns(uint64) +func (_Polygonrollupmanager *PolygonrollupmanagerCaller) PendingStateTimeout(opts *bind.CallOpts) (uint64, error) { + var out []interface{} + err := _Polygonrollupmanager.contract.Call(opts, &out, "pendingStateTimeout") + + if err != nil { + return *new(uint64), err + } + + out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64) + + return out0, err + +} + +// PendingStateTimeout is a free data retrieval call binding the contract method 0xd939b315. +// +// Solidity: function pendingStateTimeout() view returns(uint64) +func (_Polygonrollupmanager *PolygonrollupmanagerSession) PendingStateTimeout() (uint64, error) { + return _Polygonrollupmanager.Contract.PendingStateTimeout(&_Polygonrollupmanager.CallOpts) +} + +// PendingStateTimeout is a free data retrieval call binding the contract method 0xd939b315. +// +// Solidity: function pendingStateTimeout() view returns(uint64) +func (_Polygonrollupmanager *PolygonrollupmanagerCallerSession) PendingStateTimeout() (uint64, error) { + return _Polygonrollupmanager.Contract.PendingStateTimeout(&_Polygonrollupmanager.CallOpts) +} + +// Pol is a free data retrieval call binding the contract method 0xe46761c4. +// +// Solidity: function pol() view returns(address) +func (_Polygonrollupmanager *PolygonrollupmanagerCaller) Pol(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Polygonrollupmanager.contract.Call(opts, &out, "pol") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// Pol is a free data retrieval call binding the contract method 0xe46761c4. +// +// Solidity: function pol() view returns(address) +func (_Polygonrollupmanager *PolygonrollupmanagerSession) Pol() (common.Address, error) { + return _Polygonrollupmanager.Contract.Pol(&_Polygonrollupmanager.CallOpts) +} + +// Pol is a free data retrieval call binding the contract method 0xe46761c4. +// +// Solidity: function pol() view returns(address) +func (_Polygonrollupmanager *PolygonrollupmanagerCallerSession) Pol() (common.Address, error) { + return _Polygonrollupmanager.Contract.Pol(&_Polygonrollupmanager.CallOpts) +} + +// RollupAddressToID is a free data retrieval call binding the contract method 0xceee281d. +// +// Solidity: function rollupAddressToID(address rollupAddress) view returns(uint32 rollupID) +func (_Polygonrollupmanager *PolygonrollupmanagerCaller) RollupAddressToID(opts *bind.CallOpts, rollupAddress common.Address) (uint32, error) { + var out []interface{} + err := _Polygonrollupmanager.contract.Call(opts, &out, "rollupAddressToID", rollupAddress) + + if err != nil { + return *new(uint32), err + } + + out0 := *abi.ConvertType(out[0], new(uint32)).(*uint32) + + return out0, err + +} + +// RollupAddressToID is a free data retrieval call binding the contract method 0xceee281d. +// +// Solidity: function rollupAddressToID(address rollupAddress) view returns(uint32 rollupID) +func (_Polygonrollupmanager *PolygonrollupmanagerSession) RollupAddressToID(rollupAddress common.Address) (uint32, error) { + return _Polygonrollupmanager.Contract.RollupAddressToID(&_Polygonrollupmanager.CallOpts, rollupAddress) +} + +// RollupAddressToID is a free data retrieval call binding the contract method 0xceee281d. +// +// Solidity: function rollupAddressToID(address rollupAddress) view returns(uint32 rollupID) +func (_Polygonrollupmanager *PolygonrollupmanagerCallerSession) RollupAddressToID(rollupAddress common.Address) (uint32, error) { + return _Polygonrollupmanager.Contract.RollupAddressToID(&_Polygonrollupmanager.CallOpts, rollupAddress) +} + +// RollupCount is a free data retrieval call binding the contract method 0xf4e92675. +// +// Solidity: function rollupCount() view returns(uint32) +func (_Polygonrollupmanager *PolygonrollupmanagerCaller) RollupCount(opts *bind.CallOpts) (uint32, error) { + var out []interface{} + err := _Polygonrollupmanager.contract.Call(opts, &out, "rollupCount") + + if err != nil { + return *new(uint32), err + } + + out0 := *abi.ConvertType(out[0], new(uint32)).(*uint32) + + return out0, err + +} + +// RollupCount is a free data retrieval call binding the contract method 0xf4e92675. +// +// Solidity: function rollupCount() view returns(uint32) +func (_Polygonrollupmanager *PolygonrollupmanagerSession) RollupCount() (uint32, error) { + return _Polygonrollupmanager.Contract.RollupCount(&_Polygonrollupmanager.CallOpts) +} + +// RollupCount is a free data retrieval call binding the contract method 0xf4e92675. +// +// Solidity: function rollupCount() view returns(uint32) +func (_Polygonrollupmanager *PolygonrollupmanagerCallerSession) RollupCount() (uint32, error) { + return _Polygonrollupmanager.Contract.RollupCount(&_Polygonrollupmanager.CallOpts) +} + +// RollupIDToRollupData is a free data retrieval call binding the contract method 0xf9c4c2ae. +// +// Solidity: function rollupIDToRollupData(uint32 rollupID) view returns(address rollupContract, uint64 chainID, address verifier, uint64 forkID, bytes32 lastLocalExitRoot, uint64 lastBatchSequenced, uint64 lastVerifiedBatch, uint64 lastPendingState, uint64 lastPendingStateConsolidated, uint64 lastVerifiedBatchBeforeUpgrade, uint64 rollupTypeID, uint8 rollupCompatibilityID) +func (_Polygonrollupmanager *PolygonrollupmanagerCaller) RollupIDToRollupData(opts *bind.CallOpts, rollupID uint32) (struct { + RollupContract common.Address + ChainID uint64 + Verifier common.Address + ForkID uint64 + LastLocalExitRoot [32]byte + LastBatchSequenced uint64 + LastVerifiedBatch uint64 + LastPendingState uint64 + LastPendingStateConsolidated uint64 + LastVerifiedBatchBeforeUpgrade uint64 + RollupTypeID uint64 + RollupCompatibilityID uint8 +}, error) { + var out []interface{} + err := _Polygonrollupmanager.contract.Call(opts, &out, "rollupIDToRollupData", rollupID) + + outstruct := new(struct { + RollupContract common.Address + ChainID uint64 + Verifier common.Address + ForkID uint64 + LastLocalExitRoot [32]byte + LastBatchSequenced uint64 + LastVerifiedBatch uint64 + LastPendingState uint64 + LastPendingStateConsolidated uint64 + LastVerifiedBatchBeforeUpgrade uint64 + RollupTypeID uint64 + RollupCompatibilityID uint8 + }) + if err != nil { + return *outstruct, err + } + + outstruct.RollupContract = *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + outstruct.ChainID = *abi.ConvertType(out[1], new(uint64)).(*uint64) + outstruct.Verifier = *abi.ConvertType(out[2], new(common.Address)).(*common.Address) + outstruct.ForkID = *abi.ConvertType(out[3], new(uint64)).(*uint64) + outstruct.LastLocalExitRoot = *abi.ConvertType(out[4], new([32]byte)).(*[32]byte) + outstruct.LastBatchSequenced = *abi.ConvertType(out[5], new(uint64)).(*uint64) + outstruct.LastVerifiedBatch = *abi.ConvertType(out[6], new(uint64)).(*uint64) + outstruct.LastPendingState = *abi.ConvertType(out[7], new(uint64)).(*uint64) + outstruct.LastPendingStateConsolidated = *abi.ConvertType(out[8], new(uint64)).(*uint64) + outstruct.LastVerifiedBatchBeforeUpgrade = *abi.ConvertType(out[9], new(uint64)).(*uint64) + outstruct.RollupTypeID = *abi.ConvertType(out[10], new(uint64)).(*uint64) + outstruct.RollupCompatibilityID = *abi.ConvertType(out[11], new(uint8)).(*uint8) + + return *outstruct, err + +} + +// RollupIDToRollupData is a free data retrieval call binding the contract method 0xf9c4c2ae. +// +// Solidity: function rollupIDToRollupData(uint32 rollupID) view returns(address rollupContract, uint64 chainID, address verifier, uint64 forkID, bytes32 lastLocalExitRoot, uint64 lastBatchSequenced, uint64 lastVerifiedBatch, uint64 lastPendingState, uint64 lastPendingStateConsolidated, uint64 lastVerifiedBatchBeforeUpgrade, uint64 rollupTypeID, uint8 rollupCompatibilityID) +func (_Polygonrollupmanager *PolygonrollupmanagerSession) RollupIDToRollupData(rollupID uint32) (struct { + RollupContract common.Address + ChainID uint64 + Verifier common.Address + ForkID uint64 + LastLocalExitRoot [32]byte + LastBatchSequenced uint64 + LastVerifiedBatch uint64 + LastPendingState uint64 + LastPendingStateConsolidated uint64 + LastVerifiedBatchBeforeUpgrade uint64 + RollupTypeID uint64 + RollupCompatibilityID uint8 +}, error) { + return _Polygonrollupmanager.Contract.RollupIDToRollupData(&_Polygonrollupmanager.CallOpts, rollupID) +} + +// RollupIDToRollupData is a free data retrieval call binding the contract method 0xf9c4c2ae. +// +// Solidity: function rollupIDToRollupData(uint32 rollupID) view returns(address rollupContract, uint64 chainID, address verifier, uint64 forkID, bytes32 lastLocalExitRoot, uint64 lastBatchSequenced, uint64 lastVerifiedBatch, uint64 lastPendingState, uint64 lastPendingStateConsolidated, uint64 lastVerifiedBatchBeforeUpgrade, uint64 rollupTypeID, uint8 rollupCompatibilityID) +func (_Polygonrollupmanager *PolygonrollupmanagerCallerSession) RollupIDToRollupData(rollupID uint32) (struct { + RollupContract common.Address + ChainID uint64 + Verifier common.Address + ForkID uint64 + LastLocalExitRoot [32]byte + LastBatchSequenced uint64 + LastVerifiedBatch uint64 + LastPendingState uint64 + LastPendingStateConsolidated uint64 + LastVerifiedBatchBeforeUpgrade uint64 + RollupTypeID uint64 + RollupCompatibilityID uint8 +}, error) { + return _Polygonrollupmanager.Contract.RollupIDToRollupData(&_Polygonrollupmanager.CallOpts, rollupID) +} + +// RollupTypeCount is a free data retrieval call binding the contract method 0x1796a1ae. +// +// Solidity: function rollupTypeCount() view returns(uint32) +func (_Polygonrollupmanager *PolygonrollupmanagerCaller) RollupTypeCount(opts *bind.CallOpts) (uint32, error) { + var out []interface{} + err := _Polygonrollupmanager.contract.Call(opts, &out, "rollupTypeCount") + + if err != nil { + return *new(uint32), err + } + + out0 := *abi.ConvertType(out[0], new(uint32)).(*uint32) + + return out0, err + +} + +// RollupTypeCount is a free data retrieval call binding the contract method 0x1796a1ae. +// +// Solidity: function rollupTypeCount() view returns(uint32) +func (_Polygonrollupmanager *PolygonrollupmanagerSession) RollupTypeCount() (uint32, error) { + return _Polygonrollupmanager.Contract.RollupTypeCount(&_Polygonrollupmanager.CallOpts) +} + +// RollupTypeCount is a free data retrieval call binding the contract method 0x1796a1ae. +// +// Solidity: function rollupTypeCount() view returns(uint32) +func (_Polygonrollupmanager *PolygonrollupmanagerCallerSession) RollupTypeCount() (uint32, error) { + return _Polygonrollupmanager.Contract.RollupTypeCount(&_Polygonrollupmanager.CallOpts) +} + +// RollupTypeMap is a free data retrieval call binding the contract method 0x65c0504d. +// +// Solidity: function rollupTypeMap(uint32 rollupTypeID) view returns(address consensusImplementation, address verifier, uint64 forkID, uint8 rollupCompatibilityID, bool obsolete, bytes32 genesis) +func (_Polygonrollupmanager *PolygonrollupmanagerCaller) RollupTypeMap(opts *bind.CallOpts, rollupTypeID uint32) (struct { + ConsensusImplementation common.Address + Verifier common.Address + ForkID uint64 + RollupCompatibilityID uint8 + Obsolete bool + Genesis [32]byte +}, error) { + var out []interface{} + err := _Polygonrollupmanager.contract.Call(opts, &out, "rollupTypeMap", rollupTypeID) + + outstruct := new(struct { + ConsensusImplementation common.Address + Verifier common.Address + ForkID uint64 + RollupCompatibilityID uint8 + Obsolete bool + Genesis [32]byte + }) + if err != nil { + return *outstruct, err + } + + outstruct.ConsensusImplementation = *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + outstruct.Verifier = *abi.ConvertType(out[1], new(common.Address)).(*common.Address) + outstruct.ForkID = *abi.ConvertType(out[2], new(uint64)).(*uint64) + outstruct.RollupCompatibilityID = *abi.ConvertType(out[3], new(uint8)).(*uint8) + outstruct.Obsolete = *abi.ConvertType(out[4], new(bool)).(*bool) + outstruct.Genesis = *abi.ConvertType(out[5], new([32]byte)).(*[32]byte) + + return *outstruct, err + +} + +// RollupTypeMap is a free data retrieval call binding the contract method 0x65c0504d. +// +// Solidity: function rollupTypeMap(uint32 rollupTypeID) view returns(address consensusImplementation, address verifier, uint64 forkID, uint8 rollupCompatibilityID, bool obsolete, bytes32 genesis) +func (_Polygonrollupmanager *PolygonrollupmanagerSession) RollupTypeMap(rollupTypeID uint32) (struct { + ConsensusImplementation common.Address + Verifier common.Address + ForkID uint64 + RollupCompatibilityID uint8 + Obsolete bool + Genesis [32]byte +}, error) { + return _Polygonrollupmanager.Contract.RollupTypeMap(&_Polygonrollupmanager.CallOpts, rollupTypeID) +} + +// RollupTypeMap is a free data retrieval call binding the contract method 0x65c0504d. +// +// Solidity: function rollupTypeMap(uint32 rollupTypeID) view returns(address consensusImplementation, address verifier, uint64 forkID, uint8 rollupCompatibilityID, bool obsolete, bytes32 genesis) +func (_Polygonrollupmanager *PolygonrollupmanagerCallerSession) RollupTypeMap(rollupTypeID uint32) (struct { + ConsensusImplementation common.Address + Verifier common.Address + ForkID uint64 + RollupCompatibilityID uint8 + Obsolete bool + Genesis [32]byte +}, error) { + return _Polygonrollupmanager.Contract.RollupTypeMap(&_Polygonrollupmanager.CallOpts, rollupTypeID) +} + +// TotalSequencedBatches is a free data retrieval call binding the contract method 0x066ec012. +// +// Solidity: function totalSequencedBatches() view returns(uint64) +func (_Polygonrollupmanager *PolygonrollupmanagerCaller) TotalSequencedBatches(opts *bind.CallOpts) (uint64, error) { + var out []interface{} + err := _Polygonrollupmanager.contract.Call(opts, &out, "totalSequencedBatches") + + if err != nil { + return *new(uint64), err + } + + out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64) + + return out0, err + +} + +// TotalSequencedBatches is a free data retrieval call binding the contract method 0x066ec012. +// +// Solidity: function totalSequencedBatches() view returns(uint64) +func (_Polygonrollupmanager *PolygonrollupmanagerSession) TotalSequencedBatches() (uint64, error) { + return _Polygonrollupmanager.Contract.TotalSequencedBatches(&_Polygonrollupmanager.CallOpts) +} + +// TotalSequencedBatches is a free data retrieval call binding the contract method 0x066ec012. +// +// Solidity: function totalSequencedBatches() view returns(uint64) +func (_Polygonrollupmanager *PolygonrollupmanagerCallerSession) TotalSequencedBatches() (uint64, error) { + return _Polygonrollupmanager.Contract.TotalSequencedBatches(&_Polygonrollupmanager.CallOpts) +} + +// TotalVerifiedBatches is a free data retrieval call binding the contract method 0xdde0ff77. +// +// Solidity: function totalVerifiedBatches() view returns(uint64) +func (_Polygonrollupmanager *PolygonrollupmanagerCaller) TotalVerifiedBatches(opts *bind.CallOpts) (uint64, error) { + var out []interface{} + err := _Polygonrollupmanager.contract.Call(opts, &out, "totalVerifiedBatches") + + if err != nil { + return *new(uint64), err + } + + out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64) + + return out0, err + +} + +// TotalVerifiedBatches is a free data retrieval call binding the contract method 0xdde0ff77. +// +// Solidity: function totalVerifiedBatches() view returns(uint64) +func (_Polygonrollupmanager *PolygonrollupmanagerSession) TotalVerifiedBatches() (uint64, error) { + return _Polygonrollupmanager.Contract.TotalVerifiedBatches(&_Polygonrollupmanager.CallOpts) +} + +// TotalVerifiedBatches is a free data retrieval call binding the contract method 0xdde0ff77. +// +// Solidity: function totalVerifiedBatches() view returns(uint64) +func (_Polygonrollupmanager *PolygonrollupmanagerCallerSession) TotalVerifiedBatches() (uint64, error) { + return _Polygonrollupmanager.Contract.TotalVerifiedBatches(&_Polygonrollupmanager.CallOpts) +} + +// TrustedAggregatorTimeout is a free data retrieval call binding the contract method 0x841b24d7. +// +// Solidity: function trustedAggregatorTimeout() view returns(uint64) +func (_Polygonrollupmanager *PolygonrollupmanagerCaller) TrustedAggregatorTimeout(opts *bind.CallOpts) (uint64, error) { + var out []interface{} + err := _Polygonrollupmanager.contract.Call(opts, &out, "trustedAggregatorTimeout") + + if err != nil { + return *new(uint64), err + } + + out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64) + + return out0, err + +} + +// TrustedAggregatorTimeout is a free data retrieval call binding the contract method 0x841b24d7. +// +// Solidity: function trustedAggregatorTimeout() view returns(uint64) +func (_Polygonrollupmanager *PolygonrollupmanagerSession) TrustedAggregatorTimeout() (uint64, error) { + return _Polygonrollupmanager.Contract.TrustedAggregatorTimeout(&_Polygonrollupmanager.CallOpts) +} + +// TrustedAggregatorTimeout is a free data retrieval call binding the contract method 0x841b24d7. +// +// Solidity: function trustedAggregatorTimeout() view returns(uint64) +func (_Polygonrollupmanager *PolygonrollupmanagerCallerSession) TrustedAggregatorTimeout() (uint64, error) { + return _Polygonrollupmanager.Contract.TrustedAggregatorTimeout(&_Polygonrollupmanager.CallOpts) +} + +// VerifyBatchTimeTarget is a free data retrieval call binding the contract method 0x0a0d9fbe. +// +// Solidity: function verifyBatchTimeTarget() view returns(uint64) +func (_Polygonrollupmanager *PolygonrollupmanagerCaller) VerifyBatchTimeTarget(opts *bind.CallOpts) (uint64, error) { + var out []interface{} + err := _Polygonrollupmanager.contract.Call(opts, &out, "verifyBatchTimeTarget") + + if err != nil { + return *new(uint64), err + } + + out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64) + + return out0, err + +} + +// VerifyBatchTimeTarget is a free data retrieval call binding the contract method 0x0a0d9fbe. +// +// Solidity: function verifyBatchTimeTarget() view returns(uint64) +func (_Polygonrollupmanager *PolygonrollupmanagerSession) VerifyBatchTimeTarget() (uint64, error) { + return _Polygonrollupmanager.Contract.VerifyBatchTimeTarget(&_Polygonrollupmanager.CallOpts) +} + +// VerifyBatchTimeTarget is a free data retrieval call binding the contract method 0x0a0d9fbe. +// +// Solidity: function verifyBatchTimeTarget() view returns(uint64) +func (_Polygonrollupmanager *PolygonrollupmanagerCallerSession) VerifyBatchTimeTarget() (uint64, error) { + return _Polygonrollupmanager.Contract.VerifyBatchTimeTarget(&_Polygonrollupmanager.CallOpts) +} + +// ActivateEmergencyState is a paid mutator transaction binding the contract method 0x2072f6c5. +// +// Solidity: function activateEmergencyState() returns() +func (_Polygonrollupmanager *PolygonrollupmanagerTransactor) ActivateEmergencyState(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Polygonrollupmanager.contract.Transact(opts, "activateEmergencyState") +} + +// ActivateEmergencyState is a paid mutator transaction binding the contract method 0x2072f6c5. +// +// Solidity: function activateEmergencyState() returns() +func (_Polygonrollupmanager *PolygonrollupmanagerSession) ActivateEmergencyState() (*types.Transaction, error) { + return _Polygonrollupmanager.Contract.ActivateEmergencyState(&_Polygonrollupmanager.TransactOpts) +} + +// ActivateEmergencyState is a paid mutator transaction binding the contract method 0x2072f6c5. +// +// Solidity: function activateEmergencyState() returns() +func (_Polygonrollupmanager *PolygonrollupmanagerTransactorSession) ActivateEmergencyState() (*types.Transaction, error) { + return _Polygonrollupmanager.Contract.ActivateEmergencyState(&_Polygonrollupmanager.TransactOpts) +} + +// AddExistingRollup is a paid mutator transaction binding the contract method 0xe0bfd3d2. +// +// Solidity: function addExistingRollup(address rollupAddress, address verifier, uint64 forkID, uint64 chainID, bytes32 genesis, uint8 rollupCompatibilityID) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerTransactor) AddExistingRollup(opts *bind.TransactOpts, rollupAddress common.Address, verifier common.Address, forkID uint64, chainID uint64, genesis [32]byte, rollupCompatibilityID uint8) (*types.Transaction, error) { + return _Polygonrollupmanager.contract.Transact(opts, "addExistingRollup", rollupAddress, verifier, forkID, chainID, genesis, rollupCompatibilityID) +} + +// AddExistingRollup is a paid mutator transaction binding the contract method 0xe0bfd3d2. +// +// Solidity: function addExistingRollup(address rollupAddress, address verifier, uint64 forkID, uint64 chainID, bytes32 genesis, uint8 rollupCompatibilityID) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerSession) AddExistingRollup(rollupAddress common.Address, verifier common.Address, forkID uint64, chainID uint64, genesis [32]byte, rollupCompatibilityID uint8) (*types.Transaction, error) { + return _Polygonrollupmanager.Contract.AddExistingRollup(&_Polygonrollupmanager.TransactOpts, rollupAddress, verifier, forkID, chainID, genesis, rollupCompatibilityID) +} + +// AddExistingRollup is a paid mutator transaction binding the contract method 0xe0bfd3d2. +// +// Solidity: function addExistingRollup(address rollupAddress, address verifier, uint64 forkID, uint64 chainID, bytes32 genesis, uint8 rollupCompatibilityID) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerTransactorSession) AddExistingRollup(rollupAddress common.Address, verifier common.Address, forkID uint64, chainID uint64, genesis [32]byte, rollupCompatibilityID uint8) (*types.Transaction, error) { + return _Polygonrollupmanager.Contract.AddExistingRollup(&_Polygonrollupmanager.TransactOpts, rollupAddress, verifier, forkID, chainID, genesis, rollupCompatibilityID) +} + +// AddNewRollupType is a paid mutator transaction binding the contract method 0xf34eb8eb. +// +// Solidity: function addNewRollupType(address consensusImplementation, address verifier, uint64 forkID, uint8 rollupCompatibilityID, bytes32 genesis, string description) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerTransactor) AddNewRollupType(opts *bind.TransactOpts, consensusImplementation common.Address, verifier common.Address, forkID uint64, rollupCompatibilityID uint8, genesis [32]byte, description string) (*types.Transaction, error) { + return _Polygonrollupmanager.contract.Transact(opts, "addNewRollupType", consensusImplementation, verifier, forkID, rollupCompatibilityID, genesis, description) +} + +// AddNewRollupType is a paid mutator transaction binding the contract method 0xf34eb8eb. +// +// Solidity: function addNewRollupType(address consensusImplementation, address verifier, uint64 forkID, uint8 rollupCompatibilityID, bytes32 genesis, string description) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerSession) AddNewRollupType(consensusImplementation common.Address, verifier common.Address, forkID uint64, rollupCompatibilityID uint8, genesis [32]byte, description string) (*types.Transaction, error) { + return _Polygonrollupmanager.Contract.AddNewRollupType(&_Polygonrollupmanager.TransactOpts, consensusImplementation, verifier, forkID, rollupCompatibilityID, genesis, description) +} + +// AddNewRollupType is a paid mutator transaction binding the contract method 0xf34eb8eb. +// +// Solidity: function addNewRollupType(address consensusImplementation, address verifier, uint64 forkID, uint8 rollupCompatibilityID, bytes32 genesis, string description) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerTransactorSession) AddNewRollupType(consensusImplementation common.Address, verifier common.Address, forkID uint64, rollupCompatibilityID uint8, genesis [32]byte, description string) (*types.Transaction, error) { + return _Polygonrollupmanager.Contract.AddNewRollupType(&_Polygonrollupmanager.TransactOpts, consensusImplementation, verifier, forkID, rollupCompatibilityID, genesis, description) +} + +// ConsolidatePendingState is a paid mutator transaction binding the contract method 0x1608859c. +// +// Solidity: function consolidatePendingState(uint32 rollupID, uint64 pendingStateNum) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerTransactor) ConsolidatePendingState(opts *bind.TransactOpts, rollupID uint32, pendingStateNum uint64) (*types.Transaction, error) { + return _Polygonrollupmanager.contract.Transact(opts, "consolidatePendingState", rollupID, pendingStateNum) +} + +// ConsolidatePendingState is a paid mutator transaction binding the contract method 0x1608859c. +// +// Solidity: function consolidatePendingState(uint32 rollupID, uint64 pendingStateNum) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerSession) ConsolidatePendingState(rollupID uint32, pendingStateNum uint64) (*types.Transaction, error) { + return _Polygonrollupmanager.Contract.ConsolidatePendingState(&_Polygonrollupmanager.TransactOpts, rollupID, pendingStateNum) +} + +// ConsolidatePendingState is a paid mutator transaction binding the contract method 0x1608859c. +// +// Solidity: function consolidatePendingState(uint32 rollupID, uint64 pendingStateNum) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerTransactorSession) ConsolidatePendingState(rollupID uint32, pendingStateNum uint64) (*types.Transaction, error) { + return _Polygonrollupmanager.Contract.ConsolidatePendingState(&_Polygonrollupmanager.TransactOpts, rollupID, pendingStateNum) +} + +// CreateNewRollup is a paid mutator transaction binding the contract method 0x727885e9. +// +// Solidity: function createNewRollup(uint32 rollupTypeID, uint64 chainID, address admin, address sequencer, address gasTokenAddress, string sequencerURL, string networkName) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerTransactor) CreateNewRollup(opts *bind.TransactOpts, rollupTypeID uint32, chainID uint64, admin common.Address, sequencer common.Address, gasTokenAddress common.Address, sequencerURL string, networkName string) (*types.Transaction, error) { + return _Polygonrollupmanager.contract.Transact(opts, "createNewRollup", rollupTypeID, chainID, admin, sequencer, gasTokenAddress, sequencerURL, networkName) +} + +// CreateNewRollup is a paid mutator transaction binding the contract method 0x727885e9. +// +// Solidity: function createNewRollup(uint32 rollupTypeID, uint64 chainID, address admin, address sequencer, address gasTokenAddress, string sequencerURL, string networkName) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerSession) CreateNewRollup(rollupTypeID uint32, chainID uint64, admin common.Address, sequencer common.Address, gasTokenAddress common.Address, sequencerURL string, networkName string) (*types.Transaction, error) { + return _Polygonrollupmanager.Contract.CreateNewRollup(&_Polygonrollupmanager.TransactOpts, rollupTypeID, chainID, admin, sequencer, gasTokenAddress, sequencerURL, networkName) +} + +// CreateNewRollup is a paid mutator transaction binding the contract method 0x727885e9. +// +// Solidity: function createNewRollup(uint32 rollupTypeID, uint64 chainID, address admin, address sequencer, address gasTokenAddress, string sequencerURL, string networkName) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerTransactorSession) CreateNewRollup(rollupTypeID uint32, chainID uint64, admin common.Address, sequencer common.Address, gasTokenAddress common.Address, sequencerURL string, networkName string) (*types.Transaction, error) { + return _Polygonrollupmanager.Contract.CreateNewRollup(&_Polygonrollupmanager.TransactOpts, rollupTypeID, chainID, admin, sequencer, gasTokenAddress, sequencerURL, networkName) +} + +// DeactivateEmergencyState is a paid mutator transaction binding the contract method 0xdbc16976. +// +// Solidity: function deactivateEmergencyState() returns() +func (_Polygonrollupmanager *PolygonrollupmanagerTransactor) DeactivateEmergencyState(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Polygonrollupmanager.contract.Transact(opts, "deactivateEmergencyState") +} + +// DeactivateEmergencyState is a paid mutator transaction binding the contract method 0xdbc16976. +// +// Solidity: function deactivateEmergencyState() returns() +func (_Polygonrollupmanager *PolygonrollupmanagerSession) DeactivateEmergencyState() (*types.Transaction, error) { + return _Polygonrollupmanager.Contract.DeactivateEmergencyState(&_Polygonrollupmanager.TransactOpts) +} + +// DeactivateEmergencyState is a paid mutator transaction binding the contract method 0xdbc16976. +// +// Solidity: function deactivateEmergencyState() returns() +func (_Polygonrollupmanager *PolygonrollupmanagerTransactorSession) DeactivateEmergencyState() (*types.Transaction, error) { + return _Polygonrollupmanager.Contract.DeactivateEmergencyState(&_Polygonrollupmanager.TransactOpts) +} + +// GrantRole is a paid mutator transaction binding the contract method 0x2f2ff15d. +// +// Solidity: function grantRole(bytes32 role, address account) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerTransactor) GrantRole(opts *bind.TransactOpts, role [32]byte, account common.Address) (*types.Transaction, error) { + return _Polygonrollupmanager.contract.Transact(opts, "grantRole", role, account) +} + +// GrantRole is a paid mutator transaction binding the contract method 0x2f2ff15d. +// +// Solidity: function grantRole(bytes32 role, address account) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerSession) GrantRole(role [32]byte, account common.Address) (*types.Transaction, error) { + return _Polygonrollupmanager.Contract.GrantRole(&_Polygonrollupmanager.TransactOpts, role, account) +} + +// GrantRole is a paid mutator transaction binding the contract method 0x2f2ff15d. +// +// Solidity: function grantRole(bytes32 role, address account) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerTransactorSession) GrantRole(role [32]byte, account common.Address) (*types.Transaction, error) { + return _Polygonrollupmanager.Contract.GrantRole(&_Polygonrollupmanager.TransactOpts, role, account) +} + +// Initialize is a paid mutator transaction binding the contract method 0x0645af09. +// +// Solidity: function initialize(address trustedAggregator, uint64 _pendingStateTimeout, uint64 _trustedAggregatorTimeout, address admin, address timelock, address emergencyCouncil, address polygonZkEVM, address zkEVMVerifier, uint64 zkEVMForkID, uint64 zkEVMChainID) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerTransactor) Initialize(opts *bind.TransactOpts, trustedAggregator common.Address, _pendingStateTimeout uint64, _trustedAggregatorTimeout uint64, admin common.Address, timelock common.Address, emergencyCouncil common.Address, polygonZkEVM common.Address, zkEVMVerifier common.Address, zkEVMForkID uint64, zkEVMChainID uint64) (*types.Transaction, error) { + return _Polygonrollupmanager.contract.Transact(opts, "initialize", trustedAggregator, _pendingStateTimeout, _trustedAggregatorTimeout, admin, timelock, emergencyCouncil, polygonZkEVM, zkEVMVerifier, zkEVMForkID, zkEVMChainID) +} + +// Initialize is a paid mutator transaction binding the contract method 0x0645af09. +// +// Solidity: function initialize(address trustedAggregator, uint64 _pendingStateTimeout, uint64 _trustedAggregatorTimeout, address admin, address timelock, address emergencyCouncil, address polygonZkEVM, address zkEVMVerifier, uint64 zkEVMForkID, uint64 zkEVMChainID) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerSession) Initialize(trustedAggregator common.Address, _pendingStateTimeout uint64, _trustedAggregatorTimeout uint64, admin common.Address, timelock common.Address, emergencyCouncil common.Address, polygonZkEVM common.Address, zkEVMVerifier common.Address, zkEVMForkID uint64, zkEVMChainID uint64) (*types.Transaction, error) { + return _Polygonrollupmanager.Contract.Initialize(&_Polygonrollupmanager.TransactOpts, trustedAggregator, _pendingStateTimeout, _trustedAggregatorTimeout, admin, timelock, emergencyCouncil, polygonZkEVM, zkEVMVerifier, zkEVMForkID, zkEVMChainID) +} + +// Initialize is a paid mutator transaction binding the contract method 0x0645af09. +// +// Solidity: function initialize(address trustedAggregator, uint64 _pendingStateTimeout, uint64 _trustedAggregatorTimeout, address admin, address timelock, address emergencyCouncil, address polygonZkEVM, address zkEVMVerifier, uint64 zkEVMForkID, uint64 zkEVMChainID) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerTransactorSession) Initialize(trustedAggregator common.Address, _pendingStateTimeout uint64, _trustedAggregatorTimeout uint64, admin common.Address, timelock common.Address, emergencyCouncil common.Address, polygonZkEVM common.Address, zkEVMVerifier common.Address, zkEVMForkID uint64, zkEVMChainID uint64) (*types.Transaction, error) { + return _Polygonrollupmanager.Contract.Initialize(&_Polygonrollupmanager.TransactOpts, trustedAggregator, _pendingStateTimeout, _trustedAggregatorTimeout, admin, timelock, emergencyCouncil, polygonZkEVM, zkEVMVerifier, zkEVMForkID, zkEVMChainID) +} + +// ObsoleteRollupType is a paid mutator transaction binding the contract method 0x7222020f. +// +// Solidity: function obsoleteRollupType(uint32 rollupTypeID) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerTransactor) ObsoleteRollupType(opts *bind.TransactOpts, rollupTypeID uint32) (*types.Transaction, error) { + return _Polygonrollupmanager.contract.Transact(opts, "obsoleteRollupType", rollupTypeID) +} + +// ObsoleteRollupType is a paid mutator transaction binding the contract method 0x7222020f. +// +// Solidity: function obsoleteRollupType(uint32 rollupTypeID) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerSession) ObsoleteRollupType(rollupTypeID uint32) (*types.Transaction, error) { + return _Polygonrollupmanager.Contract.ObsoleteRollupType(&_Polygonrollupmanager.TransactOpts, rollupTypeID) +} + +// ObsoleteRollupType is a paid mutator transaction binding the contract method 0x7222020f. +// +// Solidity: function obsoleteRollupType(uint32 rollupTypeID) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerTransactorSession) ObsoleteRollupType(rollupTypeID uint32) (*types.Transaction, error) { + return _Polygonrollupmanager.Contract.ObsoleteRollupType(&_Polygonrollupmanager.TransactOpts, rollupTypeID) +} + +// OnSequenceBatches is a paid mutator transaction binding the contract method 0x9a908e73. +// +// Solidity: function onSequenceBatches(uint64 newSequencedBatches, bytes32 newAccInputHash) returns(uint64) +func (_Polygonrollupmanager *PolygonrollupmanagerTransactor) OnSequenceBatches(opts *bind.TransactOpts, newSequencedBatches uint64, newAccInputHash [32]byte) (*types.Transaction, error) { + return _Polygonrollupmanager.contract.Transact(opts, "onSequenceBatches", newSequencedBatches, newAccInputHash) +} + +// OnSequenceBatches is a paid mutator transaction binding the contract method 0x9a908e73. +// +// Solidity: function onSequenceBatches(uint64 newSequencedBatches, bytes32 newAccInputHash) returns(uint64) +func (_Polygonrollupmanager *PolygonrollupmanagerSession) OnSequenceBatches(newSequencedBatches uint64, newAccInputHash [32]byte) (*types.Transaction, error) { + return _Polygonrollupmanager.Contract.OnSequenceBatches(&_Polygonrollupmanager.TransactOpts, newSequencedBatches, newAccInputHash) +} + +// OnSequenceBatches is a paid mutator transaction binding the contract method 0x9a908e73. +// +// Solidity: function onSequenceBatches(uint64 newSequencedBatches, bytes32 newAccInputHash) returns(uint64) +func (_Polygonrollupmanager *PolygonrollupmanagerTransactorSession) OnSequenceBatches(newSequencedBatches uint64, newAccInputHash [32]byte) (*types.Transaction, error) { + return _Polygonrollupmanager.Contract.OnSequenceBatches(&_Polygonrollupmanager.TransactOpts, newSequencedBatches, newAccInputHash) +} + +// OverridePendingState is a paid mutator transaction binding the contract method 0x12b86e19. +// +// Solidity: function overridePendingState(uint32 rollupID, uint64 initPendingStateNum, uint64 finalPendingStateNum, uint64 initNumBatch, uint64 finalNewBatch, bytes32 newLocalExitRoot, bytes32 newStateRoot, bytes32[24] proof) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerTransactor) OverridePendingState(opts *bind.TransactOpts, rollupID uint32, initPendingStateNum uint64, finalPendingStateNum uint64, initNumBatch uint64, finalNewBatch uint64, newLocalExitRoot [32]byte, newStateRoot [32]byte, proof [24][32]byte) (*types.Transaction, error) { + return _Polygonrollupmanager.contract.Transact(opts, "overridePendingState", rollupID, initPendingStateNum, finalPendingStateNum, initNumBatch, finalNewBatch, newLocalExitRoot, newStateRoot, proof) +} + +// OverridePendingState is a paid mutator transaction binding the contract method 0x12b86e19. +// +// Solidity: function overridePendingState(uint32 rollupID, uint64 initPendingStateNum, uint64 finalPendingStateNum, uint64 initNumBatch, uint64 finalNewBatch, bytes32 newLocalExitRoot, bytes32 newStateRoot, bytes32[24] proof) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerSession) OverridePendingState(rollupID uint32, initPendingStateNum uint64, finalPendingStateNum uint64, initNumBatch uint64, finalNewBatch uint64, newLocalExitRoot [32]byte, newStateRoot [32]byte, proof [24][32]byte) (*types.Transaction, error) { + return _Polygonrollupmanager.Contract.OverridePendingState(&_Polygonrollupmanager.TransactOpts, rollupID, initPendingStateNum, finalPendingStateNum, initNumBatch, finalNewBatch, newLocalExitRoot, newStateRoot, proof) +} + +// OverridePendingState is a paid mutator transaction binding the contract method 0x12b86e19. +// +// Solidity: function overridePendingState(uint32 rollupID, uint64 initPendingStateNum, uint64 finalPendingStateNum, uint64 initNumBatch, uint64 finalNewBatch, bytes32 newLocalExitRoot, bytes32 newStateRoot, bytes32[24] proof) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerTransactorSession) OverridePendingState(rollupID uint32, initPendingStateNum uint64, finalPendingStateNum uint64, initNumBatch uint64, finalNewBatch uint64, newLocalExitRoot [32]byte, newStateRoot [32]byte, proof [24][32]byte) (*types.Transaction, error) { + return _Polygonrollupmanager.Contract.OverridePendingState(&_Polygonrollupmanager.TransactOpts, rollupID, initPendingStateNum, finalPendingStateNum, initNumBatch, finalNewBatch, newLocalExitRoot, newStateRoot, proof) +} + +// ProveNonDeterministicPendingState is a paid mutator transaction binding the contract method 0x8bd4f071. +// +// Solidity: function proveNonDeterministicPendingState(uint32 rollupID, uint64 initPendingStateNum, uint64 finalPendingStateNum, uint64 initNumBatch, uint64 finalNewBatch, bytes32 newLocalExitRoot, bytes32 newStateRoot, bytes32[24] proof) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerTransactor) ProveNonDeterministicPendingState(opts *bind.TransactOpts, rollupID uint32, initPendingStateNum uint64, finalPendingStateNum uint64, initNumBatch uint64, finalNewBatch uint64, newLocalExitRoot [32]byte, newStateRoot [32]byte, proof [24][32]byte) (*types.Transaction, error) { + return _Polygonrollupmanager.contract.Transact(opts, "proveNonDeterministicPendingState", rollupID, initPendingStateNum, finalPendingStateNum, initNumBatch, finalNewBatch, newLocalExitRoot, newStateRoot, proof) +} + +// ProveNonDeterministicPendingState is a paid mutator transaction binding the contract method 0x8bd4f071. +// +// Solidity: function proveNonDeterministicPendingState(uint32 rollupID, uint64 initPendingStateNum, uint64 finalPendingStateNum, uint64 initNumBatch, uint64 finalNewBatch, bytes32 newLocalExitRoot, bytes32 newStateRoot, bytes32[24] proof) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerSession) ProveNonDeterministicPendingState(rollupID uint32, initPendingStateNum uint64, finalPendingStateNum uint64, initNumBatch uint64, finalNewBatch uint64, newLocalExitRoot [32]byte, newStateRoot [32]byte, proof [24][32]byte) (*types.Transaction, error) { + return _Polygonrollupmanager.Contract.ProveNonDeterministicPendingState(&_Polygonrollupmanager.TransactOpts, rollupID, initPendingStateNum, finalPendingStateNum, initNumBatch, finalNewBatch, newLocalExitRoot, newStateRoot, proof) +} + +// ProveNonDeterministicPendingState is a paid mutator transaction binding the contract method 0x8bd4f071. +// +// Solidity: function proveNonDeterministicPendingState(uint32 rollupID, uint64 initPendingStateNum, uint64 finalPendingStateNum, uint64 initNumBatch, uint64 finalNewBatch, bytes32 newLocalExitRoot, bytes32 newStateRoot, bytes32[24] proof) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerTransactorSession) ProveNonDeterministicPendingState(rollupID uint32, initPendingStateNum uint64, finalPendingStateNum uint64, initNumBatch uint64, finalNewBatch uint64, newLocalExitRoot [32]byte, newStateRoot [32]byte, proof [24][32]byte) (*types.Transaction, error) { + return _Polygonrollupmanager.Contract.ProveNonDeterministicPendingState(&_Polygonrollupmanager.TransactOpts, rollupID, initPendingStateNum, finalPendingStateNum, initNumBatch, finalNewBatch, newLocalExitRoot, newStateRoot, proof) +} + +// RenounceRole is a paid mutator transaction binding the contract method 0x36568abe. +// +// Solidity: function renounceRole(bytes32 role, address account) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerTransactor) RenounceRole(opts *bind.TransactOpts, role [32]byte, account common.Address) (*types.Transaction, error) { + return _Polygonrollupmanager.contract.Transact(opts, "renounceRole", role, account) +} + +// RenounceRole is a paid mutator transaction binding the contract method 0x36568abe. +// +// Solidity: function renounceRole(bytes32 role, address account) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerSession) RenounceRole(role [32]byte, account common.Address) (*types.Transaction, error) { + return _Polygonrollupmanager.Contract.RenounceRole(&_Polygonrollupmanager.TransactOpts, role, account) +} + +// RenounceRole is a paid mutator transaction binding the contract method 0x36568abe. +// +// Solidity: function renounceRole(bytes32 role, address account) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerTransactorSession) RenounceRole(role [32]byte, account common.Address) (*types.Transaction, error) { + return _Polygonrollupmanager.Contract.RenounceRole(&_Polygonrollupmanager.TransactOpts, role, account) +} + +// RevokeRole is a paid mutator transaction binding the contract method 0xd547741f. +// +// Solidity: function revokeRole(bytes32 role, address account) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerTransactor) RevokeRole(opts *bind.TransactOpts, role [32]byte, account common.Address) (*types.Transaction, error) { + return _Polygonrollupmanager.contract.Transact(opts, "revokeRole", role, account) +} + +// RevokeRole is a paid mutator transaction binding the contract method 0xd547741f. +// +// Solidity: function revokeRole(bytes32 role, address account) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerSession) RevokeRole(role [32]byte, account common.Address) (*types.Transaction, error) { + return _Polygonrollupmanager.Contract.RevokeRole(&_Polygonrollupmanager.TransactOpts, role, account) +} + +// RevokeRole is a paid mutator transaction binding the contract method 0xd547741f. +// +// Solidity: function revokeRole(bytes32 role, address account) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerTransactorSession) RevokeRole(role [32]byte, account common.Address) (*types.Transaction, error) { + return _Polygonrollupmanager.Contract.RevokeRole(&_Polygonrollupmanager.TransactOpts, role, account) +} + +// SetBatchFee is a paid mutator transaction binding the contract method 0xd5073f6f. +// +// Solidity: function setBatchFee(uint256 newBatchFee) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerTransactor) SetBatchFee(opts *bind.TransactOpts, newBatchFee *big.Int) (*types.Transaction, error) { + return _Polygonrollupmanager.contract.Transact(opts, "setBatchFee", newBatchFee) +} + +// SetBatchFee is a paid mutator transaction binding the contract method 0xd5073f6f. +// +// Solidity: function setBatchFee(uint256 newBatchFee) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerSession) SetBatchFee(newBatchFee *big.Int) (*types.Transaction, error) { + return _Polygonrollupmanager.Contract.SetBatchFee(&_Polygonrollupmanager.TransactOpts, newBatchFee) +} + +// SetBatchFee is a paid mutator transaction binding the contract method 0xd5073f6f. +// +// Solidity: function setBatchFee(uint256 newBatchFee) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerTransactorSession) SetBatchFee(newBatchFee *big.Int) (*types.Transaction, error) { + return _Polygonrollupmanager.Contract.SetBatchFee(&_Polygonrollupmanager.TransactOpts, newBatchFee) +} + +// SetMultiplierBatchFee is a paid mutator transaction binding the contract method 0x1816b7e5. +// +// Solidity: function setMultiplierBatchFee(uint16 newMultiplierBatchFee) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerTransactor) SetMultiplierBatchFee(opts *bind.TransactOpts, newMultiplierBatchFee uint16) (*types.Transaction, error) { + return _Polygonrollupmanager.contract.Transact(opts, "setMultiplierBatchFee", newMultiplierBatchFee) +} + +// SetMultiplierBatchFee is a paid mutator transaction binding the contract method 0x1816b7e5. +// +// Solidity: function setMultiplierBatchFee(uint16 newMultiplierBatchFee) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerSession) SetMultiplierBatchFee(newMultiplierBatchFee uint16) (*types.Transaction, error) { + return _Polygonrollupmanager.Contract.SetMultiplierBatchFee(&_Polygonrollupmanager.TransactOpts, newMultiplierBatchFee) +} + +// SetMultiplierBatchFee is a paid mutator transaction binding the contract method 0x1816b7e5. +// +// Solidity: function setMultiplierBatchFee(uint16 newMultiplierBatchFee) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerTransactorSession) SetMultiplierBatchFee(newMultiplierBatchFee uint16) (*types.Transaction, error) { + return _Polygonrollupmanager.Contract.SetMultiplierBatchFee(&_Polygonrollupmanager.TransactOpts, newMultiplierBatchFee) +} + +// SetPendingStateTimeout is a paid mutator transaction binding the contract method 0x9c9f3dfe. +// +// Solidity: function setPendingStateTimeout(uint64 newPendingStateTimeout) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerTransactor) SetPendingStateTimeout(opts *bind.TransactOpts, newPendingStateTimeout uint64) (*types.Transaction, error) { + return _Polygonrollupmanager.contract.Transact(opts, "setPendingStateTimeout", newPendingStateTimeout) +} + +// SetPendingStateTimeout is a paid mutator transaction binding the contract method 0x9c9f3dfe. +// +// Solidity: function setPendingStateTimeout(uint64 newPendingStateTimeout) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerSession) SetPendingStateTimeout(newPendingStateTimeout uint64) (*types.Transaction, error) { + return _Polygonrollupmanager.Contract.SetPendingStateTimeout(&_Polygonrollupmanager.TransactOpts, newPendingStateTimeout) +} + +// SetPendingStateTimeout is a paid mutator transaction binding the contract method 0x9c9f3dfe. +// +// Solidity: function setPendingStateTimeout(uint64 newPendingStateTimeout) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerTransactorSession) SetPendingStateTimeout(newPendingStateTimeout uint64) (*types.Transaction, error) { + return _Polygonrollupmanager.Contract.SetPendingStateTimeout(&_Polygonrollupmanager.TransactOpts, newPendingStateTimeout) +} + +// SetTrustedAggregatorTimeout is a paid mutator transaction binding the contract method 0x394218e9. +// +// Solidity: function setTrustedAggregatorTimeout(uint64 newTrustedAggregatorTimeout) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerTransactor) SetTrustedAggregatorTimeout(opts *bind.TransactOpts, newTrustedAggregatorTimeout uint64) (*types.Transaction, error) { + return _Polygonrollupmanager.contract.Transact(opts, "setTrustedAggregatorTimeout", newTrustedAggregatorTimeout) +} + +// SetTrustedAggregatorTimeout is a paid mutator transaction binding the contract method 0x394218e9. +// +// Solidity: function setTrustedAggregatorTimeout(uint64 newTrustedAggregatorTimeout) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerSession) SetTrustedAggregatorTimeout(newTrustedAggregatorTimeout uint64) (*types.Transaction, error) { + return _Polygonrollupmanager.Contract.SetTrustedAggregatorTimeout(&_Polygonrollupmanager.TransactOpts, newTrustedAggregatorTimeout) +} + +// SetTrustedAggregatorTimeout is a paid mutator transaction binding the contract method 0x394218e9. +// +// Solidity: function setTrustedAggregatorTimeout(uint64 newTrustedAggregatorTimeout) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerTransactorSession) SetTrustedAggregatorTimeout(newTrustedAggregatorTimeout uint64) (*types.Transaction, error) { + return _Polygonrollupmanager.Contract.SetTrustedAggregatorTimeout(&_Polygonrollupmanager.TransactOpts, newTrustedAggregatorTimeout) +} + +// SetVerifyBatchTimeTarget is a paid mutator transaction binding the contract method 0xa066215c. +// +// Solidity: function setVerifyBatchTimeTarget(uint64 newVerifyBatchTimeTarget) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerTransactor) SetVerifyBatchTimeTarget(opts *bind.TransactOpts, newVerifyBatchTimeTarget uint64) (*types.Transaction, error) { + return _Polygonrollupmanager.contract.Transact(opts, "setVerifyBatchTimeTarget", newVerifyBatchTimeTarget) +} + +// SetVerifyBatchTimeTarget is a paid mutator transaction binding the contract method 0xa066215c. +// +// Solidity: function setVerifyBatchTimeTarget(uint64 newVerifyBatchTimeTarget) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerSession) SetVerifyBatchTimeTarget(newVerifyBatchTimeTarget uint64) (*types.Transaction, error) { + return _Polygonrollupmanager.Contract.SetVerifyBatchTimeTarget(&_Polygonrollupmanager.TransactOpts, newVerifyBatchTimeTarget) +} + +// SetVerifyBatchTimeTarget is a paid mutator transaction binding the contract method 0xa066215c. +// +// Solidity: function setVerifyBatchTimeTarget(uint64 newVerifyBatchTimeTarget) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerTransactorSession) SetVerifyBatchTimeTarget(newVerifyBatchTimeTarget uint64) (*types.Transaction, error) { + return _Polygonrollupmanager.Contract.SetVerifyBatchTimeTarget(&_Polygonrollupmanager.TransactOpts, newVerifyBatchTimeTarget) +} + +// UpdateRollup is a paid mutator transaction binding the contract method 0xc4c928c2. +// +// Solidity: function updateRollup(address rollupContract, uint32 newRollupTypeID, bytes upgradeData) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerTransactor) UpdateRollup(opts *bind.TransactOpts, rollupContract common.Address, newRollupTypeID uint32, upgradeData []byte) (*types.Transaction, error) { + return _Polygonrollupmanager.contract.Transact(opts, "updateRollup", rollupContract, newRollupTypeID, upgradeData) +} + +// UpdateRollup is a paid mutator transaction binding the contract method 0xc4c928c2. +// +// Solidity: function updateRollup(address rollupContract, uint32 newRollupTypeID, bytes upgradeData) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerSession) UpdateRollup(rollupContract common.Address, newRollupTypeID uint32, upgradeData []byte) (*types.Transaction, error) { + return _Polygonrollupmanager.Contract.UpdateRollup(&_Polygonrollupmanager.TransactOpts, rollupContract, newRollupTypeID, upgradeData) +} + +// UpdateRollup is a paid mutator transaction binding the contract method 0xc4c928c2. +// +// Solidity: function updateRollup(address rollupContract, uint32 newRollupTypeID, bytes upgradeData) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerTransactorSession) UpdateRollup(rollupContract common.Address, newRollupTypeID uint32, upgradeData []byte) (*types.Transaction, error) { + return _Polygonrollupmanager.Contract.UpdateRollup(&_Polygonrollupmanager.TransactOpts, rollupContract, newRollupTypeID, upgradeData) +} + +// VerifyBatches is a paid mutator transaction binding the contract method 0x87c20c01. +// +// Solidity: function verifyBatches(uint32 rollupID, uint64 pendingStateNum, uint64 initNumBatch, uint64 finalNewBatch, bytes32 newLocalExitRoot, bytes32 newStateRoot, address beneficiary, bytes32[24] proof) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerTransactor) VerifyBatches(opts *bind.TransactOpts, rollupID uint32, pendingStateNum uint64, initNumBatch uint64, finalNewBatch uint64, newLocalExitRoot [32]byte, newStateRoot [32]byte, beneficiary common.Address, proof [24][32]byte) (*types.Transaction, error) { + return _Polygonrollupmanager.contract.Transact(opts, "verifyBatches", rollupID, pendingStateNum, initNumBatch, finalNewBatch, newLocalExitRoot, newStateRoot, beneficiary, proof) +} + +// VerifyBatches is a paid mutator transaction binding the contract method 0x87c20c01. +// +// Solidity: function verifyBatches(uint32 rollupID, uint64 pendingStateNum, uint64 initNumBatch, uint64 finalNewBatch, bytes32 newLocalExitRoot, bytes32 newStateRoot, address beneficiary, bytes32[24] proof) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerSession) VerifyBatches(rollupID uint32, pendingStateNum uint64, initNumBatch uint64, finalNewBatch uint64, newLocalExitRoot [32]byte, newStateRoot [32]byte, beneficiary common.Address, proof [24][32]byte) (*types.Transaction, error) { + return _Polygonrollupmanager.Contract.VerifyBatches(&_Polygonrollupmanager.TransactOpts, rollupID, pendingStateNum, initNumBatch, finalNewBatch, newLocalExitRoot, newStateRoot, beneficiary, proof) +} + +// VerifyBatches is a paid mutator transaction binding the contract method 0x87c20c01. +// +// Solidity: function verifyBatches(uint32 rollupID, uint64 pendingStateNum, uint64 initNumBatch, uint64 finalNewBatch, bytes32 newLocalExitRoot, bytes32 newStateRoot, address beneficiary, bytes32[24] proof) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerTransactorSession) VerifyBatches(rollupID uint32, pendingStateNum uint64, initNumBatch uint64, finalNewBatch uint64, newLocalExitRoot [32]byte, newStateRoot [32]byte, beneficiary common.Address, proof [24][32]byte) (*types.Transaction, error) { + return _Polygonrollupmanager.Contract.VerifyBatches(&_Polygonrollupmanager.TransactOpts, rollupID, pendingStateNum, initNumBatch, finalNewBatch, newLocalExitRoot, newStateRoot, beneficiary, proof) +} + +// VerifyBatchesTrustedAggregator is a paid mutator transaction binding the contract method 0x1489ed10. +// +// Solidity: function verifyBatchesTrustedAggregator(uint32 rollupID, uint64 pendingStateNum, uint64 initNumBatch, uint64 finalNewBatch, bytes32 newLocalExitRoot, bytes32 newStateRoot, address beneficiary, bytes32[24] proof) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerTransactor) VerifyBatchesTrustedAggregator(opts *bind.TransactOpts, rollupID uint32, pendingStateNum uint64, initNumBatch uint64, finalNewBatch uint64, newLocalExitRoot [32]byte, newStateRoot [32]byte, beneficiary common.Address, proof [24][32]byte) (*types.Transaction, error) { + return _Polygonrollupmanager.contract.Transact(opts, "verifyBatchesTrustedAggregator", rollupID, pendingStateNum, initNumBatch, finalNewBatch, newLocalExitRoot, newStateRoot, beneficiary, proof) +} + +// VerifyBatchesTrustedAggregator is a paid mutator transaction binding the contract method 0x1489ed10. +// +// Solidity: function verifyBatchesTrustedAggregator(uint32 rollupID, uint64 pendingStateNum, uint64 initNumBatch, uint64 finalNewBatch, bytes32 newLocalExitRoot, bytes32 newStateRoot, address beneficiary, bytes32[24] proof) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerSession) VerifyBatchesTrustedAggregator(rollupID uint32, pendingStateNum uint64, initNumBatch uint64, finalNewBatch uint64, newLocalExitRoot [32]byte, newStateRoot [32]byte, beneficiary common.Address, proof [24][32]byte) (*types.Transaction, error) { + return _Polygonrollupmanager.Contract.VerifyBatchesTrustedAggregator(&_Polygonrollupmanager.TransactOpts, rollupID, pendingStateNum, initNumBatch, finalNewBatch, newLocalExitRoot, newStateRoot, beneficiary, proof) +} + +// VerifyBatchesTrustedAggregator is a paid mutator transaction binding the contract method 0x1489ed10. +// +// Solidity: function verifyBatchesTrustedAggregator(uint32 rollupID, uint64 pendingStateNum, uint64 initNumBatch, uint64 finalNewBatch, bytes32 newLocalExitRoot, bytes32 newStateRoot, address beneficiary, bytes32[24] proof) returns() +func (_Polygonrollupmanager *PolygonrollupmanagerTransactorSession) VerifyBatchesTrustedAggregator(rollupID uint32, pendingStateNum uint64, initNumBatch uint64, finalNewBatch uint64, newLocalExitRoot [32]byte, newStateRoot [32]byte, beneficiary common.Address, proof [24][32]byte) (*types.Transaction, error) { + return _Polygonrollupmanager.Contract.VerifyBatchesTrustedAggregator(&_Polygonrollupmanager.TransactOpts, rollupID, pendingStateNum, initNumBatch, finalNewBatch, newLocalExitRoot, newStateRoot, beneficiary, proof) +} + +// PolygonrollupmanagerAddExistingRollupIterator is returned from FilterAddExistingRollup and is used to iterate over the raw logs and unpacked data for AddExistingRollup events raised by the Polygonrollupmanager contract. +type PolygonrollupmanagerAddExistingRollupIterator struct { + Event *PolygonrollupmanagerAddExistingRollup // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PolygonrollupmanagerAddExistingRollupIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PolygonrollupmanagerAddExistingRollup) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PolygonrollupmanagerAddExistingRollup) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PolygonrollupmanagerAddExistingRollupIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolygonrollupmanagerAddExistingRollupIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolygonrollupmanagerAddExistingRollup represents a AddExistingRollup event raised by the Polygonrollupmanager contract. +type PolygonrollupmanagerAddExistingRollup struct { + RollupID uint32 + ForkID uint64 + RollupAddress common.Address + ChainID uint64 + RollupCompatibilityID uint8 + LastVerifiedBatchBeforeUpgrade uint64 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterAddExistingRollup is a free log retrieval operation binding the contract event 0xadfc7d56f7e39b08b321534f14bfb135ad27698f7d2f5ad0edc2356ea9a3f850. +// +// Solidity: event AddExistingRollup(uint32 indexed rollupID, uint64 forkID, address rollupAddress, uint64 chainID, uint8 rollupCompatibilityID, uint64 lastVerifiedBatchBeforeUpgrade) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) FilterAddExistingRollup(opts *bind.FilterOpts, rollupID []uint32) (*PolygonrollupmanagerAddExistingRollupIterator, error) { + + var rollupIDRule []interface{} + for _, rollupIDItem := range rollupID { + rollupIDRule = append(rollupIDRule, rollupIDItem) + } + + logs, sub, err := _Polygonrollupmanager.contract.FilterLogs(opts, "AddExistingRollup", rollupIDRule) + if err != nil { + return nil, err + } + return &PolygonrollupmanagerAddExistingRollupIterator{contract: _Polygonrollupmanager.contract, event: "AddExistingRollup", logs: logs, sub: sub}, nil +} + +// WatchAddExistingRollup is a free log subscription operation binding the contract event 0xadfc7d56f7e39b08b321534f14bfb135ad27698f7d2f5ad0edc2356ea9a3f850. +// +// Solidity: event AddExistingRollup(uint32 indexed rollupID, uint64 forkID, address rollupAddress, uint64 chainID, uint8 rollupCompatibilityID, uint64 lastVerifiedBatchBeforeUpgrade) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) WatchAddExistingRollup(opts *bind.WatchOpts, sink chan<- *PolygonrollupmanagerAddExistingRollup, rollupID []uint32) (event.Subscription, error) { + + var rollupIDRule []interface{} + for _, rollupIDItem := range rollupID { + rollupIDRule = append(rollupIDRule, rollupIDItem) + } + + logs, sub, err := _Polygonrollupmanager.contract.WatchLogs(opts, "AddExistingRollup", rollupIDRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PolygonrollupmanagerAddExistingRollup) + if err := _Polygonrollupmanager.contract.UnpackLog(event, "AddExistingRollup", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseAddExistingRollup is a log parse operation binding the contract event 0xadfc7d56f7e39b08b321534f14bfb135ad27698f7d2f5ad0edc2356ea9a3f850. +// +// Solidity: event AddExistingRollup(uint32 indexed rollupID, uint64 forkID, address rollupAddress, uint64 chainID, uint8 rollupCompatibilityID, uint64 lastVerifiedBatchBeforeUpgrade) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) ParseAddExistingRollup(log types.Log) (*PolygonrollupmanagerAddExistingRollup, error) { + event := new(PolygonrollupmanagerAddExistingRollup) + if err := _Polygonrollupmanager.contract.UnpackLog(event, "AddExistingRollup", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PolygonrollupmanagerAddNewRollupTypeIterator is returned from FilterAddNewRollupType and is used to iterate over the raw logs and unpacked data for AddNewRollupType events raised by the Polygonrollupmanager contract. +type PolygonrollupmanagerAddNewRollupTypeIterator struct { + Event *PolygonrollupmanagerAddNewRollupType // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PolygonrollupmanagerAddNewRollupTypeIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PolygonrollupmanagerAddNewRollupType) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PolygonrollupmanagerAddNewRollupType) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PolygonrollupmanagerAddNewRollupTypeIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolygonrollupmanagerAddNewRollupTypeIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolygonrollupmanagerAddNewRollupType represents a AddNewRollupType event raised by the Polygonrollupmanager contract. +type PolygonrollupmanagerAddNewRollupType struct { + RollupTypeID uint32 + ConsensusImplementation common.Address + Verifier common.Address + ForkID uint64 + RollupCompatibilityID uint8 + Genesis [32]byte + Description string + Raw types.Log // Blockchain specific contextual infos +} + +// FilterAddNewRollupType is a free log retrieval operation binding the contract event 0xa2970448b3bd66ba7e524e7b2a5b9cf94fa29e32488fb942afdfe70dd4b77b52. +// +// Solidity: event AddNewRollupType(uint32 indexed rollupTypeID, address consensusImplementation, address verifier, uint64 forkID, uint8 rollupCompatibilityID, bytes32 genesis, string description) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) FilterAddNewRollupType(opts *bind.FilterOpts, rollupTypeID []uint32) (*PolygonrollupmanagerAddNewRollupTypeIterator, error) { + + var rollupTypeIDRule []interface{} + for _, rollupTypeIDItem := range rollupTypeID { + rollupTypeIDRule = append(rollupTypeIDRule, rollupTypeIDItem) + } + + logs, sub, err := _Polygonrollupmanager.contract.FilterLogs(opts, "AddNewRollupType", rollupTypeIDRule) + if err != nil { + return nil, err + } + return &PolygonrollupmanagerAddNewRollupTypeIterator{contract: _Polygonrollupmanager.contract, event: "AddNewRollupType", logs: logs, sub: sub}, nil +} + +// WatchAddNewRollupType is a free log subscription operation binding the contract event 0xa2970448b3bd66ba7e524e7b2a5b9cf94fa29e32488fb942afdfe70dd4b77b52. +// +// Solidity: event AddNewRollupType(uint32 indexed rollupTypeID, address consensusImplementation, address verifier, uint64 forkID, uint8 rollupCompatibilityID, bytes32 genesis, string description) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) WatchAddNewRollupType(opts *bind.WatchOpts, sink chan<- *PolygonrollupmanagerAddNewRollupType, rollupTypeID []uint32) (event.Subscription, error) { + + var rollupTypeIDRule []interface{} + for _, rollupTypeIDItem := range rollupTypeID { + rollupTypeIDRule = append(rollupTypeIDRule, rollupTypeIDItem) + } + + logs, sub, err := _Polygonrollupmanager.contract.WatchLogs(opts, "AddNewRollupType", rollupTypeIDRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PolygonrollupmanagerAddNewRollupType) + if err := _Polygonrollupmanager.contract.UnpackLog(event, "AddNewRollupType", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseAddNewRollupType is a log parse operation binding the contract event 0xa2970448b3bd66ba7e524e7b2a5b9cf94fa29e32488fb942afdfe70dd4b77b52. +// +// Solidity: event AddNewRollupType(uint32 indexed rollupTypeID, address consensusImplementation, address verifier, uint64 forkID, uint8 rollupCompatibilityID, bytes32 genesis, string description) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) ParseAddNewRollupType(log types.Log) (*PolygonrollupmanagerAddNewRollupType, error) { + event := new(PolygonrollupmanagerAddNewRollupType) + if err := _Polygonrollupmanager.contract.UnpackLog(event, "AddNewRollupType", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PolygonrollupmanagerConsolidatePendingStateIterator is returned from FilterConsolidatePendingState and is used to iterate over the raw logs and unpacked data for ConsolidatePendingState events raised by the Polygonrollupmanager contract. +type PolygonrollupmanagerConsolidatePendingStateIterator struct { + Event *PolygonrollupmanagerConsolidatePendingState // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PolygonrollupmanagerConsolidatePendingStateIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PolygonrollupmanagerConsolidatePendingState) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PolygonrollupmanagerConsolidatePendingState) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PolygonrollupmanagerConsolidatePendingStateIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolygonrollupmanagerConsolidatePendingStateIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolygonrollupmanagerConsolidatePendingState represents a ConsolidatePendingState event raised by the Polygonrollupmanager contract. +type PolygonrollupmanagerConsolidatePendingState struct { + RollupID uint32 + NumBatch uint64 + StateRoot [32]byte + ExitRoot [32]byte + PendingStateNum uint64 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterConsolidatePendingState is a free log retrieval operation binding the contract event 0x581910eb7a27738945c2f00a91f2284b2d6de9d4e472b12f901c2b0df045e21b. +// +// Solidity: event ConsolidatePendingState(uint32 indexed rollupID, uint64 numBatch, bytes32 stateRoot, bytes32 exitRoot, uint64 pendingStateNum) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) FilterConsolidatePendingState(opts *bind.FilterOpts, rollupID []uint32) (*PolygonrollupmanagerConsolidatePendingStateIterator, error) { + + var rollupIDRule []interface{} + for _, rollupIDItem := range rollupID { + rollupIDRule = append(rollupIDRule, rollupIDItem) + } + + logs, sub, err := _Polygonrollupmanager.contract.FilterLogs(opts, "ConsolidatePendingState", rollupIDRule) + if err != nil { + return nil, err + } + return &PolygonrollupmanagerConsolidatePendingStateIterator{contract: _Polygonrollupmanager.contract, event: "ConsolidatePendingState", logs: logs, sub: sub}, nil +} + +// WatchConsolidatePendingState is a free log subscription operation binding the contract event 0x581910eb7a27738945c2f00a91f2284b2d6de9d4e472b12f901c2b0df045e21b. +// +// Solidity: event ConsolidatePendingState(uint32 indexed rollupID, uint64 numBatch, bytes32 stateRoot, bytes32 exitRoot, uint64 pendingStateNum) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) WatchConsolidatePendingState(opts *bind.WatchOpts, sink chan<- *PolygonrollupmanagerConsolidatePendingState, rollupID []uint32) (event.Subscription, error) { + + var rollupIDRule []interface{} + for _, rollupIDItem := range rollupID { + rollupIDRule = append(rollupIDRule, rollupIDItem) + } + + logs, sub, err := _Polygonrollupmanager.contract.WatchLogs(opts, "ConsolidatePendingState", rollupIDRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PolygonrollupmanagerConsolidatePendingState) + if err := _Polygonrollupmanager.contract.UnpackLog(event, "ConsolidatePendingState", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseConsolidatePendingState is a log parse operation binding the contract event 0x581910eb7a27738945c2f00a91f2284b2d6de9d4e472b12f901c2b0df045e21b. +// +// Solidity: event ConsolidatePendingState(uint32 indexed rollupID, uint64 numBatch, bytes32 stateRoot, bytes32 exitRoot, uint64 pendingStateNum) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) ParseConsolidatePendingState(log types.Log) (*PolygonrollupmanagerConsolidatePendingState, error) { + event := new(PolygonrollupmanagerConsolidatePendingState) + if err := _Polygonrollupmanager.contract.UnpackLog(event, "ConsolidatePendingState", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PolygonrollupmanagerCreateNewRollupIterator is returned from FilterCreateNewRollup and is used to iterate over the raw logs and unpacked data for CreateNewRollup events raised by the Polygonrollupmanager contract. +type PolygonrollupmanagerCreateNewRollupIterator struct { + Event *PolygonrollupmanagerCreateNewRollup // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PolygonrollupmanagerCreateNewRollupIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PolygonrollupmanagerCreateNewRollup) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PolygonrollupmanagerCreateNewRollup) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PolygonrollupmanagerCreateNewRollupIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolygonrollupmanagerCreateNewRollupIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolygonrollupmanagerCreateNewRollup represents a CreateNewRollup event raised by the Polygonrollupmanager contract. +type PolygonrollupmanagerCreateNewRollup struct { + RollupID uint32 + RollupTypeID uint32 + RollupAddress common.Address + ChainID uint64 + GasTokenAddress common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterCreateNewRollup is a free log retrieval operation binding the contract event 0x194c983456df6701c6a50830b90fe80e72b823411d0d524970c9590dc277a641. +// +// Solidity: event CreateNewRollup(uint32 indexed rollupID, uint32 rollupTypeID, address rollupAddress, uint64 chainID, address gasTokenAddress) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) FilterCreateNewRollup(opts *bind.FilterOpts, rollupID []uint32) (*PolygonrollupmanagerCreateNewRollupIterator, error) { + + var rollupIDRule []interface{} + for _, rollupIDItem := range rollupID { + rollupIDRule = append(rollupIDRule, rollupIDItem) + } + + logs, sub, err := _Polygonrollupmanager.contract.FilterLogs(opts, "CreateNewRollup", rollupIDRule) + if err != nil { + return nil, err + } + return &PolygonrollupmanagerCreateNewRollupIterator{contract: _Polygonrollupmanager.contract, event: "CreateNewRollup", logs: logs, sub: sub}, nil +} + +// WatchCreateNewRollup is a free log subscription operation binding the contract event 0x194c983456df6701c6a50830b90fe80e72b823411d0d524970c9590dc277a641. +// +// Solidity: event CreateNewRollup(uint32 indexed rollupID, uint32 rollupTypeID, address rollupAddress, uint64 chainID, address gasTokenAddress) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) WatchCreateNewRollup(opts *bind.WatchOpts, sink chan<- *PolygonrollupmanagerCreateNewRollup, rollupID []uint32) (event.Subscription, error) { + + var rollupIDRule []interface{} + for _, rollupIDItem := range rollupID { + rollupIDRule = append(rollupIDRule, rollupIDItem) + } + + logs, sub, err := _Polygonrollupmanager.contract.WatchLogs(opts, "CreateNewRollup", rollupIDRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PolygonrollupmanagerCreateNewRollup) + if err := _Polygonrollupmanager.contract.UnpackLog(event, "CreateNewRollup", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseCreateNewRollup is a log parse operation binding the contract event 0x194c983456df6701c6a50830b90fe80e72b823411d0d524970c9590dc277a641. +// +// Solidity: event CreateNewRollup(uint32 indexed rollupID, uint32 rollupTypeID, address rollupAddress, uint64 chainID, address gasTokenAddress) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) ParseCreateNewRollup(log types.Log) (*PolygonrollupmanagerCreateNewRollup, error) { + event := new(PolygonrollupmanagerCreateNewRollup) + if err := _Polygonrollupmanager.contract.UnpackLog(event, "CreateNewRollup", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PolygonrollupmanagerEmergencyStateActivatedIterator is returned from FilterEmergencyStateActivated and is used to iterate over the raw logs and unpacked data for EmergencyStateActivated events raised by the Polygonrollupmanager contract. +type PolygonrollupmanagerEmergencyStateActivatedIterator struct { + Event *PolygonrollupmanagerEmergencyStateActivated // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PolygonrollupmanagerEmergencyStateActivatedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PolygonrollupmanagerEmergencyStateActivated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PolygonrollupmanagerEmergencyStateActivated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PolygonrollupmanagerEmergencyStateActivatedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolygonrollupmanagerEmergencyStateActivatedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolygonrollupmanagerEmergencyStateActivated represents a EmergencyStateActivated event raised by the Polygonrollupmanager contract. +type PolygonrollupmanagerEmergencyStateActivated struct { + Raw types.Log // Blockchain specific contextual infos +} + +// FilterEmergencyStateActivated is a free log retrieval operation binding the contract event 0x2261efe5aef6fedc1fd1550b25facc9181745623049c7901287030b9ad1a5497. +// +// Solidity: event EmergencyStateActivated() +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) FilterEmergencyStateActivated(opts *bind.FilterOpts) (*PolygonrollupmanagerEmergencyStateActivatedIterator, error) { + + logs, sub, err := _Polygonrollupmanager.contract.FilterLogs(opts, "EmergencyStateActivated") + if err != nil { + return nil, err + } + return &PolygonrollupmanagerEmergencyStateActivatedIterator{contract: _Polygonrollupmanager.contract, event: "EmergencyStateActivated", logs: logs, sub: sub}, nil +} + +// WatchEmergencyStateActivated is a free log subscription operation binding the contract event 0x2261efe5aef6fedc1fd1550b25facc9181745623049c7901287030b9ad1a5497. +// +// Solidity: event EmergencyStateActivated() +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) WatchEmergencyStateActivated(opts *bind.WatchOpts, sink chan<- *PolygonrollupmanagerEmergencyStateActivated) (event.Subscription, error) { + + logs, sub, err := _Polygonrollupmanager.contract.WatchLogs(opts, "EmergencyStateActivated") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PolygonrollupmanagerEmergencyStateActivated) + if err := _Polygonrollupmanager.contract.UnpackLog(event, "EmergencyStateActivated", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseEmergencyStateActivated is a log parse operation binding the contract event 0x2261efe5aef6fedc1fd1550b25facc9181745623049c7901287030b9ad1a5497. +// +// Solidity: event EmergencyStateActivated() +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) ParseEmergencyStateActivated(log types.Log) (*PolygonrollupmanagerEmergencyStateActivated, error) { + event := new(PolygonrollupmanagerEmergencyStateActivated) + if err := _Polygonrollupmanager.contract.UnpackLog(event, "EmergencyStateActivated", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PolygonrollupmanagerEmergencyStateDeactivatedIterator is returned from FilterEmergencyStateDeactivated and is used to iterate over the raw logs and unpacked data for EmergencyStateDeactivated events raised by the Polygonrollupmanager contract. +type PolygonrollupmanagerEmergencyStateDeactivatedIterator struct { + Event *PolygonrollupmanagerEmergencyStateDeactivated // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PolygonrollupmanagerEmergencyStateDeactivatedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PolygonrollupmanagerEmergencyStateDeactivated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PolygonrollupmanagerEmergencyStateDeactivated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PolygonrollupmanagerEmergencyStateDeactivatedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolygonrollupmanagerEmergencyStateDeactivatedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolygonrollupmanagerEmergencyStateDeactivated represents a EmergencyStateDeactivated event raised by the Polygonrollupmanager contract. +type PolygonrollupmanagerEmergencyStateDeactivated struct { + Raw types.Log // Blockchain specific contextual infos +} + +// FilterEmergencyStateDeactivated is a free log retrieval operation binding the contract event 0x1e5e34eea33501aecf2ebec9fe0e884a40804275ea7fe10b2ba084c8374308b3. +// +// Solidity: event EmergencyStateDeactivated() +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) FilterEmergencyStateDeactivated(opts *bind.FilterOpts) (*PolygonrollupmanagerEmergencyStateDeactivatedIterator, error) { + + logs, sub, err := _Polygonrollupmanager.contract.FilterLogs(opts, "EmergencyStateDeactivated") + if err != nil { + return nil, err + } + return &PolygonrollupmanagerEmergencyStateDeactivatedIterator{contract: _Polygonrollupmanager.contract, event: "EmergencyStateDeactivated", logs: logs, sub: sub}, nil +} + +// WatchEmergencyStateDeactivated is a free log subscription operation binding the contract event 0x1e5e34eea33501aecf2ebec9fe0e884a40804275ea7fe10b2ba084c8374308b3. +// +// Solidity: event EmergencyStateDeactivated() +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) WatchEmergencyStateDeactivated(opts *bind.WatchOpts, sink chan<- *PolygonrollupmanagerEmergencyStateDeactivated) (event.Subscription, error) { + + logs, sub, err := _Polygonrollupmanager.contract.WatchLogs(opts, "EmergencyStateDeactivated") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PolygonrollupmanagerEmergencyStateDeactivated) + if err := _Polygonrollupmanager.contract.UnpackLog(event, "EmergencyStateDeactivated", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseEmergencyStateDeactivated is a log parse operation binding the contract event 0x1e5e34eea33501aecf2ebec9fe0e884a40804275ea7fe10b2ba084c8374308b3. +// +// Solidity: event EmergencyStateDeactivated() +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) ParseEmergencyStateDeactivated(log types.Log) (*PolygonrollupmanagerEmergencyStateDeactivated, error) { + event := new(PolygonrollupmanagerEmergencyStateDeactivated) + if err := _Polygonrollupmanager.contract.UnpackLog(event, "EmergencyStateDeactivated", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PolygonrollupmanagerInitializedIterator is returned from FilterInitialized and is used to iterate over the raw logs and unpacked data for Initialized events raised by the Polygonrollupmanager contract. +type PolygonrollupmanagerInitializedIterator struct { + Event *PolygonrollupmanagerInitialized // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PolygonrollupmanagerInitializedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PolygonrollupmanagerInitialized) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PolygonrollupmanagerInitialized) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PolygonrollupmanagerInitializedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolygonrollupmanagerInitializedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolygonrollupmanagerInitialized represents a Initialized event raised by the Polygonrollupmanager contract. +type PolygonrollupmanagerInitialized struct { + Version uint8 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterInitialized is a free log retrieval operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) FilterInitialized(opts *bind.FilterOpts) (*PolygonrollupmanagerInitializedIterator, error) { + + logs, sub, err := _Polygonrollupmanager.contract.FilterLogs(opts, "Initialized") + if err != nil { + return nil, err + } + return &PolygonrollupmanagerInitializedIterator{contract: _Polygonrollupmanager.contract, event: "Initialized", logs: logs, sub: sub}, nil +} + +// WatchInitialized is a free log subscription operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *PolygonrollupmanagerInitialized) (event.Subscription, error) { + + logs, sub, err := _Polygonrollupmanager.contract.WatchLogs(opts, "Initialized") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PolygonrollupmanagerInitialized) + if err := _Polygonrollupmanager.contract.UnpackLog(event, "Initialized", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseInitialized is a log parse operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) ParseInitialized(log types.Log) (*PolygonrollupmanagerInitialized, error) { + event := new(PolygonrollupmanagerInitialized) + if err := _Polygonrollupmanager.contract.UnpackLog(event, "Initialized", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PolygonrollupmanagerObsoleteRollupTypeIterator is returned from FilterObsoleteRollupType and is used to iterate over the raw logs and unpacked data for ObsoleteRollupType events raised by the Polygonrollupmanager contract. +type PolygonrollupmanagerObsoleteRollupTypeIterator struct { + Event *PolygonrollupmanagerObsoleteRollupType // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PolygonrollupmanagerObsoleteRollupTypeIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PolygonrollupmanagerObsoleteRollupType) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PolygonrollupmanagerObsoleteRollupType) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PolygonrollupmanagerObsoleteRollupTypeIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolygonrollupmanagerObsoleteRollupTypeIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolygonrollupmanagerObsoleteRollupType represents a ObsoleteRollupType event raised by the Polygonrollupmanager contract. +type PolygonrollupmanagerObsoleteRollupType struct { + RollupTypeID uint32 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterObsoleteRollupType is a free log retrieval operation binding the contract event 0x4710d2ee567ef1ed6eb2f651dde4589524bcf7cebc62147a99b281cc836e7e44. +// +// Solidity: event ObsoleteRollupType(uint32 indexed rollupTypeID) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) FilterObsoleteRollupType(opts *bind.FilterOpts, rollupTypeID []uint32) (*PolygonrollupmanagerObsoleteRollupTypeIterator, error) { + + var rollupTypeIDRule []interface{} + for _, rollupTypeIDItem := range rollupTypeID { + rollupTypeIDRule = append(rollupTypeIDRule, rollupTypeIDItem) + } + + logs, sub, err := _Polygonrollupmanager.contract.FilterLogs(opts, "ObsoleteRollupType", rollupTypeIDRule) + if err != nil { + return nil, err + } + return &PolygonrollupmanagerObsoleteRollupTypeIterator{contract: _Polygonrollupmanager.contract, event: "ObsoleteRollupType", logs: logs, sub: sub}, nil +} + +// WatchObsoleteRollupType is a free log subscription operation binding the contract event 0x4710d2ee567ef1ed6eb2f651dde4589524bcf7cebc62147a99b281cc836e7e44. +// +// Solidity: event ObsoleteRollupType(uint32 indexed rollupTypeID) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) WatchObsoleteRollupType(opts *bind.WatchOpts, sink chan<- *PolygonrollupmanagerObsoleteRollupType, rollupTypeID []uint32) (event.Subscription, error) { + + var rollupTypeIDRule []interface{} + for _, rollupTypeIDItem := range rollupTypeID { + rollupTypeIDRule = append(rollupTypeIDRule, rollupTypeIDItem) + } + + logs, sub, err := _Polygonrollupmanager.contract.WatchLogs(opts, "ObsoleteRollupType", rollupTypeIDRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PolygonrollupmanagerObsoleteRollupType) + if err := _Polygonrollupmanager.contract.UnpackLog(event, "ObsoleteRollupType", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseObsoleteRollupType is a log parse operation binding the contract event 0x4710d2ee567ef1ed6eb2f651dde4589524bcf7cebc62147a99b281cc836e7e44. +// +// Solidity: event ObsoleteRollupType(uint32 indexed rollupTypeID) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) ParseObsoleteRollupType(log types.Log) (*PolygonrollupmanagerObsoleteRollupType, error) { + event := new(PolygonrollupmanagerObsoleteRollupType) + if err := _Polygonrollupmanager.contract.UnpackLog(event, "ObsoleteRollupType", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PolygonrollupmanagerOnSequenceBatchesIterator is returned from FilterOnSequenceBatches and is used to iterate over the raw logs and unpacked data for OnSequenceBatches events raised by the Polygonrollupmanager contract. +type PolygonrollupmanagerOnSequenceBatchesIterator struct { + Event *PolygonrollupmanagerOnSequenceBatches // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PolygonrollupmanagerOnSequenceBatchesIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PolygonrollupmanagerOnSequenceBatches) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PolygonrollupmanagerOnSequenceBatches) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PolygonrollupmanagerOnSequenceBatchesIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolygonrollupmanagerOnSequenceBatchesIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolygonrollupmanagerOnSequenceBatches represents a OnSequenceBatches event raised by the Polygonrollupmanager contract. +type PolygonrollupmanagerOnSequenceBatches struct { + RollupID uint32 + LastBatchSequenced uint64 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterOnSequenceBatches is a free log retrieval operation binding the contract event 0x1d9f30260051d51d70339da239ea7b080021adcaabfa71c9b0ea339a20cf9a25. +// +// Solidity: event OnSequenceBatches(uint32 indexed rollupID, uint64 lastBatchSequenced) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) FilterOnSequenceBatches(opts *bind.FilterOpts, rollupID []uint32) (*PolygonrollupmanagerOnSequenceBatchesIterator, error) { + + var rollupIDRule []interface{} + for _, rollupIDItem := range rollupID { + rollupIDRule = append(rollupIDRule, rollupIDItem) + } + + logs, sub, err := _Polygonrollupmanager.contract.FilterLogs(opts, "OnSequenceBatches", rollupIDRule) + if err != nil { + return nil, err + } + return &PolygonrollupmanagerOnSequenceBatchesIterator{contract: _Polygonrollupmanager.contract, event: "OnSequenceBatches", logs: logs, sub: sub}, nil +} + +// WatchOnSequenceBatches is a free log subscription operation binding the contract event 0x1d9f30260051d51d70339da239ea7b080021adcaabfa71c9b0ea339a20cf9a25. +// +// Solidity: event OnSequenceBatches(uint32 indexed rollupID, uint64 lastBatchSequenced) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) WatchOnSequenceBatches(opts *bind.WatchOpts, sink chan<- *PolygonrollupmanagerOnSequenceBatches, rollupID []uint32) (event.Subscription, error) { + + var rollupIDRule []interface{} + for _, rollupIDItem := range rollupID { + rollupIDRule = append(rollupIDRule, rollupIDItem) + } + + logs, sub, err := _Polygonrollupmanager.contract.WatchLogs(opts, "OnSequenceBatches", rollupIDRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PolygonrollupmanagerOnSequenceBatches) + if err := _Polygonrollupmanager.contract.UnpackLog(event, "OnSequenceBatches", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseOnSequenceBatches is a log parse operation binding the contract event 0x1d9f30260051d51d70339da239ea7b080021adcaabfa71c9b0ea339a20cf9a25. +// +// Solidity: event OnSequenceBatches(uint32 indexed rollupID, uint64 lastBatchSequenced) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) ParseOnSequenceBatches(log types.Log) (*PolygonrollupmanagerOnSequenceBatches, error) { + event := new(PolygonrollupmanagerOnSequenceBatches) + if err := _Polygonrollupmanager.contract.UnpackLog(event, "OnSequenceBatches", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PolygonrollupmanagerOverridePendingStateIterator is returned from FilterOverridePendingState and is used to iterate over the raw logs and unpacked data for OverridePendingState events raised by the Polygonrollupmanager contract. +type PolygonrollupmanagerOverridePendingStateIterator struct { + Event *PolygonrollupmanagerOverridePendingState // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PolygonrollupmanagerOverridePendingStateIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PolygonrollupmanagerOverridePendingState) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PolygonrollupmanagerOverridePendingState) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PolygonrollupmanagerOverridePendingStateIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolygonrollupmanagerOverridePendingStateIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolygonrollupmanagerOverridePendingState represents a OverridePendingState event raised by the Polygonrollupmanager contract. +type PolygonrollupmanagerOverridePendingState struct { + RollupID uint32 + NumBatch uint64 + StateRoot [32]byte + ExitRoot [32]byte + Aggregator common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterOverridePendingState is a free log retrieval operation binding the contract event 0x3182bd6e6f74fc1fdc88b60f3a4f4c7f79db6ae6f5b88a1b3f5a1e28ec210d5e. +// +// Solidity: event OverridePendingState(uint32 indexed rollupID, uint64 numBatch, bytes32 stateRoot, bytes32 exitRoot, address aggregator) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) FilterOverridePendingState(opts *bind.FilterOpts, rollupID []uint32) (*PolygonrollupmanagerOverridePendingStateIterator, error) { + + var rollupIDRule []interface{} + for _, rollupIDItem := range rollupID { + rollupIDRule = append(rollupIDRule, rollupIDItem) + } + + logs, sub, err := _Polygonrollupmanager.contract.FilterLogs(opts, "OverridePendingState", rollupIDRule) + if err != nil { + return nil, err + } + return &PolygonrollupmanagerOverridePendingStateIterator{contract: _Polygonrollupmanager.contract, event: "OverridePendingState", logs: logs, sub: sub}, nil +} + +// WatchOverridePendingState is a free log subscription operation binding the contract event 0x3182bd6e6f74fc1fdc88b60f3a4f4c7f79db6ae6f5b88a1b3f5a1e28ec210d5e. +// +// Solidity: event OverridePendingState(uint32 indexed rollupID, uint64 numBatch, bytes32 stateRoot, bytes32 exitRoot, address aggregator) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) WatchOverridePendingState(opts *bind.WatchOpts, sink chan<- *PolygonrollupmanagerOverridePendingState, rollupID []uint32) (event.Subscription, error) { + + var rollupIDRule []interface{} + for _, rollupIDItem := range rollupID { + rollupIDRule = append(rollupIDRule, rollupIDItem) + } + + logs, sub, err := _Polygonrollupmanager.contract.WatchLogs(opts, "OverridePendingState", rollupIDRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PolygonrollupmanagerOverridePendingState) + if err := _Polygonrollupmanager.contract.UnpackLog(event, "OverridePendingState", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseOverridePendingState is a log parse operation binding the contract event 0x3182bd6e6f74fc1fdc88b60f3a4f4c7f79db6ae6f5b88a1b3f5a1e28ec210d5e. +// +// Solidity: event OverridePendingState(uint32 indexed rollupID, uint64 numBatch, bytes32 stateRoot, bytes32 exitRoot, address aggregator) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) ParseOverridePendingState(log types.Log) (*PolygonrollupmanagerOverridePendingState, error) { + event := new(PolygonrollupmanagerOverridePendingState) + if err := _Polygonrollupmanager.contract.UnpackLog(event, "OverridePendingState", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PolygonrollupmanagerProveNonDeterministicPendingStateIterator is returned from FilterProveNonDeterministicPendingState and is used to iterate over the raw logs and unpacked data for ProveNonDeterministicPendingState events raised by the Polygonrollupmanager contract. +type PolygonrollupmanagerProveNonDeterministicPendingStateIterator struct { + Event *PolygonrollupmanagerProveNonDeterministicPendingState // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PolygonrollupmanagerProveNonDeterministicPendingStateIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PolygonrollupmanagerProveNonDeterministicPendingState) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PolygonrollupmanagerProveNonDeterministicPendingState) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PolygonrollupmanagerProveNonDeterministicPendingStateIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolygonrollupmanagerProveNonDeterministicPendingStateIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolygonrollupmanagerProveNonDeterministicPendingState represents a ProveNonDeterministicPendingState event raised by the Polygonrollupmanager contract. +type PolygonrollupmanagerProveNonDeterministicPendingState struct { + StoredStateRoot [32]byte + ProvedStateRoot [32]byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterProveNonDeterministicPendingState is a free log retrieval operation binding the contract event 0x1f44c21118c4603cfb4e1b621dbcfa2b73efcececee2b99b620b2953d33a7010. +// +// Solidity: event ProveNonDeterministicPendingState(bytes32 storedStateRoot, bytes32 provedStateRoot) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) FilterProveNonDeterministicPendingState(opts *bind.FilterOpts) (*PolygonrollupmanagerProveNonDeterministicPendingStateIterator, error) { + + logs, sub, err := _Polygonrollupmanager.contract.FilterLogs(opts, "ProveNonDeterministicPendingState") + if err != nil { + return nil, err + } + return &PolygonrollupmanagerProveNonDeterministicPendingStateIterator{contract: _Polygonrollupmanager.contract, event: "ProveNonDeterministicPendingState", logs: logs, sub: sub}, nil +} + +// WatchProveNonDeterministicPendingState is a free log subscription operation binding the contract event 0x1f44c21118c4603cfb4e1b621dbcfa2b73efcececee2b99b620b2953d33a7010. +// +// Solidity: event ProveNonDeterministicPendingState(bytes32 storedStateRoot, bytes32 provedStateRoot) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) WatchProveNonDeterministicPendingState(opts *bind.WatchOpts, sink chan<- *PolygonrollupmanagerProveNonDeterministicPendingState) (event.Subscription, error) { + + logs, sub, err := _Polygonrollupmanager.contract.WatchLogs(opts, "ProveNonDeterministicPendingState") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PolygonrollupmanagerProveNonDeterministicPendingState) + if err := _Polygonrollupmanager.contract.UnpackLog(event, "ProveNonDeterministicPendingState", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseProveNonDeterministicPendingState is a log parse operation binding the contract event 0x1f44c21118c4603cfb4e1b621dbcfa2b73efcececee2b99b620b2953d33a7010. +// +// Solidity: event ProveNonDeterministicPendingState(bytes32 storedStateRoot, bytes32 provedStateRoot) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) ParseProveNonDeterministicPendingState(log types.Log) (*PolygonrollupmanagerProveNonDeterministicPendingState, error) { + event := new(PolygonrollupmanagerProveNonDeterministicPendingState) + if err := _Polygonrollupmanager.contract.UnpackLog(event, "ProveNonDeterministicPendingState", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PolygonrollupmanagerRoleAdminChangedIterator is returned from FilterRoleAdminChanged and is used to iterate over the raw logs and unpacked data for RoleAdminChanged events raised by the Polygonrollupmanager contract. +type PolygonrollupmanagerRoleAdminChangedIterator struct { + Event *PolygonrollupmanagerRoleAdminChanged // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PolygonrollupmanagerRoleAdminChangedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PolygonrollupmanagerRoleAdminChanged) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PolygonrollupmanagerRoleAdminChanged) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PolygonrollupmanagerRoleAdminChangedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolygonrollupmanagerRoleAdminChangedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolygonrollupmanagerRoleAdminChanged represents a RoleAdminChanged event raised by the Polygonrollupmanager contract. +type PolygonrollupmanagerRoleAdminChanged struct { + Role [32]byte + PreviousAdminRole [32]byte + NewAdminRole [32]byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterRoleAdminChanged is a free log retrieval operation binding the contract event 0xbd79b86ffe0ab8e8776151514217cd7cacd52c909f66475c3af44e129f0b00ff. +// +// Solidity: event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) FilterRoleAdminChanged(opts *bind.FilterOpts, role [][32]byte, previousAdminRole [][32]byte, newAdminRole [][32]byte) (*PolygonrollupmanagerRoleAdminChangedIterator, error) { + + var roleRule []interface{} + for _, roleItem := range role { + roleRule = append(roleRule, roleItem) + } + var previousAdminRoleRule []interface{} + for _, previousAdminRoleItem := range previousAdminRole { + previousAdminRoleRule = append(previousAdminRoleRule, previousAdminRoleItem) + } + var newAdminRoleRule []interface{} + for _, newAdminRoleItem := range newAdminRole { + newAdminRoleRule = append(newAdminRoleRule, newAdminRoleItem) + } + + logs, sub, err := _Polygonrollupmanager.contract.FilterLogs(opts, "RoleAdminChanged", roleRule, previousAdminRoleRule, newAdminRoleRule) + if err != nil { + return nil, err + } + return &PolygonrollupmanagerRoleAdminChangedIterator{contract: _Polygonrollupmanager.contract, event: "RoleAdminChanged", logs: logs, sub: sub}, nil +} + +// WatchRoleAdminChanged is a free log subscription operation binding the contract event 0xbd79b86ffe0ab8e8776151514217cd7cacd52c909f66475c3af44e129f0b00ff. +// +// Solidity: event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) WatchRoleAdminChanged(opts *bind.WatchOpts, sink chan<- *PolygonrollupmanagerRoleAdminChanged, role [][32]byte, previousAdminRole [][32]byte, newAdminRole [][32]byte) (event.Subscription, error) { + + var roleRule []interface{} + for _, roleItem := range role { + roleRule = append(roleRule, roleItem) + } + var previousAdminRoleRule []interface{} + for _, previousAdminRoleItem := range previousAdminRole { + previousAdminRoleRule = append(previousAdminRoleRule, previousAdminRoleItem) + } + var newAdminRoleRule []interface{} + for _, newAdminRoleItem := range newAdminRole { + newAdminRoleRule = append(newAdminRoleRule, newAdminRoleItem) + } + + logs, sub, err := _Polygonrollupmanager.contract.WatchLogs(opts, "RoleAdminChanged", roleRule, previousAdminRoleRule, newAdminRoleRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PolygonrollupmanagerRoleAdminChanged) + if err := _Polygonrollupmanager.contract.UnpackLog(event, "RoleAdminChanged", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseRoleAdminChanged is a log parse operation binding the contract event 0xbd79b86ffe0ab8e8776151514217cd7cacd52c909f66475c3af44e129f0b00ff. +// +// Solidity: event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) ParseRoleAdminChanged(log types.Log) (*PolygonrollupmanagerRoleAdminChanged, error) { + event := new(PolygonrollupmanagerRoleAdminChanged) + if err := _Polygonrollupmanager.contract.UnpackLog(event, "RoleAdminChanged", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PolygonrollupmanagerRoleGrantedIterator is returned from FilterRoleGranted and is used to iterate over the raw logs and unpacked data for RoleGranted events raised by the Polygonrollupmanager contract. +type PolygonrollupmanagerRoleGrantedIterator struct { + Event *PolygonrollupmanagerRoleGranted // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PolygonrollupmanagerRoleGrantedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PolygonrollupmanagerRoleGranted) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PolygonrollupmanagerRoleGranted) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PolygonrollupmanagerRoleGrantedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolygonrollupmanagerRoleGrantedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolygonrollupmanagerRoleGranted represents a RoleGranted event raised by the Polygonrollupmanager contract. +type PolygonrollupmanagerRoleGranted struct { + Role [32]byte + Account common.Address + Sender common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterRoleGranted is a free log retrieval operation binding the contract event 0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d. +// +// Solidity: event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) FilterRoleGranted(opts *bind.FilterOpts, role [][32]byte, account []common.Address, sender []common.Address) (*PolygonrollupmanagerRoleGrantedIterator, error) { + + var roleRule []interface{} + for _, roleItem := range role { + roleRule = append(roleRule, roleItem) + } + var accountRule []interface{} + for _, accountItem := range account { + accountRule = append(accountRule, accountItem) + } + var senderRule []interface{} + for _, senderItem := range sender { + senderRule = append(senderRule, senderItem) + } + + logs, sub, err := _Polygonrollupmanager.contract.FilterLogs(opts, "RoleGranted", roleRule, accountRule, senderRule) + if err != nil { + return nil, err + } + return &PolygonrollupmanagerRoleGrantedIterator{contract: _Polygonrollupmanager.contract, event: "RoleGranted", logs: logs, sub: sub}, nil +} + +// WatchRoleGranted is a free log subscription operation binding the contract event 0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d. +// +// Solidity: event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) WatchRoleGranted(opts *bind.WatchOpts, sink chan<- *PolygonrollupmanagerRoleGranted, role [][32]byte, account []common.Address, sender []common.Address) (event.Subscription, error) { + + var roleRule []interface{} + for _, roleItem := range role { + roleRule = append(roleRule, roleItem) + } + var accountRule []interface{} + for _, accountItem := range account { + accountRule = append(accountRule, accountItem) + } + var senderRule []interface{} + for _, senderItem := range sender { + senderRule = append(senderRule, senderItem) + } + + logs, sub, err := _Polygonrollupmanager.contract.WatchLogs(opts, "RoleGranted", roleRule, accountRule, senderRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PolygonrollupmanagerRoleGranted) + if err := _Polygonrollupmanager.contract.UnpackLog(event, "RoleGranted", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseRoleGranted is a log parse operation binding the contract event 0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d. +// +// Solidity: event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) ParseRoleGranted(log types.Log) (*PolygonrollupmanagerRoleGranted, error) { + event := new(PolygonrollupmanagerRoleGranted) + if err := _Polygonrollupmanager.contract.UnpackLog(event, "RoleGranted", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PolygonrollupmanagerRoleRevokedIterator is returned from FilterRoleRevoked and is used to iterate over the raw logs and unpacked data for RoleRevoked events raised by the Polygonrollupmanager contract. +type PolygonrollupmanagerRoleRevokedIterator struct { + Event *PolygonrollupmanagerRoleRevoked // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PolygonrollupmanagerRoleRevokedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PolygonrollupmanagerRoleRevoked) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PolygonrollupmanagerRoleRevoked) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PolygonrollupmanagerRoleRevokedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolygonrollupmanagerRoleRevokedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolygonrollupmanagerRoleRevoked represents a RoleRevoked event raised by the Polygonrollupmanager contract. +type PolygonrollupmanagerRoleRevoked struct { + Role [32]byte + Account common.Address + Sender common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterRoleRevoked is a free log retrieval operation binding the contract event 0xf6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b. +// +// Solidity: event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) FilterRoleRevoked(opts *bind.FilterOpts, role [][32]byte, account []common.Address, sender []common.Address) (*PolygonrollupmanagerRoleRevokedIterator, error) { + + var roleRule []interface{} + for _, roleItem := range role { + roleRule = append(roleRule, roleItem) + } + var accountRule []interface{} + for _, accountItem := range account { + accountRule = append(accountRule, accountItem) + } + var senderRule []interface{} + for _, senderItem := range sender { + senderRule = append(senderRule, senderItem) + } + + logs, sub, err := _Polygonrollupmanager.contract.FilterLogs(opts, "RoleRevoked", roleRule, accountRule, senderRule) + if err != nil { + return nil, err + } + return &PolygonrollupmanagerRoleRevokedIterator{contract: _Polygonrollupmanager.contract, event: "RoleRevoked", logs: logs, sub: sub}, nil +} + +// WatchRoleRevoked is a free log subscription operation binding the contract event 0xf6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b. +// +// Solidity: event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) WatchRoleRevoked(opts *bind.WatchOpts, sink chan<- *PolygonrollupmanagerRoleRevoked, role [][32]byte, account []common.Address, sender []common.Address) (event.Subscription, error) { + + var roleRule []interface{} + for _, roleItem := range role { + roleRule = append(roleRule, roleItem) + } + var accountRule []interface{} + for _, accountItem := range account { + accountRule = append(accountRule, accountItem) + } + var senderRule []interface{} + for _, senderItem := range sender { + senderRule = append(senderRule, senderItem) + } + + logs, sub, err := _Polygonrollupmanager.contract.WatchLogs(opts, "RoleRevoked", roleRule, accountRule, senderRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PolygonrollupmanagerRoleRevoked) + if err := _Polygonrollupmanager.contract.UnpackLog(event, "RoleRevoked", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseRoleRevoked is a log parse operation binding the contract event 0xf6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b. +// +// Solidity: event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) ParseRoleRevoked(log types.Log) (*PolygonrollupmanagerRoleRevoked, error) { + event := new(PolygonrollupmanagerRoleRevoked) + if err := _Polygonrollupmanager.contract.UnpackLog(event, "RoleRevoked", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PolygonrollupmanagerSetBatchFeeIterator is returned from FilterSetBatchFee and is used to iterate over the raw logs and unpacked data for SetBatchFee events raised by the Polygonrollupmanager contract. +type PolygonrollupmanagerSetBatchFeeIterator struct { + Event *PolygonrollupmanagerSetBatchFee // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PolygonrollupmanagerSetBatchFeeIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PolygonrollupmanagerSetBatchFee) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PolygonrollupmanagerSetBatchFee) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PolygonrollupmanagerSetBatchFeeIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolygonrollupmanagerSetBatchFeeIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolygonrollupmanagerSetBatchFee represents a SetBatchFee event raised by the Polygonrollupmanager contract. +type PolygonrollupmanagerSetBatchFee struct { + NewBatchFee *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterSetBatchFee is a free log retrieval operation binding the contract event 0xfb383653f53ee079978d0c9aff7aeff04a10166ce244cca9c9f9d8d96bed45b2. +// +// Solidity: event SetBatchFee(uint256 newBatchFee) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) FilterSetBatchFee(opts *bind.FilterOpts) (*PolygonrollupmanagerSetBatchFeeIterator, error) { + + logs, sub, err := _Polygonrollupmanager.contract.FilterLogs(opts, "SetBatchFee") + if err != nil { + return nil, err + } + return &PolygonrollupmanagerSetBatchFeeIterator{contract: _Polygonrollupmanager.contract, event: "SetBatchFee", logs: logs, sub: sub}, nil +} + +// WatchSetBatchFee is a free log subscription operation binding the contract event 0xfb383653f53ee079978d0c9aff7aeff04a10166ce244cca9c9f9d8d96bed45b2. +// +// Solidity: event SetBatchFee(uint256 newBatchFee) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) WatchSetBatchFee(opts *bind.WatchOpts, sink chan<- *PolygonrollupmanagerSetBatchFee) (event.Subscription, error) { + + logs, sub, err := _Polygonrollupmanager.contract.WatchLogs(opts, "SetBatchFee") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PolygonrollupmanagerSetBatchFee) + if err := _Polygonrollupmanager.contract.UnpackLog(event, "SetBatchFee", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseSetBatchFee is a log parse operation binding the contract event 0xfb383653f53ee079978d0c9aff7aeff04a10166ce244cca9c9f9d8d96bed45b2. +// +// Solidity: event SetBatchFee(uint256 newBatchFee) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) ParseSetBatchFee(log types.Log) (*PolygonrollupmanagerSetBatchFee, error) { + event := new(PolygonrollupmanagerSetBatchFee) + if err := _Polygonrollupmanager.contract.UnpackLog(event, "SetBatchFee", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PolygonrollupmanagerSetMultiplierBatchFeeIterator is returned from FilterSetMultiplierBatchFee and is used to iterate over the raw logs and unpacked data for SetMultiplierBatchFee events raised by the Polygonrollupmanager contract. +type PolygonrollupmanagerSetMultiplierBatchFeeIterator struct { + Event *PolygonrollupmanagerSetMultiplierBatchFee // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PolygonrollupmanagerSetMultiplierBatchFeeIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PolygonrollupmanagerSetMultiplierBatchFee) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PolygonrollupmanagerSetMultiplierBatchFee) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PolygonrollupmanagerSetMultiplierBatchFeeIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolygonrollupmanagerSetMultiplierBatchFeeIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolygonrollupmanagerSetMultiplierBatchFee represents a SetMultiplierBatchFee event raised by the Polygonrollupmanager contract. +type PolygonrollupmanagerSetMultiplierBatchFee struct { + NewMultiplierBatchFee uint16 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterSetMultiplierBatchFee is a free log retrieval operation binding the contract event 0x7019933d795eba185c180209e8ae8bffbaa25bcef293364687702c31f4d302c5. +// +// Solidity: event SetMultiplierBatchFee(uint16 newMultiplierBatchFee) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) FilterSetMultiplierBatchFee(opts *bind.FilterOpts) (*PolygonrollupmanagerSetMultiplierBatchFeeIterator, error) { + + logs, sub, err := _Polygonrollupmanager.contract.FilterLogs(opts, "SetMultiplierBatchFee") + if err != nil { + return nil, err + } + return &PolygonrollupmanagerSetMultiplierBatchFeeIterator{contract: _Polygonrollupmanager.contract, event: "SetMultiplierBatchFee", logs: logs, sub: sub}, nil +} + +// WatchSetMultiplierBatchFee is a free log subscription operation binding the contract event 0x7019933d795eba185c180209e8ae8bffbaa25bcef293364687702c31f4d302c5. +// +// Solidity: event SetMultiplierBatchFee(uint16 newMultiplierBatchFee) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) WatchSetMultiplierBatchFee(opts *bind.WatchOpts, sink chan<- *PolygonrollupmanagerSetMultiplierBatchFee) (event.Subscription, error) { + + logs, sub, err := _Polygonrollupmanager.contract.WatchLogs(opts, "SetMultiplierBatchFee") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PolygonrollupmanagerSetMultiplierBatchFee) + if err := _Polygonrollupmanager.contract.UnpackLog(event, "SetMultiplierBatchFee", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseSetMultiplierBatchFee is a log parse operation binding the contract event 0x7019933d795eba185c180209e8ae8bffbaa25bcef293364687702c31f4d302c5. +// +// Solidity: event SetMultiplierBatchFee(uint16 newMultiplierBatchFee) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) ParseSetMultiplierBatchFee(log types.Log) (*PolygonrollupmanagerSetMultiplierBatchFee, error) { + event := new(PolygonrollupmanagerSetMultiplierBatchFee) + if err := _Polygonrollupmanager.contract.UnpackLog(event, "SetMultiplierBatchFee", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PolygonrollupmanagerSetPendingStateTimeoutIterator is returned from FilterSetPendingStateTimeout and is used to iterate over the raw logs and unpacked data for SetPendingStateTimeout events raised by the Polygonrollupmanager contract. +type PolygonrollupmanagerSetPendingStateTimeoutIterator struct { + Event *PolygonrollupmanagerSetPendingStateTimeout // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PolygonrollupmanagerSetPendingStateTimeoutIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PolygonrollupmanagerSetPendingStateTimeout) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PolygonrollupmanagerSetPendingStateTimeout) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PolygonrollupmanagerSetPendingStateTimeoutIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolygonrollupmanagerSetPendingStateTimeoutIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolygonrollupmanagerSetPendingStateTimeout represents a SetPendingStateTimeout event raised by the Polygonrollupmanager contract. +type PolygonrollupmanagerSetPendingStateTimeout struct { + NewPendingStateTimeout uint64 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterSetPendingStateTimeout is a free log retrieval operation binding the contract event 0xc4121f4e22c69632ebb7cf1f462be0511dc034f999b52013eddfb24aab765c75. +// +// Solidity: event SetPendingStateTimeout(uint64 newPendingStateTimeout) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) FilterSetPendingStateTimeout(opts *bind.FilterOpts) (*PolygonrollupmanagerSetPendingStateTimeoutIterator, error) { + + logs, sub, err := _Polygonrollupmanager.contract.FilterLogs(opts, "SetPendingStateTimeout") + if err != nil { + return nil, err + } + return &PolygonrollupmanagerSetPendingStateTimeoutIterator{contract: _Polygonrollupmanager.contract, event: "SetPendingStateTimeout", logs: logs, sub: sub}, nil +} + +// WatchSetPendingStateTimeout is a free log subscription operation binding the contract event 0xc4121f4e22c69632ebb7cf1f462be0511dc034f999b52013eddfb24aab765c75. +// +// Solidity: event SetPendingStateTimeout(uint64 newPendingStateTimeout) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) WatchSetPendingStateTimeout(opts *bind.WatchOpts, sink chan<- *PolygonrollupmanagerSetPendingStateTimeout) (event.Subscription, error) { + + logs, sub, err := _Polygonrollupmanager.contract.WatchLogs(opts, "SetPendingStateTimeout") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PolygonrollupmanagerSetPendingStateTimeout) + if err := _Polygonrollupmanager.contract.UnpackLog(event, "SetPendingStateTimeout", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseSetPendingStateTimeout is a log parse operation binding the contract event 0xc4121f4e22c69632ebb7cf1f462be0511dc034f999b52013eddfb24aab765c75. +// +// Solidity: event SetPendingStateTimeout(uint64 newPendingStateTimeout) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) ParseSetPendingStateTimeout(log types.Log) (*PolygonrollupmanagerSetPendingStateTimeout, error) { + event := new(PolygonrollupmanagerSetPendingStateTimeout) + if err := _Polygonrollupmanager.contract.UnpackLog(event, "SetPendingStateTimeout", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PolygonrollupmanagerSetTrustedAggregatorIterator is returned from FilterSetTrustedAggregator and is used to iterate over the raw logs and unpacked data for SetTrustedAggregator events raised by the Polygonrollupmanager contract. +type PolygonrollupmanagerSetTrustedAggregatorIterator struct { + Event *PolygonrollupmanagerSetTrustedAggregator // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PolygonrollupmanagerSetTrustedAggregatorIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PolygonrollupmanagerSetTrustedAggregator) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PolygonrollupmanagerSetTrustedAggregator) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PolygonrollupmanagerSetTrustedAggregatorIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolygonrollupmanagerSetTrustedAggregatorIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolygonrollupmanagerSetTrustedAggregator represents a SetTrustedAggregator event raised by the Polygonrollupmanager contract. +type PolygonrollupmanagerSetTrustedAggregator struct { + NewTrustedAggregator common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterSetTrustedAggregator is a free log retrieval operation binding the contract event 0x61f8fec29495a3078e9271456f05fb0707fd4e41f7661865f80fc437d06681ca. +// +// Solidity: event SetTrustedAggregator(address newTrustedAggregator) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) FilterSetTrustedAggregator(opts *bind.FilterOpts) (*PolygonrollupmanagerSetTrustedAggregatorIterator, error) { + + logs, sub, err := _Polygonrollupmanager.contract.FilterLogs(opts, "SetTrustedAggregator") + if err != nil { + return nil, err + } + return &PolygonrollupmanagerSetTrustedAggregatorIterator{contract: _Polygonrollupmanager.contract, event: "SetTrustedAggregator", logs: logs, sub: sub}, nil +} + +// WatchSetTrustedAggregator is a free log subscription operation binding the contract event 0x61f8fec29495a3078e9271456f05fb0707fd4e41f7661865f80fc437d06681ca. +// +// Solidity: event SetTrustedAggregator(address newTrustedAggregator) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) WatchSetTrustedAggregator(opts *bind.WatchOpts, sink chan<- *PolygonrollupmanagerSetTrustedAggregator) (event.Subscription, error) { + + logs, sub, err := _Polygonrollupmanager.contract.WatchLogs(opts, "SetTrustedAggregator") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PolygonrollupmanagerSetTrustedAggregator) + if err := _Polygonrollupmanager.contract.UnpackLog(event, "SetTrustedAggregator", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseSetTrustedAggregator is a log parse operation binding the contract event 0x61f8fec29495a3078e9271456f05fb0707fd4e41f7661865f80fc437d06681ca. +// +// Solidity: event SetTrustedAggregator(address newTrustedAggregator) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) ParseSetTrustedAggregator(log types.Log) (*PolygonrollupmanagerSetTrustedAggregator, error) { + event := new(PolygonrollupmanagerSetTrustedAggregator) + if err := _Polygonrollupmanager.contract.UnpackLog(event, "SetTrustedAggregator", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PolygonrollupmanagerSetTrustedAggregatorTimeoutIterator is returned from FilterSetTrustedAggregatorTimeout and is used to iterate over the raw logs and unpacked data for SetTrustedAggregatorTimeout events raised by the Polygonrollupmanager contract. +type PolygonrollupmanagerSetTrustedAggregatorTimeoutIterator struct { + Event *PolygonrollupmanagerSetTrustedAggregatorTimeout // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PolygonrollupmanagerSetTrustedAggregatorTimeoutIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PolygonrollupmanagerSetTrustedAggregatorTimeout) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PolygonrollupmanagerSetTrustedAggregatorTimeout) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PolygonrollupmanagerSetTrustedAggregatorTimeoutIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolygonrollupmanagerSetTrustedAggregatorTimeoutIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolygonrollupmanagerSetTrustedAggregatorTimeout represents a SetTrustedAggregatorTimeout event raised by the Polygonrollupmanager contract. +type PolygonrollupmanagerSetTrustedAggregatorTimeout struct { + NewTrustedAggregatorTimeout uint64 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterSetTrustedAggregatorTimeout is a free log retrieval operation binding the contract event 0x1f4fa24c2e4bad19a7f3ec5c5485f70d46c798461c2e684f55bbd0fc661373a1. +// +// Solidity: event SetTrustedAggregatorTimeout(uint64 newTrustedAggregatorTimeout) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) FilterSetTrustedAggregatorTimeout(opts *bind.FilterOpts) (*PolygonrollupmanagerSetTrustedAggregatorTimeoutIterator, error) { + + logs, sub, err := _Polygonrollupmanager.contract.FilterLogs(opts, "SetTrustedAggregatorTimeout") + if err != nil { + return nil, err + } + return &PolygonrollupmanagerSetTrustedAggregatorTimeoutIterator{contract: _Polygonrollupmanager.contract, event: "SetTrustedAggregatorTimeout", logs: logs, sub: sub}, nil +} + +// WatchSetTrustedAggregatorTimeout is a free log subscription operation binding the contract event 0x1f4fa24c2e4bad19a7f3ec5c5485f70d46c798461c2e684f55bbd0fc661373a1. +// +// Solidity: event SetTrustedAggregatorTimeout(uint64 newTrustedAggregatorTimeout) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) WatchSetTrustedAggregatorTimeout(opts *bind.WatchOpts, sink chan<- *PolygonrollupmanagerSetTrustedAggregatorTimeout) (event.Subscription, error) { + + logs, sub, err := _Polygonrollupmanager.contract.WatchLogs(opts, "SetTrustedAggregatorTimeout") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PolygonrollupmanagerSetTrustedAggregatorTimeout) + if err := _Polygonrollupmanager.contract.UnpackLog(event, "SetTrustedAggregatorTimeout", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseSetTrustedAggregatorTimeout is a log parse operation binding the contract event 0x1f4fa24c2e4bad19a7f3ec5c5485f70d46c798461c2e684f55bbd0fc661373a1. +// +// Solidity: event SetTrustedAggregatorTimeout(uint64 newTrustedAggregatorTimeout) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) ParseSetTrustedAggregatorTimeout(log types.Log) (*PolygonrollupmanagerSetTrustedAggregatorTimeout, error) { + event := new(PolygonrollupmanagerSetTrustedAggregatorTimeout) + if err := _Polygonrollupmanager.contract.UnpackLog(event, "SetTrustedAggregatorTimeout", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PolygonrollupmanagerSetVerifyBatchTimeTargetIterator is returned from FilterSetVerifyBatchTimeTarget and is used to iterate over the raw logs and unpacked data for SetVerifyBatchTimeTarget events raised by the Polygonrollupmanager contract. +type PolygonrollupmanagerSetVerifyBatchTimeTargetIterator struct { + Event *PolygonrollupmanagerSetVerifyBatchTimeTarget // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PolygonrollupmanagerSetVerifyBatchTimeTargetIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PolygonrollupmanagerSetVerifyBatchTimeTarget) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PolygonrollupmanagerSetVerifyBatchTimeTarget) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PolygonrollupmanagerSetVerifyBatchTimeTargetIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolygonrollupmanagerSetVerifyBatchTimeTargetIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolygonrollupmanagerSetVerifyBatchTimeTarget represents a SetVerifyBatchTimeTarget event raised by the Polygonrollupmanager contract. +type PolygonrollupmanagerSetVerifyBatchTimeTarget struct { + NewVerifyBatchTimeTarget uint64 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterSetVerifyBatchTimeTarget is a free log retrieval operation binding the contract event 0x1b023231a1ab6b5d93992f168fb44498e1a7e64cef58daff6f1c216de6a68c28. +// +// Solidity: event SetVerifyBatchTimeTarget(uint64 newVerifyBatchTimeTarget) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) FilterSetVerifyBatchTimeTarget(opts *bind.FilterOpts) (*PolygonrollupmanagerSetVerifyBatchTimeTargetIterator, error) { + + logs, sub, err := _Polygonrollupmanager.contract.FilterLogs(opts, "SetVerifyBatchTimeTarget") + if err != nil { + return nil, err + } + return &PolygonrollupmanagerSetVerifyBatchTimeTargetIterator{contract: _Polygonrollupmanager.contract, event: "SetVerifyBatchTimeTarget", logs: logs, sub: sub}, nil +} + +// WatchSetVerifyBatchTimeTarget is a free log subscription operation binding the contract event 0x1b023231a1ab6b5d93992f168fb44498e1a7e64cef58daff6f1c216de6a68c28. +// +// Solidity: event SetVerifyBatchTimeTarget(uint64 newVerifyBatchTimeTarget) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) WatchSetVerifyBatchTimeTarget(opts *bind.WatchOpts, sink chan<- *PolygonrollupmanagerSetVerifyBatchTimeTarget) (event.Subscription, error) { + + logs, sub, err := _Polygonrollupmanager.contract.WatchLogs(opts, "SetVerifyBatchTimeTarget") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PolygonrollupmanagerSetVerifyBatchTimeTarget) + if err := _Polygonrollupmanager.contract.UnpackLog(event, "SetVerifyBatchTimeTarget", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseSetVerifyBatchTimeTarget is a log parse operation binding the contract event 0x1b023231a1ab6b5d93992f168fb44498e1a7e64cef58daff6f1c216de6a68c28. +// +// Solidity: event SetVerifyBatchTimeTarget(uint64 newVerifyBatchTimeTarget) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) ParseSetVerifyBatchTimeTarget(log types.Log) (*PolygonrollupmanagerSetVerifyBatchTimeTarget, error) { + event := new(PolygonrollupmanagerSetVerifyBatchTimeTarget) + if err := _Polygonrollupmanager.contract.UnpackLog(event, "SetVerifyBatchTimeTarget", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PolygonrollupmanagerUpdateRollupIterator is returned from FilterUpdateRollup and is used to iterate over the raw logs and unpacked data for UpdateRollup events raised by the Polygonrollupmanager contract. +type PolygonrollupmanagerUpdateRollupIterator struct { + Event *PolygonrollupmanagerUpdateRollup // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PolygonrollupmanagerUpdateRollupIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PolygonrollupmanagerUpdateRollup) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PolygonrollupmanagerUpdateRollup) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PolygonrollupmanagerUpdateRollupIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolygonrollupmanagerUpdateRollupIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolygonrollupmanagerUpdateRollup represents a UpdateRollup event raised by the Polygonrollupmanager contract. +type PolygonrollupmanagerUpdateRollup struct { + RollupID uint32 + NewRollupTypeID uint32 + LastVerifiedBatchBeforeUpgrade uint64 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterUpdateRollup is a free log retrieval operation binding the contract event 0xf585e04c05d396901170247783d3e5f0ee9c1df23072985b50af089f5e48b19d. +// +// Solidity: event UpdateRollup(uint32 indexed rollupID, uint32 newRollupTypeID, uint64 lastVerifiedBatchBeforeUpgrade) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) FilterUpdateRollup(opts *bind.FilterOpts, rollupID []uint32) (*PolygonrollupmanagerUpdateRollupIterator, error) { + + var rollupIDRule []interface{} + for _, rollupIDItem := range rollupID { + rollupIDRule = append(rollupIDRule, rollupIDItem) + } + + logs, sub, err := _Polygonrollupmanager.contract.FilterLogs(opts, "UpdateRollup", rollupIDRule) + if err != nil { + return nil, err + } + return &PolygonrollupmanagerUpdateRollupIterator{contract: _Polygonrollupmanager.contract, event: "UpdateRollup", logs: logs, sub: sub}, nil +} + +// WatchUpdateRollup is a free log subscription operation binding the contract event 0xf585e04c05d396901170247783d3e5f0ee9c1df23072985b50af089f5e48b19d. +// +// Solidity: event UpdateRollup(uint32 indexed rollupID, uint32 newRollupTypeID, uint64 lastVerifiedBatchBeforeUpgrade) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) WatchUpdateRollup(opts *bind.WatchOpts, sink chan<- *PolygonrollupmanagerUpdateRollup, rollupID []uint32) (event.Subscription, error) { + + var rollupIDRule []interface{} + for _, rollupIDItem := range rollupID { + rollupIDRule = append(rollupIDRule, rollupIDItem) + } + + logs, sub, err := _Polygonrollupmanager.contract.WatchLogs(opts, "UpdateRollup", rollupIDRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PolygonrollupmanagerUpdateRollup) + if err := _Polygonrollupmanager.contract.UnpackLog(event, "UpdateRollup", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseUpdateRollup is a log parse operation binding the contract event 0xf585e04c05d396901170247783d3e5f0ee9c1df23072985b50af089f5e48b19d. +// +// Solidity: event UpdateRollup(uint32 indexed rollupID, uint32 newRollupTypeID, uint64 lastVerifiedBatchBeforeUpgrade) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) ParseUpdateRollup(log types.Log) (*PolygonrollupmanagerUpdateRollup, error) { + event := new(PolygonrollupmanagerUpdateRollup) + if err := _Polygonrollupmanager.contract.UnpackLog(event, "UpdateRollup", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PolygonrollupmanagerVerifyBatchesIterator is returned from FilterVerifyBatches and is used to iterate over the raw logs and unpacked data for VerifyBatches events raised by the Polygonrollupmanager contract. +type PolygonrollupmanagerVerifyBatchesIterator struct { + Event *PolygonrollupmanagerVerifyBatches // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PolygonrollupmanagerVerifyBatchesIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PolygonrollupmanagerVerifyBatches) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PolygonrollupmanagerVerifyBatches) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PolygonrollupmanagerVerifyBatchesIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolygonrollupmanagerVerifyBatchesIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolygonrollupmanagerVerifyBatches represents a VerifyBatches event raised by the Polygonrollupmanager contract. +type PolygonrollupmanagerVerifyBatches struct { + RollupID uint32 + NumBatch uint64 + StateRoot [32]byte + ExitRoot [32]byte + Aggregator common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterVerifyBatches is a free log retrieval operation binding the contract event 0xaac1e7a157b259544ebacd6e8a82ae5d6c8f174e12aa48696277bcc9a661f0b4. +// +// Solidity: event VerifyBatches(uint32 indexed rollupID, uint64 numBatch, bytes32 stateRoot, bytes32 exitRoot, address indexed aggregator) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) FilterVerifyBatches(opts *bind.FilterOpts, rollupID []uint32, aggregator []common.Address) (*PolygonrollupmanagerVerifyBatchesIterator, error) { + + var rollupIDRule []interface{} + for _, rollupIDItem := range rollupID { + rollupIDRule = append(rollupIDRule, rollupIDItem) + } + + var aggregatorRule []interface{} + for _, aggregatorItem := range aggregator { + aggregatorRule = append(aggregatorRule, aggregatorItem) + } + + logs, sub, err := _Polygonrollupmanager.contract.FilterLogs(opts, "VerifyBatches", rollupIDRule, aggregatorRule) + if err != nil { + return nil, err + } + return &PolygonrollupmanagerVerifyBatchesIterator{contract: _Polygonrollupmanager.contract, event: "VerifyBatches", logs: logs, sub: sub}, nil +} + +// WatchVerifyBatches is a free log subscription operation binding the contract event 0xaac1e7a157b259544ebacd6e8a82ae5d6c8f174e12aa48696277bcc9a661f0b4. +// +// Solidity: event VerifyBatches(uint32 indexed rollupID, uint64 numBatch, bytes32 stateRoot, bytes32 exitRoot, address indexed aggregator) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) WatchVerifyBatches(opts *bind.WatchOpts, sink chan<- *PolygonrollupmanagerVerifyBatches, rollupID []uint32, aggregator []common.Address) (event.Subscription, error) { + + var rollupIDRule []interface{} + for _, rollupIDItem := range rollupID { + rollupIDRule = append(rollupIDRule, rollupIDItem) + } + + var aggregatorRule []interface{} + for _, aggregatorItem := range aggregator { + aggregatorRule = append(aggregatorRule, aggregatorItem) + } + + logs, sub, err := _Polygonrollupmanager.contract.WatchLogs(opts, "VerifyBatches", rollupIDRule, aggregatorRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PolygonrollupmanagerVerifyBatches) + if err := _Polygonrollupmanager.contract.UnpackLog(event, "VerifyBatches", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseVerifyBatches is a log parse operation binding the contract event 0xaac1e7a157b259544ebacd6e8a82ae5d6c8f174e12aa48696277bcc9a661f0b4. +// +// Solidity: event VerifyBatches(uint32 indexed rollupID, uint64 numBatch, bytes32 stateRoot, bytes32 exitRoot, address indexed aggregator) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) ParseVerifyBatches(log types.Log) (*PolygonrollupmanagerVerifyBatches, error) { + event := new(PolygonrollupmanagerVerifyBatches) + if err := _Polygonrollupmanager.contract.UnpackLog(event, "VerifyBatches", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PolygonrollupmanagerVerifyBatchesTrustedAggregatorIterator is returned from FilterVerifyBatchesTrustedAggregator and is used to iterate over the raw logs and unpacked data for VerifyBatchesTrustedAggregator events raised by the Polygonrollupmanager contract. +type PolygonrollupmanagerVerifyBatchesTrustedAggregatorIterator struct { + Event *PolygonrollupmanagerVerifyBatchesTrustedAggregator // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PolygonrollupmanagerVerifyBatchesTrustedAggregatorIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PolygonrollupmanagerVerifyBatchesTrustedAggregator) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PolygonrollupmanagerVerifyBatchesTrustedAggregator) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PolygonrollupmanagerVerifyBatchesTrustedAggregatorIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolygonrollupmanagerVerifyBatchesTrustedAggregatorIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolygonrollupmanagerVerifyBatchesTrustedAggregator represents a VerifyBatchesTrustedAggregator event raised by the Polygonrollupmanager contract. +type PolygonrollupmanagerVerifyBatchesTrustedAggregator struct { + RollupID uint32 + NumBatch uint64 + StateRoot [32]byte + ExitRoot [32]byte + Aggregator common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterVerifyBatchesTrustedAggregator is a free log retrieval operation binding the contract event 0xd1ec3a1216f08b6eff72e169ceb548b782db18a6614852618d86bb19f3f9b0d3. +// +// Solidity: event VerifyBatchesTrustedAggregator(uint32 indexed rollupID, uint64 numBatch, bytes32 stateRoot, bytes32 exitRoot, address indexed aggregator) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) FilterVerifyBatchesTrustedAggregator(opts *bind.FilterOpts, rollupID []uint32, aggregator []common.Address) (*PolygonrollupmanagerVerifyBatchesTrustedAggregatorIterator, error) { + + var rollupIDRule []interface{} + for _, rollupIDItem := range rollupID { + rollupIDRule = append(rollupIDRule, rollupIDItem) + } + + var aggregatorRule []interface{} + for _, aggregatorItem := range aggregator { + aggregatorRule = append(aggregatorRule, aggregatorItem) + } + + logs, sub, err := _Polygonrollupmanager.contract.FilterLogs(opts, "VerifyBatchesTrustedAggregator", rollupIDRule, aggregatorRule) + if err != nil { + return nil, err + } + return &PolygonrollupmanagerVerifyBatchesTrustedAggregatorIterator{contract: _Polygonrollupmanager.contract, event: "VerifyBatchesTrustedAggregator", logs: logs, sub: sub}, nil +} + +// WatchVerifyBatchesTrustedAggregator is a free log subscription operation binding the contract event 0xd1ec3a1216f08b6eff72e169ceb548b782db18a6614852618d86bb19f3f9b0d3. +// +// Solidity: event VerifyBatchesTrustedAggregator(uint32 indexed rollupID, uint64 numBatch, bytes32 stateRoot, bytes32 exitRoot, address indexed aggregator) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) WatchVerifyBatchesTrustedAggregator(opts *bind.WatchOpts, sink chan<- *PolygonrollupmanagerVerifyBatchesTrustedAggregator, rollupID []uint32, aggregator []common.Address) (event.Subscription, error) { + + var rollupIDRule []interface{} + for _, rollupIDItem := range rollupID { + rollupIDRule = append(rollupIDRule, rollupIDItem) + } + + var aggregatorRule []interface{} + for _, aggregatorItem := range aggregator { + aggregatorRule = append(aggregatorRule, aggregatorItem) + } + + logs, sub, err := _Polygonrollupmanager.contract.WatchLogs(opts, "VerifyBatchesTrustedAggregator", rollupIDRule, aggregatorRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PolygonrollupmanagerVerifyBatchesTrustedAggregator) + if err := _Polygonrollupmanager.contract.UnpackLog(event, "VerifyBatchesTrustedAggregator", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseVerifyBatchesTrustedAggregator is a log parse operation binding the contract event 0xd1ec3a1216f08b6eff72e169ceb548b782db18a6614852618d86bb19f3f9b0d3. +// +// Solidity: event VerifyBatchesTrustedAggregator(uint32 indexed rollupID, uint64 numBatch, bytes32 stateRoot, bytes32 exitRoot, address indexed aggregator) +func (_Polygonrollupmanager *PolygonrollupmanagerFilterer) ParseVerifyBatchesTrustedAggregator(log types.Log) (*PolygonrollupmanagerVerifyBatchesTrustedAggregator, error) { + event := new(PolygonrollupmanagerVerifyBatchesTrustedAggregator) + if err := _Polygonrollupmanager.contract.UnpackLog(event, "VerifyBatchesTrustedAggregator", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/etherman/smartcontracts/polygonzkevm/polygonzkevm.go b/etherman/smartcontracts/polygonzkevm/polygonzkevm.go new file mode 100644 index 0000000..5beeb1e --- /dev/null +++ b/etherman/smartcontracts/polygonzkevm/polygonzkevm.go @@ -0,0 +1,3099 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package polygonzkevm + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// PolygonRollupBaseEtrogBatchData is an auto generated low-level Go binding around an user-defined struct. +type PolygonRollupBaseEtrogBatchData struct { + Transactions []byte + ForcedGlobalExitRoot [32]byte + ForcedTimestamp uint64 + ForcedBlockHashL1 [32]byte +} + +// PolygonzkevmMetaData contains all meta data concerning the Polygonzkevm contract. +var PolygonzkevmMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[{\"internalType\":\"contractIPolygonZkEVMGlobalExitRootV2\",\"name\":\"_globalExitRootManager\",\"type\":\"address\"},{\"internalType\":\"contractIERC20Upgradeable\",\"name\":\"_pol\",\"type\":\"address\"},{\"internalType\":\"contractIPolygonZkEVMBridgeV2\",\"name\":\"_bridgeAddress\",\"type\":\"address\"},{\"internalType\":\"contractPolygonRollupManager\",\"name\":\"_rollupManager\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"BatchAlreadyVerified\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"BatchNotSequencedOrNotSequenceEnd\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ExceedMaxVerifyBatches\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FinalNumBatchBelowLastVerifiedBatch\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FinalNumBatchDoesNotMatchPendingState\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FinalPendingStateNumInvalid\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ForceBatchNotAllowed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ForceBatchTimeoutNotExpired\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ForceBatchesAlreadyActive\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ForceBatchesOverflow\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ForcedDataDoesNotMatch\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"GasTokenNetworkMustBeZeroOnEther\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"GlobalExitRootNotExist\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"HaltTimeoutNotExpired\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"HugeTokenMetadataNotSupported\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InitNumBatchAboveLastVerifiedBatch\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InitNumBatchDoesNotMatchPendingState\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidInitializeTransaction\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidProof\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidRangeBatchTimeTarget\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidRangeForceBatchTimeout\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidRangeMultiplierBatchFee\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NewAccInputHashDoesNotExist\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NewPendingStateTimeoutMustBeLower\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NewStateRootNotInsidePrime\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NewTrustedAggregatorTimeoutMustBeLower\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotEnoughMaticAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotEnoughPOLAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OldAccInputHashDoesNotExist\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OldStateRootDoesNotExist\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OnlyAdmin\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OnlyPendingAdmin\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OnlyRollupManager\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OnlyTrustedAggregator\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OnlyTrustedSequencer\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"PendingStateDoesNotExist\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"PendingStateInvalid\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"PendingStateNotConsolidable\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"PendingStateTimeoutExceedHaltAggregationTimeout\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SequenceZeroBatches\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SequencedTimestampBelowForcedTimestamp\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SequencedTimestampInvalid\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"StoredRootMustBeDifferentThanNewRoot\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TransactionsLengthAboveMax\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TrustedAggregatorTimeoutExceedHaltAggregationTimeout\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TrustedAggregatorTimeoutNotExpired\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AcceptAdminRole\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[],\"name\":\"ActivateForceBatches\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint64\",\"name\":\"forceBatchNum\",\"type\":\"uint64\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"lastGlobalExitRoot\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sequencer\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"transactions\",\"type\":\"bytes\"}],\"name\":\"ForceBatch\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"transactions\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"lastGlobalExitRoot\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sequencer\",\"type\":\"address\"}],\"name\":\"InitialSequenceBatches\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint64\",\"name\":\"numBatch\",\"type\":\"uint64\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"l1InfoRoot\",\"type\":\"bytes32\"}],\"name\":\"SequenceBatches\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint64\",\"name\":\"numBatch\",\"type\":\"uint64\"}],\"name\":\"SequenceForceBatches\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"newforceBatchTimeout\",\"type\":\"uint64\"}],\"name\":\"SetForceBatchTimeout\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newTrustedSequencer\",\"type\":\"address\"}],\"name\":\"SetTrustedSequencer\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"newTrustedSequencerURL\",\"type\":\"string\"}],\"name\":\"SetTrustedSequencerURL\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newPendingAdmin\",\"type\":\"address\"}],\"name\":\"TransferAdminRole\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint64\",\"name\":\"numBatch\",\"type\":\"uint64\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"stateRoot\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"aggregator\",\"type\":\"address\"}],\"name\":\"VerifyBatches\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"GLOBAL_EXIT_ROOT_MANAGER_L2\",\"outputs\":[{\"internalType\":\"contractIBasePolygonZkEVMGlobalExitRoot\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"INITIALIZE_TX_BRIDGE_LIST_LEN_LEN\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"INITIALIZE_TX_BRIDGE_PARAMS\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"INITIALIZE_TX_BRIDGE_PARAMS_AFTER_BRIDGE_ADDRESS\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"INITIALIZE_TX_BRIDGE_PARAMS_AFTER_BRIDGE_ADDRESS_EMPTY_METADATA\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"INITIALIZE_TX_CONSTANT_BYTES\",\"outputs\":[{\"internalType\":\"uint16\",\"name\":\"\",\"type\":\"uint16\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"INITIALIZE_TX_CONSTANT_BYTES_EMPTY_METADATA\",\"outputs\":[{\"internalType\":\"uint16\",\"name\":\"\",\"type\":\"uint16\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"INITIALIZE_TX_DATA_LEN_EMPTY_METADATA\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"INITIALIZE_TX_EFFECTIVE_PERCENTAGE\",\"outputs\":[{\"internalType\":\"bytes1\",\"name\":\"\",\"type\":\"bytes1\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"SIGNATURE_INITIALIZE_TX_R\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"SIGNATURE_INITIALIZE_TX_S\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"SIGNATURE_INITIALIZE_TX_V\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"acceptAdminRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"activateForceBatches\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"admin\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"bridgeAddress\",\"outputs\":[{\"internalType\":\"contractIPolygonZkEVMBridgeV2\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"calculatePolPerForceBatch\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"transactions\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"polAmount\",\"type\":\"uint256\"}],\"name\":\"forceBatch\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"forceBatchTimeout\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"name\":\"forcedBatches\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"gapLastTimestamp\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"gasTokenAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"gasTokenNetwork\",\"outputs\":[{\"internalType\":\"uint32\",\"name\":\"\",\"type\":\"uint32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"networkID\",\"type\":\"uint32\"},{\"internalType\":\"address\",\"name\":\"_gasTokenAddress\",\"type\":\"address\"},{\"internalType\":\"uint32\",\"name\":\"_gasTokenNetwork\",\"type\":\"uint32\"},{\"internalType\":\"bytes\",\"name\":\"_gasTokenMetadata\",\"type\":\"bytes\"}],\"name\":\"generateInitializeTransaction\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"globalExitRootManager\",\"outputs\":[{\"internalType\":\"contractIPolygonZkEVMGlobalExitRootV2\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_admin\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"sequencer\",\"type\":\"address\"},{\"internalType\":\"uint32\",\"name\":\"networkID\",\"type\":\"uint32\"},{\"internalType\":\"address\",\"name\":\"_gasTokenAddress\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"sequencerURL\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"_networkName\",\"type\":\"string\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"isForcedBatchAllowed\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"lastAccInputHash\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"lastForceBatch\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"lastForceBatchSequenced\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"networkName\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint64\",\"name\":\"lastVerifiedBatch\",\"type\":\"uint64\"},{\"internalType\":\"bytes32\",\"name\":\"newStateRoot\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"aggregator\",\"type\":\"address\"}],\"name\":\"onVerifyBatches\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pendingAdmin\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pol\",\"outputs\":[{\"internalType\":\"contractIERC20Upgradeable\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"rollupManager\",\"outputs\":[{\"internalType\":\"contractPolygonRollupManager\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"transactions\",\"type\":\"bytes\"},{\"internalType\":\"bytes32\",\"name\":\"forcedGlobalExitRoot\",\"type\":\"bytes32\"},{\"internalType\":\"uint64\",\"name\":\"forcedTimestamp\",\"type\":\"uint64\"},{\"internalType\":\"bytes32\",\"name\":\"forcedBlockHashL1\",\"type\":\"bytes32\"}],\"internalType\":\"structPolygonRollupBaseEtrog.BatchData[]\",\"name\":\"batches\",\"type\":\"tuple[]\"},{\"internalType\":\"address\",\"name\":\"l2Coinbase\",\"type\":\"address\"}],\"name\":\"sequenceBatches\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"transactions\",\"type\":\"bytes\"},{\"internalType\":\"bytes32\",\"name\":\"forcedGlobalExitRoot\",\"type\":\"bytes32\"},{\"internalType\":\"uint64\",\"name\":\"forcedTimestamp\",\"type\":\"uint64\"},{\"internalType\":\"bytes32\",\"name\":\"forcedBlockHashL1\",\"type\":\"bytes32\"}],\"internalType\":\"structPolygonRollupBaseEtrog.BatchData[]\",\"name\":\"batches\",\"type\":\"tuple[]\"}],\"name\":\"sequenceForceBatches\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint64\",\"name\":\"newforceBatchTimeout\",\"type\":\"uint64\"}],\"name\":\"setForceBatchTimeout\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newTrustedSequencer\",\"type\":\"address\"}],\"name\":\"setTrustedSequencer\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"newTrustedSequencerURL\",\"type\":\"string\"}],\"name\":\"setTrustedSequencerURL\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newPendingAdmin\",\"type\":\"address\"}],\"name\":\"transferAdminRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"trustedSequencer\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"trustedSequencerURL\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", + Bin: "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", +} + +// PolygonzkevmABI is the input ABI used to generate the binding from. +// Deprecated: Use PolygonzkevmMetaData.ABI instead. +var PolygonzkevmABI = PolygonzkevmMetaData.ABI + +// PolygonzkevmBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use PolygonzkevmMetaData.Bin instead. +var PolygonzkevmBin = PolygonzkevmMetaData.Bin + +// DeployPolygonzkevm deploys a new Ethereum contract, binding an instance of Polygonzkevm to it. +func DeployPolygonzkevm(auth *bind.TransactOpts, backend bind.ContractBackend, _globalExitRootManager common.Address, _pol common.Address, _bridgeAddress common.Address, _rollupManager common.Address) (common.Address, *types.Transaction, *Polygonzkevm, error) { + parsed, err := PolygonzkevmMetaData.GetAbi() + if err != nil { + return common.Address{}, nil, nil, err + } + if parsed == nil { + return common.Address{}, nil, nil, errors.New("GetABI returned nil") + } + + address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex(PolygonzkevmBin), backend, _globalExitRootManager, _pol, _bridgeAddress, _rollupManager) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &Polygonzkevm{PolygonzkevmCaller: PolygonzkevmCaller{contract: contract}, PolygonzkevmTransactor: PolygonzkevmTransactor{contract: contract}, PolygonzkevmFilterer: PolygonzkevmFilterer{contract: contract}}, nil +} + +// Polygonzkevm is an auto generated Go binding around an Ethereum contract. +type Polygonzkevm struct { + PolygonzkevmCaller // Read-only binding to the contract + PolygonzkevmTransactor // Write-only binding to the contract + PolygonzkevmFilterer // Log filterer for contract events +} + +// PolygonzkevmCaller is an auto generated read-only Go binding around an Ethereum contract. +type PolygonzkevmCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// PolygonzkevmTransactor is an auto generated write-only Go binding around an Ethereum contract. +type PolygonzkevmTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// PolygonzkevmFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type PolygonzkevmFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// PolygonzkevmSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type PolygonzkevmSession struct { + Contract *Polygonzkevm // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// PolygonzkevmCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type PolygonzkevmCallerSession struct { + Contract *PolygonzkevmCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// PolygonzkevmTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type PolygonzkevmTransactorSession struct { + Contract *PolygonzkevmTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// PolygonzkevmRaw is an auto generated low-level Go binding around an Ethereum contract. +type PolygonzkevmRaw struct { + Contract *Polygonzkevm // Generic contract binding to access the raw methods on +} + +// PolygonzkevmCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type PolygonzkevmCallerRaw struct { + Contract *PolygonzkevmCaller // Generic read-only contract binding to access the raw methods on +} + +// PolygonzkevmTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type PolygonzkevmTransactorRaw struct { + Contract *PolygonzkevmTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewPolygonzkevm creates a new instance of Polygonzkevm, bound to a specific deployed contract. +func NewPolygonzkevm(address common.Address, backend bind.ContractBackend) (*Polygonzkevm, error) { + contract, err := bindPolygonzkevm(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &Polygonzkevm{PolygonzkevmCaller: PolygonzkevmCaller{contract: contract}, PolygonzkevmTransactor: PolygonzkevmTransactor{contract: contract}, PolygonzkevmFilterer: PolygonzkevmFilterer{contract: contract}}, nil +} + +// NewPolygonzkevmCaller creates a new read-only instance of Polygonzkevm, bound to a specific deployed contract. +func NewPolygonzkevmCaller(address common.Address, caller bind.ContractCaller) (*PolygonzkevmCaller, error) { + contract, err := bindPolygonzkevm(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &PolygonzkevmCaller{contract: contract}, nil +} + +// NewPolygonzkevmTransactor creates a new write-only instance of Polygonzkevm, bound to a specific deployed contract. +func NewPolygonzkevmTransactor(address common.Address, transactor bind.ContractTransactor) (*PolygonzkevmTransactor, error) { + contract, err := bindPolygonzkevm(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &PolygonzkevmTransactor{contract: contract}, nil +} + +// NewPolygonzkevmFilterer creates a new log filterer instance of Polygonzkevm, bound to a specific deployed contract. +func NewPolygonzkevmFilterer(address common.Address, filterer bind.ContractFilterer) (*PolygonzkevmFilterer, error) { + contract, err := bindPolygonzkevm(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &PolygonzkevmFilterer{contract: contract}, nil +} + +// bindPolygonzkevm binds a generic wrapper to an already deployed contract. +func bindPolygonzkevm(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := PolygonzkevmMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Polygonzkevm *PolygonzkevmRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Polygonzkevm.Contract.PolygonzkevmCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Polygonzkevm *PolygonzkevmRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Polygonzkevm.Contract.PolygonzkevmTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Polygonzkevm *PolygonzkevmRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Polygonzkevm.Contract.PolygonzkevmTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Polygonzkevm *PolygonzkevmCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Polygonzkevm.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Polygonzkevm *PolygonzkevmTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Polygonzkevm.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Polygonzkevm *PolygonzkevmTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Polygonzkevm.Contract.contract.Transact(opts, method, params...) +} + +// GLOBALEXITROOTMANAGERL2 is a free data retrieval call binding the contract method 0x9e001877. +// +// Solidity: function GLOBAL_EXIT_ROOT_MANAGER_L2() view returns(address) +func (_Polygonzkevm *PolygonzkevmCaller) GLOBALEXITROOTMANAGERL2(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Polygonzkevm.contract.Call(opts, &out, "GLOBAL_EXIT_ROOT_MANAGER_L2") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// GLOBALEXITROOTMANAGERL2 is a free data retrieval call binding the contract method 0x9e001877. +// +// Solidity: function GLOBAL_EXIT_ROOT_MANAGER_L2() view returns(address) +func (_Polygonzkevm *PolygonzkevmSession) GLOBALEXITROOTMANAGERL2() (common.Address, error) { + return _Polygonzkevm.Contract.GLOBALEXITROOTMANAGERL2(&_Polygonzkevm.CallOpts) +} + +// GLOBALEXITROOTMANAGERL2 is a free data retrieval call binding the contract method 0x9e001877. +// +// Solidity: function GLOBAL_EXIT_ROOT_MANAGER_L2() view returns(address) +func (_Polygonzkevm *PolygonzkevmCallerSession) GLOBALEXITROOTMANAGERL2() (common.Address, error) { + return _Polygonzkevm.Contract.GLOBALEXITROOTMANAGERL2(&_Polygonzkevm.CallOpts) +} + +// INITIALIZETXBRIDGELISTLENLEN is a free data retrieval call binding the contract method 0x11e892d4. +// +// Solidity: function INITIALIZE_TX_BRIDGE_LIST_LEN_LEN() view returns(uint8) +func (_Polygonzkevm *PolygonzkevmCaller) INITIALIZETXBRIDGELISTLENLEN(opts *bind.CallOpts) (uint8, error) { + var out []interface{} + err := _Polygonzkevm.contract.Call(opts, &out, "INITIALIZE_TX_BRIDGE_LIST_LEN_LEN") + + if err != nil { + return *new(uint8), err + } + + out0 := *abi.ConvertType(out[0], new(uint8)).(*uint8) + + return out0, err + +} + +// INITIALIZETXBRIDGELISTLENLEN is a free data retrieval call binding the contract method 0x11e892d4. +// +// Solidity: function INITIALIZE_TX_BRIDGE_LIST_LEN_LEN() view returns(uint8) +func (_Polygonzkevm *PolygonzkevmSession) INITIALIZETXBRIDGELISTLENLEN() (uint8, error) { + return _Polygonzkevm.Contract.INITIALIZETXBRIDGELISTLENLEN(&_Polygonzkevm.CallOpts) +} + +// INITIALIZETXBRIDGELISTLENLEN is a free data retrieval call binding the contract method 0x11e892d4. +// +// Solidity: function INITIALIZE_TX_BRIDGE_LIST_LEN_LEN() view returns(uint8) +func (_Polygonzkevm *PolygonzkevmCallerSession) INITIALIZETXBRIDGELISTLENLEN() (uint8, error) { + return _Polygonzkevm.Contract.INITIALIZETXBRIDGELISTLENLEN(&_Polygonzkevm.CallOpts) +} + +// INITIALIZETXBRIDGEPARAMS is a free data retrieval call binding the contract method 0x05835f37. +// +// Solidity: function INITIALIZE_TX_BRIDGE_PARAMS() view returns(bytes) +func (_Polygonzkevm *PolygonzkevmCaller) INITIALIZETXBRIDGEPARAMS(opts *bind.CallOpts) ([]byte, error) { + var out []interface{} + err := _Polygonzkevm.contract.Call(opts, &out, "INITIALIZE_TX_BRIDGE_PARAMS") + + if err != nil { + return *new([]byte), err + } + + out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte) + + return out0, err + +} + +// INITIALIZETXBRIDGEPARAMS is a free data retrieval call binding the contract method 0x05835f37. +// +// Solidity: function INITIALIZE_TX_BRIDGE_PARAMS() view returns(bytes) +func (_Polygonzkevm *PolygonzkevmSession) INITIALIZETXBRIDGEPARAMS() ([]byte, error) { + return _Polygonzkevm.Contract.INITIALIZETXBRIDGEPARAMS(&_Polygonzkevm.CallOpts) +} + +// INITIALIZETXBRIDGEPARAMS is a free data retrieval call binding the contract method 0x05835f37. +// +// Solidity: function INITIALIZE_TX_BRIDGE_PARAMS() view returns(bytes) +func (_Polygonzkevm *PolygonzkevmCallerSession) INITIALIZETXBRIDGEPARAMS() ([]byte, error) { + return _Polygonzkevm.Contract.INITIALIZETXBRIDGEPARAMS(&_Polygonzkevm.CallOpts) +} + +// INITIALIZETXBRIDGEPARAMSAFTERBRIDGEADDRESS is a free data retrieval call binding the contract method 0x7a5460c5. +// +// Solidity: function INITIALIZE_TX_BRIDGE_PARAMS_AFTER_BRIDGE_ADDRESS() view returns(bytes) +func (_Polygonzkevm *PolygonzkevmCaller) INITIALIZETXBRIDGEPARAMSAFTERBRIDGEADDRESS(opts *bind.CallOpts) ([]byte, error) { + var out []interface{} + err := _Polygonzkevm.contract.Call(opts, &out, "INITIALIZE_TX_BRIDGE_PARAMS_AFTER_BRIDGE_ADDRESS") + + if err != nil { + return *new([]byte), err + } + + out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte) + + return out0, err + +} + +// INITIALIZETXBRIDGEPARAMSAFTERBRIDGEADDRESS is a free data retrieval call binding the contract method 0x7a5460c5. +// +// Solidity: function INITIALIZE_TX_BRIDGE_PARAMS_AFTER_BRIDGE_ADDRESS() view returns(bytes) +func (_Polygonzkevm *PolygonzkevmSession) INITIALIZETXBRIDGEPARAMSAFTERBRIDGEADDRESS() ([]byte, error) { + return _Polygonzkevm.Contract.INITIALIZETXBRIDGEPARAMSAFTERBRIDGEADDRESS(&_Polygonzkevm.CallOpts) +} + +// INITIALIZETXBRIDGEPARAMSAFTERBRIDGEADDRESS is a free data retrieval call binding the contract method 0x7a5460c5. +// +// Solidity: function INITIALIZE_TX_BRIDGE_PARAMS_AFTER_BRIDGE_ADDRESS() view returns(bytes) +func (_Polygonzkevm *PolygonzkevmCallerSession) INITIALIZETXBRIDGEPARAMSAFTERBRIDGEADDRESS() ([]byte, error) { + return _Polygonzkevm.Contract.INITIALIZETXBRIDGEPARAMSAFTERBRIDGEADDRESS(&_Polygonzkevm.CallOpts) +} + +// INITIALIZETXBRIDGEPARAMSAFTERBRIDGEADDRESSEMPTYMETADATA is a free data retrieval call binding the contract method 0x52bdeb6d. +// +// Solidity: function INITIALIZE_TX_BRIDGE_PARAMS_AFTER_BRIDGE_ADDRESS_EMPTY_METADATA() view returns(bytes) +func (_Polygonzkevm *PolygonzkevmCaller) INITIALIZETXBRIDGEPARAMSAFTERBRIDGEADDRESSEMPTYMETADATA(opts *bind.CallOpts) ([]byte, error) { + var out []interface{} + err := _Polygonzkevm.contract.Call(opts, &out, "INITIALIZE_TX_BRIDGE_PARAMS_AFTER_BRIDGE_ADDRESS_EMPTY_METADATA") + + if err != nil { + return *new([]byte), err + } + + out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte) + + return out0, err + +} + +// INITIALIZETXBRIDGEPARAMSAFTERBRIDGEADDRESSEMPTYMETADATA is a free data retrieval call binding the contract method 0x52bdeb6d. +// +// Solidity: function INITIALIZE_TX_BRIDGE_PARAMS_AFTER_BRIDGE_ADDRESS_EMPTY_METADATA() view returns(bytes) +func (_Polygonzkevm *PolygonzkevmSession) INITIALIZETXBRIDGEPARAMSAFTERBRIDGEADDRESSEMPTYMETADATA() ([]byte, error) { + return _Polygonzkevm.Contract.INITIALIZETXBRIDGEPARAMSAFTERBRIDGEADDRESSEMPTYMETADATA(&_Polygonzkevm.CallOpts) +} + +// INITIALIZETXBRIDGEPARAMSAFTERBRIDGEADDRESSEMPTYMETADATA is a free data retrieval call binding the contract method 0x52bdeb6d. +// +// Solidity: function INITIALIZE_TX_BRIDGE_PARAMS_AFTER_BRIDGE_ADDRESS_EMPTY_METADATA() view returns(bytes) +func (_Polygonzkevm *PolygonzkevmCallerSession) INITIALIZETXBRIDGEPARAMSAFTERBRIDGEADDRESSEMPTYMETADATA() ([]byte, error) { + return _Polygonzkevm.Contract.INITIALIZETXBRIDGEPARAMSAFTERBRIDGEADDRESSEMPTYMETADATA(&_Polygonzkevm.CallOpts) +} + +// INITIALIZETXCONSTANTBYTES is a free data retrieval call binding the contract method 0x03508963. +// +// Solidity: function INITIALIZE_TX_CONSTANT_BYTES() view returns(uint16) +func (_Polygonzkevm *PolygonzkevmCaller) INITIALIZETXCONSTANTBYTES(opts *bind.CallOpts) (uint16, error) { + var out []interface{} + err := _Polygonzkevm.contract.Call(opts, &out, "INITIALIZE_TX_CONSTANT_BYTES") + + if err != nil { + return *new(uint16), err + } + + out0 := *abi.ConvertType(out[0], new(uint16)).(*uint16) + + return out0, err + +} + +// INITIALIZETXCONSTANTBYTES is a free data retrieval call binding the contract method 0x03508963. +// +// Solidity: function INITIALIZE_TX_CONSTANT_BYTES() view returns(uint16) +func (_Polygonzkevm *PolygonzkevmSession) INITIALIZETXCONSTANTBYTES() (uint16, error) { + return _Polygonzkevm.Contract.INITIALIZETXCONSTANTBYTES(&_Polygonzkevm.CallOpts) +} + +// INITIALIZETXCONSTANTBYTES is a free data retrieval call binding the contract method 0x03508963. +// +// Solidity: function INITIALIZE_TX_CONSTANT_BYTES() view returns(uint16) +func (_Polygonzkevm *PolygonzkevmCallerSession) INITIALIZETXCONSTANTBYTES() (uint16, error) { + return _Polygonzkevm.Contract.INITIALIZETXCONSTANTBYTES(&_Polygonzkevm.CallOpts) +} + +// INITIALIZETXCONSTANTBYTESEMPTYMETADATA is a free data retrieval call binding the contract method 0x676870d2. +// +// Solidity: function INITIALIZE_TX_CONSTANT_BYTES_EMPTY_METADATA() view returns(uint16) +func (_Polygonzkevm *PolygonzkevmCaller) INITIALIZETXCONSTANTBYTESEMPTYMETADATA(opts *bind.CallOpts) (uint16, error) { + var out []interface{} + err := _Polygonzkevm.contract.Call(opts, &out, "INITIALIZE_TX_CONSTANT_BYTES_EMPTY_METADATA") + + if err != nil { + return *new(uint16), err + } + + out0 := *abi.ConvertType(out[0], new(uint16)).(*uint16) + + return out0, err + +} + +// INITIALIZETXCONSTANTBYTESEMPTYMETADATA is a free data retrieval call binding the contract method 0x676870d2. +// +// Solidity: function INITIALIZE_TX_CONSTANT_BYTES_EMPTY_METADATA() view returns(uint16) +func (_Polygonzkevm *PolygonzkevmSession) INITIALIZETXCONSTANTBYTESEMPTYMETADATA() (uint16, error) { + return _Polygonzkevm.Contract.INITIALIZETXCONSTANTBYTESEMPTYMETADATA(&_Polygonzkevm.CallOpts) +} + +// INITIALIZETXCONSTANTBYTESEMPTYMETADATA is a free data retrieval call binding the contract method 0x676870d2. +// +// Solidity: function INITIALIZE_TX_CONSTANT_BYTES_EMPTY_METADATA() view returns(uint16) +func (_Polygonzkevm *PolygonzkevmCallerSession) INITIALIZETXCONSTANTBYTESEMPTYMETADATA() (uint16, error) { + return _Polygonzkevm.Contract.INITIALIZETXCONSTANTBYTESEMPTYMETADATA(&_Polygonzkevm.CallOpts) +} + +// INITIALIZETXDATALENEMPTYMETADATA is a free data retrieval call binding the contract method 0xc7fffd4b. +// +// Solidity: function INITIALIZE_TX_DATA_LEN_EMPTY_METADATA() view returns(uint8) +func (_Polygonzkevm *PolygonzkevmCaller) INITIALIZETXDATALENEMPTYMETADATA(opts *bind.CallOpts) (uint8, error) { + var out []interface{} + err := _Polygonzkevm.contract.Call(opts, &out, "INITIALIZE_TX_DATA_LEN_EMPTY_METADATA") + + if err != nil { + return *new(uint8), err + } + + out0 := *abi.ConvertType(out[0], new(uint8)).(*uint8) + + return out0, err + +} + +// INITIALIZETXDATALENEMPTYMETADATA is a free data retrieval call binding the contract method 0xc7fffd4b. +// +// Solidity: function INITIALIZE_TX_DATA_LEN_EMPTY_METADATA() view returns(uint8) +func (_Polygonzkevm *PolygonzkevmSession) INITIALIZETXDATALENEMPTYMETADATA() (uint8, error) { + return _Polygonzkevm.Contract.INITIALIZETXDATALENEMPTYMETADATA(&_Polygonzkevm.CallOpts) +} + +// INITIALIZETXDATALENEMPTYMETADATA is a free data retrieval call binding the contract method 0xc7fffd4b. +// +// Solidity: function INITIALIZE_TX_DATA_LEN_EMPTY_METADATA() view returns(uint8) +func (_Polygonzkevm *PolygonzkevmCallerSession) INITIALIZETXDATALENEMPTYMETADATA() (uint8, error) { + return _Polygonzkevm.Contract.INITIALIZETXDATALENEMPTYMETADATA(&_Polygonzkevm.CallOpts) +} + +// INITIALIZETXEFFECTIVEPERCENTAGE is a free data retrieval call binding the contract method 0x40b5de6c. +// +// Solidity: function INITIALIZE_TX_EFFECTIVE_PERCENTAGE() view returns(bytes1) +func (_Polygonzkevm *PolygonzkevmCaller) INITIALIZETXEFFECTIVEPERCENTAGE(opts *bind.CallOpts) ([1]byte, error) { + var out []interface{} + err := _Polygonzkevm.contract.Call(opts, &out, "INITIALIZE_TX_EFFECTIVE_PERCENTAGE") + + if err != nil { + return *new([1]byte), err + } + + out0 := *abi.ConvertType(out[0], new([1]byte)).(*[1]byte) + + return out0, err + +} + +// INITIALIZETXEFFECTIVEPERCENTAGE is a free data retrieval call binding the contract method 0x40b5de6c. +// +// Solidity: function INITIALIZE_TX_EFFECTIVE_PERCENTAGE() view returns(bytes1) +func (_Polygonzkevm *PolygonzkevmSession) INITIALIZETXEFFECTIVEPERCENTAGE() ([1]byte, error) { + return _Polygonzkevm.Contract.INITIALIZETXEFFECTIVEPERCENTAGE(&_Polygonzkevm.CallOpts) +} + +// INITIALIZETXEFFECTIVEPERCENTAGE is a free data retrieval call binding the contract method 0x40b5de6c. +// +// Solidity: function INITIALIZE_TX_EFFECTIVE_PERCENTAGE() view returns(bytes1) +func (_Polygonzkevm *PolygonzkevmCallerSession) INITIALIZETXEFFECTIVEPERCENTAGE() ([1]byte, error) { + return _Polygonzkevm.Contract.INITIALIZETXEFFECTIVEPERCENTAGE(&_Polygonzkevm.CallOpts) +} + +// SIGNATUREINITIALIZETXR is a free data retrieval call binding the contract method 0xb0afe154. +// +// Solidity: function SIGNATURE_INITIALIZE_TX_R() view returns(bytes32) +func (_Polygonzkevm *PolygonzkevmCaller) SIGNATUREINITIALIZETXR(opts *bind.CallOpts) ([32]byte, error) { + var out []interface{} + err := _Polygonzkevm.contract.Call(opts, &out, "SIGNATURE_INITIALIZE_TX_R") + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// SIGNATUREINITIALIZETXR is a free data retrieval call binding the contract method 0xb0afe154. +// +// Solidity: function SIGNATURE_INITIALIZE_TX_R() view returns(bytes32) +func (_Polygonzkevm *PolygonzkevmSession) SIGNATUREINITIALIZETXR() ([32]byte, error) { + return _Polygonzkevm.Contract.SIGNATUREINITIALIZETXR(&_Polygonzkevm.CallOpts) +} + +// SIGNATUREINITIALIZETXR is a free data retrieval call binding the contract method 0xb0afe154. +// +// Solidity: function SIGNATURE_INITIALIZE_TX_R() view returns(bytes32) +func (_Polygonzkevm *PolygonzkevmCallerSession) SIGNATUREINITIALIZETXR() ([32]byte, error) { + return _Polygonzkevm.Contract.SIGNATUREINITIALIZETXR(&_Polygonzkevm.CallOpts) +} + +// SIGNATUREINITIALIZETXS is a free data retrieval call binding the contract method 0xd7bc90ff. +// +// Solidity: function SIGNATURE_INITIALIZE_TX_S() view returns(bytes32) +func (_Polygonzkevm *PolygonzkevmCaller) SIGNATUREINITIALIZETXS(opts *bind.CallOpts) ([32]byte, error) { + var out []interface{} + err := _Polygonzkevm.contract.Call(opts, &out, "SIGNATURE_INITIALIZE_TX_S") + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// SIGNATUREINITIALIZETXS is a free data retrieval call binding the contract method 0xd7bc90ff. +// +// Solidity: function SIGNATURE_INITIALIZE_TX_S() view returns(bytes32) +func (_Polygonzkevm *PolygonzkevmSession) SIGNATUREINITIALIZETXS() ([32]byte, error) { + return _Polygonzkevm.Contract.SIGNATUREINITIALIZETXS(&_Polygonzkevm.CallOpts) +} + +// SIGNATUREINITIALIZETXS is a free data retrieval call binding the contract method 0xd7bc90ff. +// +// Solidity: function SIGNATURE_INITIALIZE_TX_S() view returns(bytes32) +func (_Polygonzkevm *PolygonzkevmCallerSession) SIGNATUREINITIALIZETXS() ([32]byte, error) { + return _Polygonzkevm.Contract.SIGNATUREINITIALIZETXS(&_Polygonzkevm.CallOpts) +} + +// SIGNATUREINITIALIZETXV is a free data retrieval call binding the contract method 0xf35dda47. +// +// Solidity: function SIGNATURE_INITIALIZE_TX_V() view returns(uint8) +func (_Polygonzkevm *PolygonzkevmCaller) SIGNATUREINITIALIZETXV(opts *bind.CallOpts) (uint8, error) { + var out []interface{} + err := _Polygonzkevm.contract.Call(opts, &out, "SIGNATURE_INITIALIZE_TX_V") + + if err != nil { + return *new(uint8), err + } + + out0 := *abi.ConvertType(out[0], new(uint8)).(*uint8) + + return out0, err + +} + +// SIGNATUREINITIALIZETXV is a free data retrieval call binding the contract method 0xf35dda47. +// +// Solidity: function SIGNATURE_INITIALIZE_TX_V() view returns(uint8) +func (_Polygonzkevm *PolygonzkevmSession) SIGNATUREINITIALIZETXV() (uint8, error) { + return _Polygonzkevm.Contract.SIGNATUREINITIALIZETXV(&_Polygonzkevm.CallOpts) +} + +// SIGNATUREINITIALIZETXV is a free data retrieval call binding the contract method 0xf35dda47. +// +// Solidity: function SIGNATURE_INITIALIZE_TX_V() view returns(uint8) +func (_Polygonzkevm *PolygonzkevmCallerSession) SIGNATUREINITIALIZETXV() (uint8, error) { + return _Polygonzkevm.Contract.SIGNATUREINITIALIZETXV(&_Polygonzkevm.CallOpts) +} + +// Admin is a free data retrieval call binding the contract method 0xf851a440. +// +// Solidity: function admin() view returns(address) +func (_Polygonzkevm *PolygonzkevmCaller) Admin(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Polygonzkevm.contract.Call(opts, &out, "admin") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// Admin is a free data retrieval call binding the contract method 0xf851a440. +// +// Solidity: function admin() view returns(address) +func (_Polygonzkevm *PolygonzkevmSession) Admin() (common.Address, error) { + return _Polygonzkevm.Contract.Admin(&_Polygonzkevm.CallOpts) +} + +// Admin is a free data retrieval call binding the contract method 0xf851a440. +// +// Solidity: function admin() view returns(address) +func (_Polygonzkevm *PolygonzkevmCallerSession) Admin() (common.Address, error) { + return _Polygonzkevm.Contract.Admin(&_Polygonzkevm.CallOpts) +} + +// BridgeAddress is a free data retrieval call binding the contract method 0xa3c573eb. +// +// Solidity: function bridgeAddress() view returns(address) +func (_Polygonzkevm *PolygonzkevmCaller) BridgeAddress(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Polygonzkevm.contract.Call(opts, &out, "bridgeAddress") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// BridgeAddress is a free data retrieval call binding the contract method 0xa3c573eb. +// +// Solidity: function bridgeAddress() view returns(address) +func (_Polygonzkevm *PolygonzkevmSession) BridgeAddress() (common.Address, error) { + return _Polygonzkevm.Contract.BridgeAddress(&_Polygonzkevm.CallOpts) +} + +// BridgeAddress is a free data retrieval call binding the contract method 0xa3c573eb. +// +// Solidity: function bridgeAddress() view returns(address) +func (_Polygonzkevm *PolygonzkevmCallerSession) BridgeAddress() (common.Address, error) { + return _Polygonzkevm.Contract.BridgeAddress(&_Polygonzkevm.CallOpts) +} + +// CalculatePolPerForceBatch is a free data retrieval call binding the contract method 0x00d0295d. +// +// Solidity: function calculatePolPerForceBatch() view returns(uint256) +func (_Polygonzkevm *PolygonzkevmCaller) CalculatePolPerForceBatch(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _Polygonzkevm.contract.Call(opts, &out, "calculatePolPerForceBatch") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// CalculatePolPerForceBatch is a free data retrieval call binding the contract method 0x00d0295d. +// +// Solidity: function calculatePolPerForceBatch() view returns(uint256) +func (_Polygonzkevm *PolygonzkevmSession) CalculatePolPerForceBatch() (*big.Int, error) { + return _Polygonzkevm.Contract.CalculatePolPerForceBatch(&_Polygonzkevm.CallOpts) +} + +// CalculatePolPerForceBatch is a free data retrieval call binding the contract method 0x00d0295d. +// +// Solidity: function calculatePolPerForceBatch() view returns(uint256) +func (_Polygonzkevm *PolygonzkevmCallerSession) CalculatePolPerForceBatch() (*big.Int, error) { + return _Polygonzkevm.Contract.CalculatePolPerForceBatch(&_Polygonzkevm.CallOpts) +} + +// ForceBatchTimeout is a free data retrieval call binding the contract method 0xc754c7ed. +// +// Solidity: function forceBatchTimeout() view returns(uint64) +func (_Polygonzkevm *PolygonzkevmCaller) ForceBatchTimeout(opts *bind.CallOpts) (uint64, error) { + var out []interface{} + err := _Polygonzkevm.contract.Call(opts, &out, "forceBatchTimeout") + + if err != nil { + return *new(uint64), err + } + + out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64) + + return out0, err + +} + +// ForceBatchTimeout is a free data retrieval call binding the contract method 0xc754c7ed. +// +// Solidity: function forceBatchTimeout() view returns(uint64) +func (_Polygonzkevm *PolygonzkevmSession) ForceBatchTimeout() (uint64, error) { + return _Polygonzkevm.Contract.ForceBatchTimeout(&_Polygonzkevm.CallOpts) +} + +// ForceBatchTimeout is a free data retrieval call binding the contract method 0xc754c7ed. +// +// Solidity: function forceBatchTimeout() view returns(uint64) +func (_Polygonzkevm *PolygonzkevmCallerSession) ForceBatchTimeout() (uint64, error) { + return _Polygonzkevm.Contract.ForceBatchTimeout(&_Polygonzkevm.CallOpts) +} + +// ForcedBatches is a free data retrieval call binding the contract method 0x6b8616ce. +// +// Solidity: function forcedBatches(uint64 ) view returns(bytes32) +func (_Polygonzkevm *PolygonzkevmCaller) ForcedBatches(opts *bind.CallOpts, arg0 uint64) ([32]byte, error) { + var out []interface{} + err := _Polygonzkevm.contract.Call(opts, &out, "forcedBatches", arg0) + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// ForcedBatches is a free data retrieval call binding the contract method 0x6b8616ce. +// +// Solidity: function forcedBatches(uint64 ) view returns(bytes32) +func (_Polygonzkevm *PolygonzkevmSession) ForcedBatches(arg0 uint64) ([32]byte, error) { + return _Polygonzkevm.Contract.ForcedBatches(&_Polygonzkevm.CallOpts, arg0) +} + +// ForcedBatches is a free data retrieval call binding the contract method 0x6b8616ce. +// +// Solidity: function forcedBatches(uint64 ) view returns(bytes32) +func (_Polygonzkevm *PolygonzkevmCallerSession) ForcedBatches(arg0 uint64) ([32]byte, error) { + return _Polygonzkevm.Contract.ForcedBatches(&_Polygonzkevm.CallOpts, arg0) +} + +// GapLastTimestamp is a free data retrieval call binding the contract method 0x2a9f208f. +// +// Solidity: function gapLastTimestamp() view returns(uint64) +func (_Polygonzkevm *PolygonzkevmCaller) GapLastTimestamp(opts *bind.CallOpts) (uint64, error) { + var out []interface{} + err := _Polygonzkevm.contract.Call(opts, &out, "gapLastTimestamp") + + if err != nil { + return *new(uint64), err + } + + out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64) + + return out0, err + +} + +// GapLastTimestamp is a free data retrieval call binding the contract method 0x2a9f208f. +// +// Solidity: function gapLastTimestamp() view returns(uint64) +func (_Polygonzkevm *PolygonzkevmSession) GapLastTimestamp() (uint64, error) { + return _Polygonzkevm.Contract.GapLastTimestamp(&_Polygonzkevm.CallOpts) +} + +// GapLastTimestamp is a free data retrieval call binding the contract method 0x2a9f208f. +// +// Solidity: function gapLastTimestamp() view returns(uint64) +func (_Polygonzkevm *PolygonzkevmCallerSession) GapLastTimestamp() (uint64, error) { + return _Polygonzkevm.Contract.GapLastTimestamp(&_Polygonzkevm.CallOpts) +} + +// GasTokenAddress is a free data retrieval call binding the contract method 0x3c351e10. +// +// Solidity: function gasTokenAddress() view returns(address) +func (_Polygonzkevm *PolygonzkevmCaller) GasTokenAddress(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Polygonzkevm.contract.Call(opts, &out, "gasTokenAddress") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// GasTokenAddress is a free data retrieval call binding the contract method 0x3c351e10. +// +// Solidity: function gasTokenAddress() view returns(address) +func (_Polygonzkevm *PolygonzkevmSession) GasTokenAddress() (common.Address, error) { + return _Polygonzkevm.Contract.GasTokenAddress(&_Polygonzkevm.CallOpts) +} + +// GasTokenAddress is a free data retrieval call binding the contract method 0x3c351e10. +// +// Solidity: function gasTokenAddress() view returns(address) +func (_Polygonzkevm *PolygonzkevmCallerSession) GasTokenAddress() (common.Address, error) { + return _Polygonzkevm.Contract.GasTokenAddress(&_Polygonzkevm.CallOpts) +} + +// GasTokenNetwork is a free data retrieval call binding the contract method 0x3cbc795b. +// +// Solidity: function gasTokenNetwork() view returns(uint32) +func (_Polygonzkevm *PolygonzkevmCaller) GasTokenNetwork(opts *bind.CallOpts) (uint32, error) { + var out []interface{} + err := _Polygonzkevm.contract.Call(opts, &out, "gasTokenNetwork") + + if err != nil { + return *new(uint32), err + } + + out0 := *abi.ConvertType(out[0], new(uint32)).(*uint32) + + return out0, err + +} + +// GasTokenNetwork is a free data retrieval call binding the contract method 0x3cbc795b. +// +// Solidity: function gasTokenNetwork() view returns(uint32) +func (_Polygonzkevm *PolygonzkevmSession) GasTokenNetwork() (uint32, error) { + return _Polygonzkevm.Contract.GasTokenNetwork(&_Polygonzkevm.CallOpts) +} + +// GasTokenNetwork is a free data retrieval call binding the contract method 0x3cbc795b. +// +// Solidity: function gasTokenNetwork() view returns(uint32) +func (_Polygonzkevm *PolygonzkevmCallerSession) GasTokenNetwork() (uint32, error) { + return _Polygonzkevm.Contract.GasTokenNetwork(&_Polygonzkevm.CallOpts) +} + +// GenerateInitializeTransaction is a free data retrieval call binding the contract method 0xa652f26c. +// +// Solidity: function generateInitializeTransaction(uint32 networkID, address _gasTokenAddress, uint32 _gasTokenNetwork, bytes _gasTokenMetadata) view returns(bytes) +func (_Polygonzkevm *PolygonzkevmCaller) GenerateInitializeTransaction(opts *bind.CallOpts, networkID uint32, _gasTokenAddress common.Address, _gasTokenNetwork uint32, _gasTokenMetadata []byte) ([]byte, error) { + var out []interface{} + err := _Polygonzkevm.contract.Call(opts, &out, "generateInitializeTransaction", networkID, _gasTokenAddress, _gasTokenNetwork, _gasTokenMetadata) + + if err != nil { + return *new([]byte), err + } + + out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte) + + return out0, err + +} + +// GenerateInitializeTransaction is a free data retrieval call binding the contract method 0xa652f26c. +// +// Solidity: function generateInitializeTransaction(uint32 networkID, address _gasTokenAddress, uint32 _gasTokenNetwork, bytes _gasTokenMetadata) view returns(bytes) +func (_Polygonzkevm *PolygonzkevmSession) GenerateInitializeTransaction(networkID uint32, _gasTokenAddress common.Address, _gasTokenNetwork uint32, _gasTokenMetadata []byte) ([]byte, error) { + return _Polygonzkevm.Contract.GenerateInitializeTransaction(&_Polygonzkevm.CallOpts, networkID, _gasTokenAddress, _gasTokenNetwork, _gasTokenMetadata) +} + +// GenerateInitializeTransaction is a free data retrieval call binding the contract method 0xa652f26c. +// +// Solidity: function generateInitializeTransaction(uint32 networkID, address _gasTokenAddress, uint32 _gasTokenNetwork, bytes _gasTokenMetadata) view returns(bytes) +func (_Polygonzkevm *PolygonzkevmCallerSession) GenerateInitializeTransaction(networkID uint32, _gasTokenAddress common.Address, _gasTokenNetwork uint32, _gasTokenMetadata []byte) ([]byte, error) { + return _Polygonzkevm.Contract.GenerateInitializeTransaction(&_Polygonzkevm.CallOpts, networkID, _gasTokenAddress, _gasTokenNetwork, _gasTokenMetadata) +} + +// GlobalExitRootManager is a free data retrieval call binding the contract method 0xd02103ca. +// +// Solidity: function globalExitRootManager() view returns(address) +func (_Polygonzkevm *PolygonzkevmCaller) GlobalExitRootManager(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Polygonzkevm.contract.Call(opts, &out, "globalExitRootManager") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// GlobalExitRootManager is a free data retrieval call binding the contract method 0xd02103ca. +// +// Solidity: function globalExitRootManager() view returns(address) +func (_Polygonzkevm *PolygonzkevmSession) GlobalExitRootManager() (common.Address, error) { + return _Polygonzkevm.Contract.GlobalExitRootManager(&_Polygonzkevm.CallOpts) +} + +// GlobalExitRootManager is a free data retrieval call binding the contract method 0xd02103ca. +// +// Solidity: function globalExitRootManager() view returns(address) +func (_Polygonzkevm *PolygonzkevmCallerSession) GlobalExitRootManager() (common.Address, error) { + return _Polygonzkevm.Contract.GlobalExitRootManager(&_Polygonzkevm.CallOpts) +} + +// IsForcedBatchAllowed is a free data retrieval call binding the contract method 0x2b35b3ac. +// +// Solidity: function isForcedBatchAllowed() view returns(bool) +func (_Polygonzkevm *PolygonzkevmCaller) IsForcedBatchAllowed(opts *bind.CallOpts) (bool, error) { + var out []interface{} + err := _Polygonzkevm.contract.Call(opts, &out, "isForcedBatchAllowed") + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// IsForcedBatchAllowed is a free data retrieval call binding the contract method 0x2b35b3ac. +// +// Solidity: function isForcedBatchAllowed() view returns(bool) +func (_Polygonzkevm *PolygonzkevmSession) IsForcedBatchAllowed() (bool, error) { + return _Polygonzkevm.Contract.IsForcedBatchAllowed(&_Polygonzkevm.CallOpts) +} + +// IsForcedBatchAllowed is a free data retrieval call binding the contract method 0x2b35b3ac. +// +// Solidity: function isForcedBatchAllowed() view returns(bool) +func (_Polygonzkevm *PolygonzkevmCallerSession) IsForcedBatchAllowed() (bool, error) { + return _Polygonzkevm.Contract.IsForcedBatchAllowed(&_Polygonzkevm.CallOpts) +} + +// LastAccInputHash is a free data retrieval call binding the contract method 0x6e05d2cd. +// +// Solidity: function lastAccInputHash() view returns(bytes32) +func (_Polygonzkevm *PolygonzkevmCaller) LastAccInputHash(opts *bind.CallOpts) ([32]byte, error) { + var out []interface{} + err := _Polygonzkevm.contract.Call(opts, &out, "lastAccInputHash") + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// LastAccInputHash is a free data retrieval call binding the contract method 0x6e05d2cd. +// +// Solidity: function lastAccInputHash() view returns(bytes32) +func (_Polygonzkevm *PolygonzkevmSession) LastAccInputHash() ([32]byte, error) { + return _Polygonzkevm.Contract.LastAccInputHash(&_Polygonzkevm.CallOpts) +} + +// LastAccInputHash is a free data retrieval call binding the contract method 0x6e05d2cd. +// +// Solidity: function lastAccInputHash() view returns(bytes32) +func (_Polygonzkevm *PolygonzkevmCallerSession) LastAccInputHash() ([32]byte, error) { + return _Polygonzkevm.Contract.LastAccInputHash(&_Polygonzkevm.CallOpts) +} + +// LastForceBatch is a free data retrieval call binding the contract method 0xe7a7ed02. +// +// Solidity: function lastForceBatch() view returns(uint64) +func (_Polygonzkevm *PolygonzkevmCaller) LastForceBatch(opts *bind.CallOpts) (uint64, error) { + var out []interface{} + err := _Polygonzkevm.contract.Call(opts, &out, "lastForceBatch") + + if err != nil { + return *new(uint64), err + } + + out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64) + + return out0, err + +} + +// LastForceBatch is a free data retrieval call binding the contract method 0xe7a7ed02. +// +// Solidity: function lastForceBatch() view returns(uint64) +func (_Polygonzkevm *PolygonzkevmSession) LastForceBatch() (uint64, error) { + return _Polygonzkevm.Contract.LastForceBatch(&_Polygonzkevm.CallOpts) +} + +// LastForceBatch is a free data retrieval call binding the contract method 0xe7a7ed02. +// +// Solidity: function lastForceBatch() view returns(uint64) +func (_Polygonzkevm *PolygonzkevmCallerSession) LastForceBatch() (uint64, error) { + return _Polygonzkevm.Contract.LastForceBatch(&_Polygonzkevm.CallOpts) +} + +// LastForceBatchSequenced is a free data retrieval call binding the contract method 0x45605267. +// +// Solidity: function lastForceBatchSequenced() view returns(uint64) +func (_Polygonzkevm *PolygonzkevmCaller) LastForceBatchSequenced(opts *bind.CallOpts) (uint64, error) { + var out []interface{} + err := _Polygonzkevm.contract.Call(opts, &out, "lastForceBatchSequenced") + + if err != nil { + return *new(uint64), err + } + + out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64) + + return out0, err + +} + +// LastForceBatchSequenced is a free data retrieval call binding the contract method 0x45605267. +// +// Solidity: function lastForceBatchSequenced() view returns(uint64) +func (_Polygonzkevm *PolygonzkevmSession) LastForceBatchSequenced() (uint64, error) { + return _Polygonzkevm.Contract.LastForceBatchSequenced(&_Polygonzkevm.CallOpts) +} + +// LastForceBatchSequenced is a free data retrieval call binding the contract method 0x45605267. +// +// Solidity: function lastForceBatchSequenced() view returns(uint64) +func (_Polygonzkevm *PolygonzkevmCallerSession) LastForceBatchSequenced() (uint64, error) { + return _Polygonzkevm.Contract.LastForceBatchSequenced(&_Polygonzkevm.CallOpts) +} + +// NetworkName is a free data retrieval call binding the contract method 0x107bf28c. +// +// Solidity: function networkName() view returns(string) +func (_Polygonzkevm *PolygonzkevmCaller) NetworkName(opts *bind.CallOpts) (string, error) { + var out []interface{} + err := _Polygonzkevm.contract.Call(opts, &out, "networkName") + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// NetworkName is a free data retrieval call binding the contract method 0x107bf28c. +// +// Solidity: function networkName() view returns(string) +func (_Polygonzkevm *PolygonzkevmSession) NetworkName() (string, error) { + return _Polygonzkevm.Contract.NetworkName(&_Polygonzkevm.CallOpts) +} + +// NetworkName is a free data retrieval call binding the contract method 0x107bf28c. +// +// Solidity: function networkName() view returns(string) +func (_Polygonzkevm *PolygonzkevmCallerSession) NetworkName() (string, error) { + return _Polygonzkevm.Contract.NetworkName(&_Polygonzkevm.CallOpts) +} + +// PendingAdmin is a free data retrieval call binding the contract method 0x26782247. +// +// Solidity: function pendingAdmin() view returns(address) +func (_Polygonzkevm *PolygonzkevmCaller) PendingAdmin(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Polygonzkevm.contract.Call(opts, &out, "pendingAdmin") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// PendingAdmin is a free data retrieval call binding the contract method 0x26782247. +// +// Solidity: function pendingAdmin() view returns(address) +func (_Polygonzkevm *PolygonzkevmSession) PendingAdmin() (common.Address, error) { + return _Polygonzkevm.Contract.PendingAdmin(&_Polygonzkevm.CallOpts) +} + +// PendingAdmin is a free data retrieval call binding the contract method 0x26782247. +// +// Solidity: function pendingAdmin() view returns(address) +func (_Polygonzkevm *PolygonzkevmCallerSession) PendingAdmin() (common.Address, error) { + return _Polygonzkevm.Contract.PendingAdmin(&_Polygonzkevm.CallOpts) +} + +// Pol is a free data retrieval call binding the contract method 0xe46761c4. +// +// Solidity: function pol() view returns(address) +func (_Polygonzkevm *PolygonzkevmCaller) Pol(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Polygonzkevm.contract.Call(opts, &out, "pol") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// Pol is a free data retrieval call binding the contract method 0xe46761c4. +// +// Solidity: function pol() view returns(address) +func (_Polygonzkevm *PolygonzkevmSession) Pol() (common.Address, error) { + return _Polygonzkevm.Contract.Pol(&_Polygonzkevm.CallOpts) +} + +// Pol is a free data retrieval call binding the contract method 0xe46761c4. +// +// Solidity: function pol() view returns(address) +func (_Polygonzkevm *PolygonzkevmCallerSession) Pol() (common.Address, error) { + return _Polygonzkevm.Contract.Pol(&_Polygonzkevm.CallOpts) +} + +// RollupManager is a free data retrieval call binding the contract method 0x49b7b802. +// +// Solidity: function rollupManager() view returns(address) +func (_Polygonzkevm *PolygonzkevmCaller) RollupManager(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Polygonzkevm.contract.Call(opts, &out, "rollupManager") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// RollupManager is a free data retrieval call binding the contract method 0x49b7b802. +// +// Solidity: function rollupManager() view returns(address) +func (_Polygonzkevm *PolygonzkevmSession) RollupManager() (common.Address, error) { + return _Polygonzkevm.Contract.RollupManager(&_Polygonzkevm.CallOpts) +} + +// RollupManager is a free data retrieval call binding the contract method 0x49b7b802. +// +// Solidity: function rollupManager() view returns(address) +func (_Polygonzkevm *PolygonzkevmCallerSession) RollupManager() (common.Address, error) { + return _Polygonzkevm.Contract.RollupManager(&_Polygonzkevm.CallOpts) +} + +// TrustedSequencer is a free data retrieval call binding the contract method 0xcfa8ed47. +// +// Solidity: function trustedSequencer() view returns(address) +func (_Polygonzkevm *PolygonzkevmCaller) TrustedSequencer(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Polygonzkevm.contract.Call(opts, &out, "trustedSequencer") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// TrustedSequencer is a free data retrieval call binding the contract method 0xcfa8ed47. +// +// Solidity: function trustedSequencer() view returns(address) +func (_Polygonzkevm *PolygonzkevmSession) TrustedSequencer() (common.Address, error) { + return _Polygonzkevm.Contract.TrustedSequencer(&_Polygonzkevm.CallOpts) +} + +// TrustedSequencer is a free data retrieval call binding the contract method 0xcfa8ed47. +// +// Solidity: function trustedSequencer() view returns(address) +func (_Polygonzkevm *PolygonzkevmCallerSession) TrustedSequencer() (common.Address, error) { + return _Polygonzkevm.Contract.TrustedSequencer(&_Polygonzkevm.CallOpts) +} + +// TrustedSequencerURL is a free data retrieval call binding the contract method 0x542028d5. +// +// Solidity: function trustedSequencerURL() view returns(string) +func (_Polygonzkevm *PolygonzkevmCaller) TrustedSequencerURL(opts *bind.CallOpts) (string, error) { + var out []interface{} + err := _Polygonzkevm.contract.Call(opts, &out, "trustedSequencerURL") + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// TrustedSequencerURL is a free data retrieval call binding the contract method 0x542028d5. +// +// Solidity: function trustedSequencerURL() view returns(string) +func (_Polygonzkevm *PolygonzkevmSession) TrustedSequencerURL() (string, error) { + return _Polygonzkevm.Contract.TrustedSequencerURL(&_Polygonzkevm.CallOpts) +} + +// TrustedSequencerURL is a free data retrieval call binding the contract method 0x542028d5. +// +// Solidity: function trustedSequencerURL() view returns(string) +func (_Polygonzkevm *PolygonzkevmCallerSession) TrustedSequencerURL() (string, error) { + return _Polygonzkevm.Contract.TrustedSequencerURL(&_Polygonzkevm.CallOpts) +} + +// AcceptAdminRole is a paid mutator transaction binding the contract method 0x8c3d7301. +// +// Solidity: function acceptAdminRole() returns() +func (_Polygonzkevm *PolygonzkevmTransactor) AcceptAdminRole(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Polygonzkevm.contract.Transact(opts, "acceptAdminRole") +} + +// AcceptAdminRole is a paid mutator transaction binding the contract method 0x8c3d7301. +// +// Solidity: function acceptAdminRole() returns() +func (_Polygonzkevm *PolygonzkevmSession) AcceptAdminRole() (*types.Transaction, error) { + return _Polygonzkevm.Contract.AcceptAdminRole(&_Polygonzkevm.TransactOpts) +} + +// AcceptAdminRole is a paid mutator transaction binding the contract method 0x8c3d7301. +// +// Solidity: function acceptAdminRole() returns() +func (_Polygonzkevm *PolygonzkevmTransactorSession) AcceptAdminRole() (*types.Transaction, error) { + return _Polygonzkevm.Contract.AcceptAdminRole(&_Polygonzkevm.TransactOpts) +} + +// ActivateForceBatches is a paid mutator transaction binding the contract method 0x5ec91958. +// +// Solidity: function activateForceBatches() returns() +func (_Polygonzkevm *PolygonzkevmTransactor) ActivateForceBatches(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Polygonzkevm.contract.Transact(opts, "activateForceBatches") +} + +// ActivateForceBatches is a paid mutator transaction binding the contract method 0x5ec91958. +// +// Solidity: function activateForceBatches() returns() +func (_Polygonzkevm *PolygonzkevmSession) ActivateForceBatches() (*types.Transaction, error) { + return _Polygonzkevm.Contract.ActivateForceBatches(&_Polygonzkevm.TransactOpts) +} + +// ActivateForceBatches is a paid mutator transaction binding the contract method 0x5ec91958. +// +// Solidity: function activateForceBatches() returns() +func (_Polygonzkevm *PolygonzkevmTransactorSession) ActivateForceBatches() (*types.Transaction, error) { + return _Polygonzkevm.Contract.ActivateForceBatches(&_Polygonzkevm.TransactOpts) +} + +// ForceBatch is a paid mutator transaction binding the contract method 0xeaeb077b. +// +// Solidity: function forceBatch(bytes transactions, uint256 polAmount) returns() +func (_Polygonzkevm *PolygonzkevmTransactor) ForceBatch(opts *bind.TransactOpts, transactions []byte, polAmount *big.Int) (*types.Transaction, error) { + return _Polygonzkevm.contract.Transact(opts, "forceBatch", transactions, polAmount) +} + +// ForceBatch is a paid mutator transaction binding the contract method 0xeaeb077b. +// +// Solidity: function forceBatch(bytes transactions, uint256 polAmount) returns() +func (_Polygonzkevm *PolygonzkevmSession) ForceBatch(transactions []byte, polAmount *big.Int) (*types.Transaction, error) { + return _Polygonzkevm.Contract.ForceBatch(&_Polygonzkevm.TransactOpts, transactions, polAmount) +} + +// ForceBatch is a paid mutator transaction binding the contract method 0xeaeb077b. +// +// Solidity: function forceBatch(bytes transactions, uint256 polAmount) returns() +func (_Polygonzkevm *PolygonzkevmTransactorSession) ForceBatch(transactions []byte, polAmount *big.Int) (*types.Transaction, error) { + return _Polygonzkevm.Contract.ForceBatch(&_Polygonzkevm.TransactOpts, transactions, polAmount) +} + +// Initialize is a paid mutator transaction binding the contract method 0x71257022. +// +// Solidity: function initialize(address _admin, address sequencer, uint32 networkID, address _gasTokenAddress, string sequencerURL, string _networkName) returns() +func (_Polygonzkevm *PolygonzkevmTransactor) Initialize(opts *bind.TransactOpts, _admin common.Address, sequencer common.Address, networkID uint32, _gasTokenAddress common.Address, sequencerURL string, _networkName string) (*types.Transaction, error) { + return _Polygonzkevm.contract.Transact(opts, "initialize", _admin, sequencer, networkID, _gasTokenAddress, sequencerURL, _networkName) +} + +// Initialize is a paid mutator transaction binding the contract method 0x71257022. +// +// Solidity: function initialize(address _admin, address sequencer, uint32 networkID, address _gasTokenAddress, string sequencerURL, string _networkName) returns() +func (_Polygonzkevm *PolygonzkevmSession) Initialize(_admin common.Address, sequencer common.Address, networkID uint32, _gasTokenAddress common.Address, sequencerURL string, _networkName string) (*types.Transaction, error) { + return _Polygonzkevm.Contract.Initialize(&_Polygonzkevm.TransactOpts, _admin, sequencer, networkID, _gasTokenAddress, sequencerURL, _networkName) +} + +// Initialize is a paid mutator transaction binding the contract method 0x71257022. +// +// Solidity: function initialize(address _admin, address sequencer, uint32 networkID, address _gasTokenAddress, string sequencerURL, string _networkName) returns() +func (_Polygonzkevm *PolygonzkevmTransactorSession) Initialize(_admin common.Address, sequencer common.Address, networkID uint32, _gasTokenAddress common.Address, sequencerURL string, _networkName string) (*types.Transaction, error) { + return _Polygonzkevm.Contract.Initialize(&_Polygonzkevm.TransactOpts, _admin, sequencer, networkID, _gasTokenAddress, sequencerURL, _networkName) +} + +// OnVerifyBatches is a paid mutator transaction binding the contract method 0x32c2d153. +// +// Solidity: function onVerifyBatches(uint64 lastVerifiedBatch, bytes32 newStateRoot, address aggregator) returns() +func (_Polygonzkevm *PolygonzkevmTransactor) OnVerifyBatches(opts *bind.TransactOpts, lastVerifiedBatch uint64, newStateRoot [32]byte, aggregator common.Address) (*types.Transaction, error) { + return _Polygonzkevm.contract.Transact(opts, "onVerifyBatches", lastVerifiedBatch, newStateRoot, aggregator) +} + +// OnVerifyBatches is a paid mutator transaction binding the contract method 0x32c2d153. +// +// Solidity: function onVerifyBatches(uint64 lastVerifiedBatch, bytes32 newStateRoot, address aggregator) returns() +func (_Polygonzkevm *PolygonzkevmSession) OnVerifyBatches(lastVerifiedBatch uint64, newStateRoot [32]byte, aggregator common.Address) (*types.Transaction, error) { + return _Polygonzkevm.Contract.OnVerifyBatches(&_Polygonzkevm.TransactOpts, lastVerifiedBatch, newStateRoot, aggregator) +} + +// OnVerifyBatches is a paid mutator transaction binding the contract method 0x32c2d153. +// +// Solidity: function onVerifyBatches(uint64 lastVerifiedBatch, bytes32 newStateRoot, address aggregator) returns() +func (_Polygonzkevm *PolygonzkevmTransactorSession) OnVerifyBatches(lastVerifiedBatch uint64, newStateRoot [32]byte, aggregator common.Address) (*types.Transaction, error) { + return _Polygonzkevm.Contract.OnVerifyBatches(&_Polygonzkevm.TransactOpts, lastVerifiedBatch, newStateRoot, aggregator) +} + +// SequenceBatches is a paid mutator transaction binding the contract method 0xecef3f99. +// +// Solidity: function sequenceBatches((bytes,bytes32,uint64,bytes32)[] batches, address l2Coinbase) returns() +func (_Polygonzkevm *PolygonzkevmTransactor) SequenceBatches(opts *bind.TransactOpts, batches []PolygonRollupBaseEtrogBatchData, l2Coinbase common.Address) (*types.Transaction, error) { + return _Polygonzkevm.contract.Transact(opts, "sequenceBatches", batches, l2Coinbase) +} + +// SequenceBatches is a paid mutator transaction binding the contract method 0xecef3f99. +// +// Solidity: function sequenceBatches((bytes,bytes32,uint64,bytes32)[] batches, address l2Coinbase) returns() +func (_Polygonzkevm *PolygonzkevmSession) SequenceBatches(batches []PolygonRollupBaseEtrogBatchData, l2Coinbase common.Address) (*types.Transaction, error) { + return _Polygonzkevm.Contract.SequenceBatches(&_Polygonzkevm.TransactOpts, batches, l2Coinbase) +} + +// SequenceBatches is a paid mutator transaction binding the contract method 0xecef3f99. +// +// Solidity: function sequenceBatches((bytes,bytes32,uint64,bytes32)[] batches, address l2Coinbase) returns() +func (_Polygonzkevm *PolygonzkevmTransactorSession) SequenceBatches(batches []PolygonRollupBaseEtrogBatchData, l2Coinbase common.Address) (*types.Transaction, error) { + return _Polygonzkevm.Contract.SequenceBatches(&_Polygonzkevm.TransactOpts, batches, l2Coinbase) +} + +// SequenceForceBatches is a paid mutator transaction binding the contract method 0x9f26f840. +// +// Solidity: function sequenceForceBatches((bytes,bytes32,uint64,bytes32)[] batches) returns() +func (_Polygonzkevm *PolygonzkevmTransactor) SequenceForceBatches(opts *bind.TransactOpts, batches []PolygonRollupBaseEtrogBatchData) (*types.Transaction, error) { + return _Polygonzkevm.contract.Transact(opts, "sequenceForceBatches", batches) +} + +// SequenceForceBatches is a paid mutator transaction binding the contract method 0x9f26f840. +// +// Solidity: function sequenceForceBatches((bytes,bytes32,uint64,bytes32)[] batches) returns() +func (_Polygonzkevm *PolygonzkevmSession) SequenceForceBatches(batches []PolygonRollupBaseEtrogBatchData) (*types.Transaction, error) { + return _Polygonzkevm.Contract.SequenceForceBatches(&_Polygonzkevm.TransactOpts, batches) +} + +// SequenceForceBatches is a paid mutator transaction binding the contract method 0x9f26f840. +// +// Solidity: function sequenceForceBatches((bytes,bytes32,uint64,bytes32)[] batches) returns() +func (_Polygonzkevm *PolygonzkevmTransactorSession) SequenceForceBatches(batches []PolygonRollupBaseEtrogBatchData) (*types.Transaction, error) { + return _Polygonzkevm.Contract.SequenceForceBatches(&_Polygonzkevm.TransactOpts, batches) +} + +// SetForceBatchTimeout is a paid mutator transaction binding the contract method 0x4e487706. +// +// Solidity: function setForceBatchTimeout(uint64 newforceBatchTimeout) returns() +func (_Polygonzkevm *PolygonzkevmTransactor) SetForceBatchTimeout(opts *bind.TransactOpts, newforceBatchTimeout uint64) (*types.Transaction, error) { + return _Polygonzkevm.contract.Transact(opts, "setForceBatchTimeout", newforceBatchTimeout) +} + +// SetForceBatchTimeout is a paid mutator transaction binding the contract method 0x4e487706. +// +// Solidity: function setForceBatchTimeout(uint64 newforceBatchTimeout) returns() +func (_Polygonzkevm *PolygonzkevmSession) SetForceBatchTimeout(newforceBatchTimeout uint64) (*types.Transaction, error) { + return _Polygonzkevm.Contract.SetForceBatchTimeout(&_Polygonzkevm.TransactOpts, newforceBatchTimeout) +} + +// SetForceBatchTimeout is a paid mutator transaction binding the contract method 0x4e487706. +// +// Solidity: function setForceBatchTimeout(uint64 newforceBatchTimeout) returns() +func (_Polygonzkevm *PolygonzkevmTransactorSession) SetForceBatchTimeout(newforceBatchTimeout uint64) (*types.Transaction, error) { + return _Polygonzkevm.Contract.SetForceBatchTimeout(&_Polygonzkevm.TransactOpts, newforceBatchTimeout) +} + +// SetTrustedSequencer is a paid mutator transaction binding the contract method 0x6ff512cc. +// +// Solidity: function setTrustedSequencer(address newTrustedSequencer) returns() +func (_Polygonzkevm *PolygonzkevmTransactor) SetTrustedSequencer(opts *bind.TransactOpts, newTrustedSequencer common.Address) (*types.Transaction, error) { + return _Polygonzkevm.contract.Transact(opts, "setTrustedSequencer", newTrustedSequencer) +} + +// SetTrustedSequencer is a paid mutator transaction binding the contract method 0x6ff512cc. +// +// Solidity: function setTrustedSequencer(address newTrustedSequencer) returns() +func (_Polygonzkevm *PolygonzkevmSession) SetTrustedSequencer(newTrustedSequencer common.Address) (*types.Transaction, error) { + return _Polygonzkevm.Contract.SetTrustedSequencer(&_Polygonzkevm.TransactOpts, newTrustedSequencer) +} + +// SetTrustedSequencer is a paid mutator transaction binding the contract method 0x6ff512cc. +// +// Solidity: function setTrustedSequencer(address newTrustedSequencer) returns() +func (_Polygonzkevm *PolygonzkevmTransactorSession) SetTrustedSequencer(newTrustedSequencer common.Address) (*types.Transaction, error) { + return _Polygonzkevm.Contract.SetTrustedSequencer(&_Polygonzkevm.TransactOpts, newTrustedSequencer) +} + +// SetTrustedSequencerURL is a paid mutator transaction binding the contract method 0xc89e42df. +// +// Solidity: function setTrustedSequencerURL(string newTrustedSequencerURL) returns() +func (_Polygonzkevm *PolygonzkevmTransactor) SetTrustedSequencerURL(opts *bind.TransactOpts, newTrustedSequencerURL string) (*types.Transaction, error) { + return _Polygonzkevm.contract.Transact(opts, "setTrustedSequencerURL", newTrustedSequencerURL) +} + +// SetTrustedSequencerURL is a paid mutator transaction binding the contract method 0xc89e42df. +// +// Solidity: function setTrustedSequencerURL(string newTrustedSequencerURL) returns() +func (_Polygonzkevm *PolygonzkevmSession) SetTrustedSequencerURL(newTrustedSequencerURL string) (*types.Transaction, error) { + return _Polygonzkevm.Contract.SetTrustedSequencerURL(&_Polygonzkevm.TransactOpts, newTrustedSequencerURL) +} + +// SetTrustedSequencerURL is a paid mutator transaction binding the contract method 0xc89e42df. +// +// Solidity: function setTrustedSequencerURL(string newTrustedSequencerURL) returns() +func (_Polygonzkevm *PolygonzkevmTransactorSession) SetTrustedSequencerURL(newTrustedSequencerURL string) (*types.Transaction, error) { + return _Polygonzkevm.Contract.SetTrustedSequencerURL(&_Polygonzkevm.TransactOpts, newTrustedSequencerURL) +} + +// TransferAdminRole is a paid mutator transaction binding the contract method 0xada8f919. +// +// Solidity: function transferAdminRole(address newPendingAdmin) returns() +func (_Polygonzkevm *PolygonzkevmTransactor) TransferAdminRole(opts *bind.TransactOpts, newPendingAdmin common.Address) (*types.Transaction, error) { + return _Polygonzkevm.contract.Transact(opts, "transferAdminRole", newPendingAdmin) +} + +// TransferAdminRole is a paid mutator transaction binding the contract method 0xada8f919. +// +// Solidity: function transferAdminRole(address newPendingAdmin) returns() +func (_Polygonzkevm *PolygonzkevmSession) TransferAdminRole(newPendingAdmin common.Address) (*types.Transaction, error) { + return _Polygonzkevm.Contract.TransferAdminRole(&_Polygonzkevm.TransactOpts, newPendingAdmin) +} + +// TransferAdminRole is a paid mutator transaction binding the contract method 0xada8f919. +// +// Solidity: function transferAdminRole(address newPendingAdmin) returns() +func (_Polygonzkevm *PolygonzkevmTransactorSession) TransferAdminRole(newPendingAdmin common.Address) (*types.Transaction, error) { + return _Polygonzkevm.Contract.TransferAdminRole(&_Polygonzkevm.TransactOpts, newPendingAdmin) +} + +// PolygonzkevmAcceptAdminRoleIterator is returned from FilterAcceptAdminRole and is used to iterate over the raw logs and unpacked data for AcceptAdminRole events raised by the Polygonzkevm contract. +type PolygonzkevmAcceptAdminRoleIterator struct { + Event *PolygonzkevmAcceptAdminRole // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PolygonzkevmAcceptAdminRoleIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PolygonzkevmAcceptAdminRole) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PolygonzkevmAcceptAdminRole) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PolygonzkevmAcceptAdminRoleIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolygonzkevmAcceptAdminRoleIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolygonzkevmAcceptAdminRole represents a AcceptAdminRole event raised by the Polygonzkevm contract. +type PolygonzkevmAcceptAdminRole struct { + NewAdmin common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterAcceptAdminRole is a free log retrieval operation binding the contract event 0x056dc487bbf0795d0bbb1b4f0af523a855503cff740bfb4d5475f7a90c091e8e. +// +// Solidity: event AcceptAdminRole(address newAdmin) +func (_Polygonzkevm *PolygonzkevmFilterer) FilterAcceptAdminRole(opts *bind.FilterOpts) (*PolygonzkevmAcceptAdminRoleIterator, error) { + + logs, sub, err := _Polygonzkevm.contract.FilterLogs(opts, "AcceptAdminRole") + if err != nil { + return nil, err + } + return &PolygonzkevmAcceptAdminRoleIterator{contract: _Polygonzkevm.contract, event: "AcceptAdminRole", logs: logs, sub: sub}, nil +} + +// WatchAcceptAdminRole is a free log subscription operation binding the contract event 0x056dc487bbf0795d0bbb1b4f0af523a855503cff740bfb4d5475f7a90c091e8e. +// +// Solidity: event AcceptAdminRole(address newAdmin) +func (_Polygonzkevm *PolygonzkevmFilterer) WatchAcceptAdminRole(opts *bind.WatchOpts, sink chan<- *PolygonzkevmAcceptAdminRole) (event.Subscription, error) { + + logs, sub, err := _Polygonzkevm.contract.WatchLogs(opts, "AcceptAdminRole") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PolygonzkevmAcceptAdminRole) + if err := _Polygonzkevm.contract.UnpackLog(event, "AcceptAdminRole", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseAcceptAdminRole is a log parse operation binding the contract event 0x056dc487bbf0795d0bbb1b4f0af523a855503cff740bfb4d5475f7a90c091e8e. +// +// Solidity: event AcceptAdminRole(address newAdmin) +func (_Polygonzkevm *PolygonzkevmFilterer) ParseAcceptAdminRole(log types.Log) (*PolygonzkevmAcceptAdminRole, error) { + event := new(PolygonzkevmAcceptAdminRole) + if err := _Polygonzkevm.contract.UnpackLog(event, "AcceptAdminRole", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PolygonzkevmActivateForceBatchesIterator is returned from FilterActivateForceBatches and is used to iterate over the raw logs and unpacked data for ActivateForceBatches events raised by the Polygonzkevm contract. +type PolygonzkevmActivateForceBatchesIterator struct { + Event *PolygonzkevmActivateForceBatches // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PolygonzkevmActivateForceBatchesIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PolygonzkevmActivateForceBatches) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PolygonzkevmActivateForceBatches) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PolygonzkevmActivateForceBatchesIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolygonzkevmActivateForceBatchesIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolygonzkevmActivateForceBatches represents a ActivateForceBatches event raised by the Polygonzkevm contract. +type PolygonzkevmActivateForceBatches struct { + Raw types.Log // Blockchain specific contextual infos +} + +// FilterActivateForceBatches is a free log retrieval operation binding the contract event 0x854dd6ce5a1445c4c54388b21cffd11cf5bba1b9e763aec48ce3da75d617412f. +// +// Solidity: event ActivateForceBatches() +func (_Polygonzkevm *PolygonzkevmFilterer) FilterActivateForceBatches(opts *bind.FilterOpts) (*PolygonzkevmActivateForceBatchesIterator, error) { + + logs, sub, err := _Polygonzkevm.contract.FilterLogs(opts, "ActivateForceBatches") + if err != nil { + return nil, err + } + return &PolygonzkevmActivateForceBatchesIterator{contract: _Polygonzkevm.contract, event: "ActivateForceBatches", logs: logs, sub: sub}, nil +} + +// WatchActivateForceBatches is a free log subscription operation binding the contract event 0x854dd6ce5a1445c4c54388b21cffd11cf5bba1b9e763aec48ce3da75d617412f. +// +// Solidity: event ActivateForceBatches() +func (_Polygonzkevm *PolygonzkevmFilterer) WatchActivateForceBatches(opts *bind.WatchOpts, sink chan<- *PolygonzkevmActivateForceBatches) (event.Subscription, error) { + + logs, sub, err := _Polygonzkevm.contract.WatchLogs(opts, "ActivateForceBatches") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PolygonzkevmActivateForceBatches) + if err := _Polygonzkevm.contract.UnpackLog(event, "ActivateForceBatches", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseActivateForceBatches is a log parse operation binding the contract event 0x854dd6ce5a1445c4c54388b21cffd11cf5bba1b9e763aec48ce3da75d617412f. +// +// Solidity: event ActivateForceBatches() +func (_Polygonzkevm *PolygonzkevmFilterer) ParseActivateForceBatches(log types.Log) (*PolygonzkevmActivateForceBatches, error) { + event := new(PolygonzkevmActivateForceBatches) + if err := _Polygonzkevm.contract.UnpackLog(event, "ActivateForceBatches", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PolygonzkevmForceBatchIterator is returned from FilterForceBatch and is used to iterate over the raw logs and unpacked data for ForceBatch events raised by the Polygonzkevm contract. +type PolygonzkevmForceBatchIterator struct { + Event *PolygonzkevmForceBatch // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PolygonzkevmForceBatchIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PolygonzkevmForceBatch) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PolygonzkevmForceBatch) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PolygonzkevmForceBatchIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolygonzkevmForceBatchIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolygonzkevmForceBatch represents a ForceBatch event raised by the Polygonzkevm contract. +type PolygonzkevmForceBatch struct { + ForceBatchNum uint64 + LastGlobalExitRoot [32]byte + Sequencer common.Address + Transactions []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterForceBatch is a free log retrieval operation binding the contract event 0xf94bb37db835f1ab585ee00041849a09b12cd081d77fa15ca070757619cbc931. +// +// Solidity: event ForceBatch(uint64 indexed forceBatchNum, bytes32 lastGlobalExitRoot, address sequencer, bytes transactions) +func (_Polygonzkevm *PolygonzkevmFilterer) FilterForceBatch(opts *bind.FilterOpts, forceBatchNum []uint64) (*PolygonzkevmForceBatchIterator, error) { + + var forceBatchNumRule []interface{} + for _, forceBatchNumItem := range forceBatchNum { + forceBatchNumRule = append(forceBatchNumRule, forceBatchNumItem) + } + + logs, sub, err := _Polygonzkevm.contract.FilterLogs(opts, "ForceBatch", forceBatchNumRule) + if err != nil { + return nil, err + } + return &PolygonzkevmForceBatchIterator{contract: _Polygonzkevm.contract, event: "ForceBatch", logs: logs, sub: sub}, nil +} + +// WatchForceBatch is a free log subscription operation binding the contract event 0xf94bb37db835f1ab585ee00041849a09b12cd081d77fa15ca070757619cbc931. +// +// Solidity: event ForceBatch(uint64 indexed forceBatchNum, bytes32 lastGlobalExitRoot, address sequencer, bytes transactions) +func (_Polygonzkevm *PolygonzkevmFilterer) WatchForceBatch(opts *bind.WatchOpts, sink chan<- *PolygonzkevmForceBatch, forceBatchNum []uint64) (event.Subscription, error) { + + var forceBatchNumRule []interface{} + for _, forceBatchNumItem := range forceBatchNum { + forceBatchNumRule = append(forceBatchNumRule, forceBatchNumItem) + } + + logs, sub, err := _Polygonzkevm.contract.WatchLogs(opts, "ForceBatch", forceBatchNumRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PolygonzkevmForceBatch) + if err := _Polygonzkevm.contract.UnpackLog(event, "ForceBatch", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseForceBatch is a log parse operation binding the contract event 0xf94bb37db835f1ab585ee00041849a09b12cd081d77fa15ca070757619cbc931. +// +// Solidity: event ForceBatch(uint64 indexed forceBatchNum, bytes32 lastGlobalExitRoot, address sequencer, bytes transactions) +func (_Polygonzkevm *PolygonzkevmFilterer) ParseForceBatch(log types.Log) (*PolygonzkevmForceBatch, error) { + event := new(PolygonzkevmForceBatch) + if err := _Polygonzkevm.contract.UnpackLog(event, "ForceBatch", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PolygonzkevmInitialSequenceBatchesIterator is returned from FilterInitialSequenceBatches and is used to iterate over the raw logs and unpacked data for InitialSequenceBatches events raised by the Polygonzkevm contract. +type PolygonzkevmInitialSequenceBatchesIterator struct { + Event *PolygonzkevmInitialSequenceBatches // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PolygonzkevmInitialSequenceBatchesIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PolygonzkevmInitialSequenceBatches) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PolygonzkevmInitialSequenceBatches) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PolygonzkevmInitialSequenceBatchesIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolygonzkevmInitialSequenceBatchesIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolygonzkevmInitialSequenceBatches represents a InitialSequenceBatches event raised by the Polygonzkevm contract. +type PolygonzkevmInitialSequenceBatches struct { + Transactions []byte + LastGlobalExitRoot [32]byte + Sequencer common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterInitialSequenceBatches is a free log retrieval operation binding the contract event 0x060116213bcbf54ca19fd649dc84b59ab2bbd200ab199770e4d923e222a28e7f. +// +// Solidity: event InitialSequenceBatches(bytes transactions, bytes32 lastGlobalExitRoot, address sequencer) +func (_Polygonzkevm *PolygonzkevmFilterer) FilterInitialSequenceBatches(opts *bind.FilterOpts) (*PolygonzkevmInitialSequenceBatchesIterator, error) { + + logs, sub, err := _Polygonzkevm.contract.FilterLogs(opts, "InitialSequenceBatches") + if err != nil { + return nil, err + } + return &PolygonzkevmInitialSequenceBatchesIterator{contract: _Polygonzkevm.contract, event: "InitialSequenceBatches", logs: logs, sub: sub}, nil +} + +// WatchInitialSequenceBatches is a free log subscription operation binding the contract event 0x060116213bcbf54ca19fd649dc84b59ab2bbd200ab199770e4d923e222a28e7f. +// +// Solidity: event InitialSequenceBatches(bytes transactions, bytes32 lastGlobalExitRoot, address sequencer) +func (_Polygonzkevm *PolygonzkevmFilterer) WatchInitialSequenceBatches(opts *bind.WatchOpts, sink chan<- *PolygonzkevmInitialSequenceBatches) (event.Subscription, error) { + + logs, sub, err := _Polygonzkevm.contract.WatchLogs(opts, "InitialSequenceBatches") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PolygonzkevmInitialSequenceBatches) + if err := _Polygonzkevm.contract.UnpackLog(event, "InitialSequenceBatches", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseInitialSequenceBatches is a log parse operation binding the contract event 0x060116213bcbf54ca19fd649dc84b59ab2bbd200ab199770e4d923e222a28e7f. +// +// Solidity: event InitialSequenceBatches(bytes transactions, bytes32 lastGlobalExitRoot, address sequencer) +func (_Polygonzkevm *PolygonzkevmFilterer) ParseInitialSequenceBatches(log types.Log) (*PolygonzkevmInitialSequenceBatches, error) { + event := new(PolygonzkevmInitialSequenceBatches) + if err := _Polygonzkevm.contract.UnpackLog(event, "InitialSequenceBatches", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PolygonzkevmInitializedIterator is returned from FilterInitialized and is used to iterate over the raw logs and unpacked data for Initialized events raised by the Polygonzkevm contract. +type PolygonzkevmInitializedIterator struct { + Event *PolygonzkevmInitialized // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PolygonzkevmInitializedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PolygonzkevmInitialized) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PolygonzkevmInitialized) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PolygonzkevmInitializedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolygonzkevmInitializedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolygonzkevmInitialized represents a Initialized event raised by the Polygonzkevm contract. +type PolygonzkevmInitialized struct { + Version uint8 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterInitialized is a free log retrieval operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_Polygonzkevm *PolygonzkevmFilterer) FilterInitialized(opts *bind.FilterOpts) (*PolygonzkevmInitializedIterator, error) { + + logs, sub, err := _Polygonzkevm.contract.FilterLogs(opts, "Initialized") + if err != nil { + return nil, err + } + return &PolygonzkevmInitializedIterator{contract: _Polygonzkevm.contract, event: "Initialized", logs: logs, sub: sub}, nil +} + +// WatchInitialized is a free log subscription operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_Polygonzkevm *PolygonzkevmFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *PolygonzkevmInitialized) (event.Subscription, error) { + + logs, sub, err := _Polygonzkevm.contract.WatchLogs(opts, "Initialized") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PolygonzkevmInitialized) + if err := _Polygonzkevm.contract.UnpackLog(event, "Initialized", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseInitialized is a log parse operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_Polygonzkevm *PolygonzkevmFilterer) ParseInitialized(log types.Log) (*PolygonzkevmInitialized, error) { + event := new(PolygonzkevmInitialized) + if err := _Polygonzkevm.contract.UnpackLog(event, "Initialized", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PolygonzkevmSequenceBatchesIterator is returned from FilterSequenceBatches and is used to iterate over the raw logs and unpacked data for SequenceBatches events raised by the Polygonzkevm contract. +type PolygonzkevmSequenceBatchesIterator struct { + Event *PolygonzkevmSequenceBatches // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PolygonzkevmSequenceBatchesIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PolygonzkevmSequenceBatches) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PolygonzkevmSequenceBatches) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PolygonzkevmSequenceBatchesIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolygonzkevmSequenceBatchesIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolygonzkevmSequenceBatches represents a SequenceBatches event raised by the Polygonzkevm contract. +type PolygonzkevmSequenceBatches struct { + NumBatch uint64 + L1InfoRoot [32]byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterSequenceBatches is a free log retrieval operation binding the contract event 0x3e54d0825ed78523037d00a81759237eb436ce774bd546993ee67a1b67b6e766. +// +// Solidity: event SequenceBatches(uint64 indexed numBatch, bytes32 l1InfoRoot) +func (_Polygonzkevm *PolygonzkevmFilterer) FilterSequenceBatches(opts *bind.FilterOpts, numBatch []uint64) (*PolygonzkevmSequenceBatchesIterator, error) { + + var numBatchRule []interface{} + for _, numBatchItem := range numBatch { + numBatchRule = append(numBatchRule, numBatchItem) + } + + logs, sub, err := _Polygonzkevm.contract.FilterLogs(opts, "SequenceBatches", numBatchRule) + if err != nil { + return nil, err + } + return &PolygonzkevmSequenceBatchesIterator{contract: _Polygonzkevm.contract, event: "SequenceBatches", logs: logs, sub: sub}, nil +} + +// WatchSequenceBatches is a free log subscription operation binding the contract event 0x3e54d0825ed78523037d00a81759237eb436ce774bd546993ee67a1b67b6e766. +// +// Solidity: event SequenceBatches(uint64 indexed numBatch, bytes32 l1InfoRoot) +func (_Polygonzkevm *PolygonzkevmFilterer) WatchSequenceBatches(opts *bind.WatchOpts, sink chan<- *PolygonzkevmSequenceBatches, numBatch []uint64) (event.Subscription, error) { + + var numBatchRule []interface{} + for _, numBatchItem := range numBatch { + numBatchRule = append(numBatchRule, numBatchItem) + } + + logs, sub, err := _Polygonzkevm.contract.WatchLogs(opts, "SequenceBatches", numBatchRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PolygonzkevmSequenceBatches) + if err := _Polygonzkevm.contract.UnpackLog(event, "SequenceBatches", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseSequenceBatches is a log parse operation binding the contract event 0x3e54d0825ed78523037d00a81759237eb436ce774bd546993ee67a1b67b6e766. +// +// Solidity: event SequenceBatches(uint64 indexed numBatch, bytes32 l1InfoRoot) +func (_Polygonzkevm *PolygonzkevmFilterer) ParseSequenceBatches(log types.Log) (*PolygonzkevmSequenceBatches, error) { + event := new(PolygonzkevmSequenceBatches) + if err := _Polygonzkevm.contract.UnpackLog(event, "SequenceBatches", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PolygonzkevmSequenceForceBatchesIterator is returned from FilterSequenceForceBatches and is used to iterate over the raw logs and unpacked data for SequenceForceBatches events raised by the Polygonzkevm contract. +type PolygonzkevmSequenceForceBatchesIterator struct { + Event *PolygonzkevmSequenceForceBatches // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PolygonzkevmSequenceForceBatchesIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PolygonzkevmSequenceForceBatches) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PolygonzkevmSequenceForceBatches) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PolygonzkevmSequenceForceBatchesIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolygonzkevmSequenceForceBatchesIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolygonzkevmSequenceForceBatches represents a SequenceForceBatches event raised by the Polygonzkevm contract. +type PolygonzkevmSequenceForceBatches struct { + NumBatch uint64 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterSequenceForceBatches is a free log retrieval operation binding the contract event 0x648a61dd2438f072f5a1960939abd30f37aea80d2e94c9792ad142d3e0a490a4. +// +// Solidity: event SequenceForceBatches(uint64 indexed numBatch) +func (_Polygonzkevm *PolygonzkevmFilterer) FilterSequenceForceBatches(opts *bind.FilterOpts, numBatch []uint64) (*PolygonzkevmSequenceForceBatchesIterator, error) { + + var numBatchRule []interface{} + for _, numBatchItem := range numBatch { + numBatchRule = append(numBatchRule, numBatchItem) + } + + logs, sub, err := _Polygonzkevm.contract.FilterLogs(opts, "SequenceForceBatches", numBatchRule) + if err != nil { + return nil, err + } + return &PolygonzkevmSequenceForceBatchesIterator{contract: _Polygonzkevm.contract, event: "SequenceForceBatches", logs: logs, sub: sub}, nil +} + +// WatchSequenceForceBatches is a free log subscription operation binding the contract event 0x648a61dd2438f072f5a1960939abd30f37aea80d2e94c9792ad142d3e0a490a4. +// +// Solidity: event SequenceForceBatches(uint64 indexed numBatch) +func (_Polygonzkevm *PolygonzkevmFilterer) WatchSequenceForceBatches(opts *bind.WatchOpts, sink chan<- *PolygonzkevmSequenceForceBatches, numBatch []uint64) (event.Subscription, error) { + + var numBatchRule []interface{} + for _, numBatchItem := range numBatch { + numBatchRule = append(numBatchRule, numBatchItem) + } + + logs, sub, err := _Polygonzkevm.contract.WatchLogs(opts, "SequenceForceBatches", numBatchRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PolygonzkevmSequenceForceBatches) + if err := _Polygonzkevm.contract.UnpackLog(event, "SequenceForceBatches", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseSequenceForceBatches is a log parse operation binding the contract event 0x648a61dd2438f072f5a1960939abd30f37aea80d2e94c9792ad142d3e0a490a4. +// +// Solidity: event SequenceForceBatches(uint64 indexed numBatch) +func (_Polygonzkevm *PolygonzkevmFilterer) ParseSequenceForceBatches(log types.Log) (*PolygonzkevmSequenceForceBatches, error) { + event := new(PolygonzkevmSequenceForceBatches) + if err := _Polygonzkevm.contract.UnpackLog(event, "SequenceForceBatches", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PolygonzkevmSetForceBatchTimeoutIterator is returned from FilterSetForceBatchTimeout and is used to iterate over the raw logs and unpacked data for SetForceBatchTimeout events raised by the Polygonzkevm contract. +type PolygonzkevmSetForceBatchTimeoutIterator struct { + Event *PolygonzkevmSetForceBatchTimeout // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PolygonzkevmSetForceBatchTimeoutIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PolygonzkevmSetForceBatchTimeout) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PolygonzkevmSetForceBatchTimeout) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PolygonzkevmSetForceBatchTimeoutIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolygonzkevmSetForceBatchTimeoutIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolygonzkevmSetForceBatchTimeout represents a SetForceBatchTimeout event raised by the Polygonzkevm contract. +type PolygonzkevmSetForceBatchTimeout struct { + NewforceBatchTimeout uint64 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterSetForceBatchTimeout is a free log retrieval operation binding the contract event 0xa7eb6cb8a613eb4e8bddc1ac3d61ec6cf10898760f0b187bcca794c6ca6fa40b. +// +// Solidity: event SetForceBatchTimeout(uint64 newforceBatchTimeout) +func (_Polygonzkevm *PolygonzkevmFilterer) FilterSetForceBatchTimeout(opts *bind.FilterOpts) (*PolygonzkevmSetForceBatchTimeoutIterator, error) { + + logs, sub, err := _Polygonzkevm.contract.FilterLogs(opts, "SetForceBatchTimeout") + if err != nil { + return nil, err + } + return &PolygonzkevmSetForceBatchTimeoutIterator{contract: _Polygonzkevm.contract, event: "SetForceBatchTimeout", logs: logs, sub: sub}, nil +} + +// WatchSetForceBatchTimeout is a free log subscription operation binding the contract event 0xa7eb6cb8a613eb4e8bddc1ac3d61ec6cf10898760f0b187bcca794c6ca6fa40b. +// +// Solidity: event SetForceBatchTimeout(uint64 newforceBatchTimeout) +func (_Polygonzkevm *PolygonzkevmFilterer) WatchSetForceBatchTimeout(opts *bind.WatchOpts, sink chan<- *PolygonzkevmSetForceBatchTimeout) (event.Subscription, error) { + + logs, sub, err := _Polygonzkevm.contract.WatchLogs(opts, "SetForceBatchTimeout") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PolygonzkevmSetForceBatchTimeout) + if err := _Polygonzkevm.contract.UnpackLog(event, "SetForceBatchTimeout", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseSetForceBatchTimeout is a log parse operation binding the contract event 0xa7eb6cb8a613eb4e8bddc1ac3d61ec6cf10898760f0b187bcca794c6ca6fa40b. +// +// Solidity: event SetForceBatchTimeout(uint64 newforceBatchTimeout) +func (_Polygonzkevm *PolygonzkevmFilterer) ParseSetForceBatchTimeout(log types.Log) (*PolygonzkevmSetForceBatchTimeout, error) { + event := new(PolygonzkevmSetForceBatchTimeout) + if err := _Polygonzkevm.contract.UnpackLog(event, "SetForceBatchTimeout", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PolygonzkevmSetTrustedSequencerIterator is returned from FilterSetTrustedSequencer and is used to iterate over the raw logs and unpacked data for SetTrustedSequencer events raised by the Polygonzkevm contract. +type PolygonzkevmSetTrustedSequencerIterator struct { + Event *PolygonzkevmSetTrustedSequencer // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PolygonzkevmSetTrustedSequencerIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PolygonzkevmSetTrustedSequencer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PolygonzkevmSetTrustedSequencer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PolygonzkevmSetTrustedSequencerIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolygonzkevmSetTrustedSequencerIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolygonzkevmSetTrustedSequencer represents a SetTrustedSequencer event raised by the Polygonzkevm contract. +type PolygonzkevmSetTrustedSequencer struct { + NewTrustedSequencer common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterSetTrustedSequencer is a free log retrieval operation binding the contract event 0xf54144f9611984021529f814a1cb6a41e22c58351510a0d9f7e822618abb9cc0. +// +// Solidity: event SetTrustedSequencer(address newTrustedSequencer) +func (_Polygonzkevm *PolygonzkevmFilterer) FilterSetTrustedSequencer(opts *bind.FilterOpts) (*PolygonzkevmSetTrustedSequencerIterator, error) { + + logs, sub, err := _Polygonzkevm.contract.FilterLogs(opts, "SetTrustedSequencer") + if err != nil { + return nil, err + } + return &PolygonzkevmSetTrustedSequencerIterator{contract: _Polygonzkevm.contract, event: "SetTrustedSequencer", logs: logs, sub: sub}, nil +} + +// WatchSetTrustedSequencer is a free log subscription operation binding the contract event 0xf54144f9611984021529f814a1cb6a41e22c58351510a0d9f7e822618abb9cc0. +// +// Solidity: event SetTrustedSequencer(address newTrustedSequencer) +func (_Polygonzkevm *PolygonzkevmFilterer) WatchSetTrustedSequencer(opts *bind.WatchOpts, sink chan<- *PolygonzkevmSetTrustedSequencer) (event.Subscription, error) { + + logs, sub, err := _Polygonzkevm.contract.WatchLogs(opts, "SetTrustedSequencer") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PolygonzkevmSetTrustedSequencer) + if err := _Polygonzkevm.contract.UnpackLog(event, "SetTrustedSequencer", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseSetTrustedSequencer is a log parse operation binding the contract event 0xf54144f9611984021529f814a1cb6a41e22c58351510a0d9f7e822618abb9cc0. +// +// Solidity: event SetTrustedSequencer(address newTrustedSequencer) +func (_Polygonzkevm *PolygonzkevmFilterer) ParseSetTrustedSequencer(log types.Log) (*PolygonzkevmSetTrustedSequencer, error) { + event := new(PolygonzkevmSetTrustedSequencer) + if err := _Polygonzkevm.contract.UnpackLog(event, "SetTrustedSequencer", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PolygonzkevmSetTrustedSequencerURLIterator is returned from FilterSetTrustedSequencerURL and is used to iterate over the raw logs and unpacked data for SetTrustedSequencerURL events raised by the Polygonzkevm contract. +type PolygonzkevmSetTrustedSequencerURLIterator struct { + Event *PolygonzkevmSetTrustedSequencerURL // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PolygonzkevmSetTrustedSequencerURLIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PolygonzkevmSetTrustedSequencerURL) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PolygonzkevmSetTrustedSequencerURL) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PolygonzkevmSetTrustedSequencerURLIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolygonzkevmSetTrustedSequencerURLIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolygonzkevmSetTrustedSequencerURL represents a SetTrustedSequencerURL event raised by the Polygonzkevm contract. +type PolygonzkevmSetTrustedSequencerURL struct { + NewTrustedSequencerURL string + Raw types.Log // Blockchain specific contextual infos +} + +// FilterSetTrustedSequencerURL is a free log retrieval operation binding the contract event 0x6b8f723a4c7a5335cafae8a598a0aa0301be1387c037dccc085b62add6448b20. +// +// Solidity: event SetTrustedSequencerURL(string newTrustedSequencerURL) +func (_Polygonzkevm *PolygonzkevmFilterer) FilterSetTrustedSequencerURL(opts *bind.FilterOpts) (*PolygonzkevmSetTrustedSequencerURLIterator, error) { + + logs, sub, err := _Polygonzkevm.contract.FilterLogs(opts, "SetTrustedSequencerURL") + if err != nil { + return nil, err + } + return &PolygonzkevmSetTrustedSequencerURLIterator{contract: _Polygonzkevm.contract, event: "SetTrustedSequencerURL", logs: logs, sub: sub}, nil +} + +// WatchSetTrustedSequencerURL is a free log subscription operation binding the contract event 0x6b8f723a4c7a5335cafae8a598a0aa0301be1387c037dccc085b62add6448b20. +// +// Solidity: event SetTrustedSequencerURL(string newTrustedSequencerURL) +func (_Polygonzkevm *PolygonzkevmFilterer) WatchSetTrustedSequencerURL(opts *bind.WatchOpts, sink chan<- *PolygonzkevmSetTrustedSequencerURL) (event.Subscription, error) { + + logs, sub, err := _Polygonzkevm.contract.WatchLogs(opts, "SetTrustedSequencerURL") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PolygonzkevmSetTrustedSequencerURL) + if err := _Polygonzkevm.contract.UnpackLog(event, "SetTrustedSequencerURL", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseSetTrustedSequencerURL is a log parse operation binding the contract event 0x6b8f723a4c7a5335cafae8a598a0aa0301be1387c037dccc085b62add6448b20. +// +// Solidity: event SetTrustedSequencerURL(string newTrustedSequencerURL) +func (_Polygonzkevm *PolygonzkevmFilterer) ParseSetTrustedSequencerURL(log types.Log) (*PolygonzkevmSetTrustedSequencerURL, error) { + event := new(PolygonzkevmSetTrustedSequencerURL) + if err := _Polygonzkevm.contract.UnpackLog(event, "SetTrustedSequencerURL", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PolygonzkevmTransferAdminRoleIterator is returned from FilterTransferAdminRole and is used to iterate over the raw logs and unpacked data for TransferAdminRole events raised by the Polygonzkevm contract. +type PolygonzkevmTransferAdminRoleIterator struct { + Event *PolygonzkevmTransferAdminRole // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PolygonzkevmTransferAdminRoleIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PolygonzkevmTransferAdminRole) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PolygonzkevmTransferAdminRole) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PolygonzkevmTransferAdminRoleIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolygonzkevmTransferAdminRoleIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolygonzkevmTransferAdminRole represents a TransferAdminRole event raised by the Polygonzkevm contract. +type PolygonzkevmTransferAdminRole struct { + NewPendingAdmin common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterTransferAdminRole is a free log retrieval operation binding the contract event 0xa5b56b7906fd0a20e3f35120dd8343db1e12e037a6c90111c7e42885e82a1ce6. +// +// Solidity: event TransferAdminRole(address newPendingAdmin) +func (_Polygonzkevm *PolygonzkevmFilterer) FilterTransferAdminRole(opts *bind.FilterOpts) (*PolygonzkevmTransferAdminRoleIterator, error) { + + logs, sub, err := _Polygonzkevm.contract.FilterLogs(opts, "TransferAdminRole") + if err != nil { + return nil, err + } + return &PolygonzkevmTransferAdminRoleIterator{contract: _Polygonzkevm.contract, event: "TransferAdminRole", logs: logs, sub: sub}, nil +} + +// WatchTransferAdminRole is a free log subscription operation binding the contract event 0xa5b56b7906fd0a20e3f35120dd8343db1e12e037a6c90111c7e42885e82a1ce6. +// +// Solidity: event TransferAdminRole(address newPendingAdmin) +func (_Polygonzkevm *PolygonzkevmFilterer) WatchTransferAdminRole(opts *bind.WatchOpts, sink chan<- *PolygonzkevmTransferAdminRole) (event.Subscription, error) { + + logs, sub, err := _Polygonzkevm.contract.WatchLogs(opts, "TransferAdminRole") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PolygonzkevmTransferAdminRole) + if err := _Polygonzkevm.contract.UnpackLog(event, "TransferAdminRole", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseTransferAdminRole is a log parse operation binding the contract event 0xa5b56b7906fd0a20e3f35120dd8343db1e12e037a6c90111c7e42885e82a1ce6. +// +// Solidity: event TransferAdminRole(address newPendingAdmin) +func (_Polygonzkevm *PolygonzkevmFilterer) ParseTransferAdminRole(log types.Log) (*PolygonzkevmTransferAdminRole, error) { + event := new(PolygonzkevmTransferAdminRole) + if err := _Polygonzkevm.contract.UnpackLog(event, "TransferAdminRole", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PolygonzkevmVerifyBatchesIterator is returned from FilterVerifyBatches and is used to iterate over the raw logs and unpacked data for VerifyBatches events raised by the Polygonzkevm contract. +type PolygonzkevmVerifyBatchesIterator struct { + Event *PolygonzkevmVerifyBatches // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PolygonzkevmVerifyBatchesIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PolygonzkevmVerifyBatches) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PolygonzkevmVerifyBatches) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PolygonzkevmVerifyBatchesIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolygonzkevmVerifyBatchesIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolygonzkevmVerifyBatches represents a VerifyBatches event raised by the Polygonzkevm contract. +type PolygonzkevmVerifyBatches struct { + NumBatch uint64 + StateRoot [32]byte + Aggregator common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterVerifyBatches is a free log retrieval operation binding the contract event 0x9c72852172521097ba7e1482e6b44b351323df0155f97f4ea18fcec28e1f5966. +// +// Solidity: event VerifyBatches(uint64 indexed numBatch, bytes32 stateRoot, address indexed aggregator) +func (_Polygonzkevm *PolygonzkevmFilterer) FilterVerifyBatches(opts *bind.FilterOpts, numBatch []uint64, aggregator []common.Address) (*PolygonzkevmVerifyBatchesIterator, error) { + + var numBatchRule []interface{} + for _, numBatchItem := range numBatch { + numBatchRule = append(numBatchRule, numBatchItem) + } + + var aggregatorRule []interface{} + for _, aggregatorItem := range aggregator { + aggregatorRule = append(aggregatorRule, aggregatorItem) + } + + logs, sub, err := _Polygonzkevm.contract.FilterLogs(opts, "VerifyBatches", numBatchRule, aggregatorRule) + if err != nil { + return nil, err + } + return &PolygonzkevmVerifyBatchesIterator{contract: _Polygonzkevm.contract, event: "VerifyBatches", logs: logs, sub: sub}, nil +} + +// WatchVerifyBatches is a free log subscription operation binding the contract event 0x9c72852172521097ba7e1482e6b44b351323df0155f97f4ea18fcec28e1f5966. +// +// Solidity: event VerifyBatches(uint64 indexed numBatch, bytes32 stateRoot, address indexed aggregator) +func (_Polygonzkevm *PolygonzkevmFilterer) WatchVerifyBatches(opts *bind.WatchOpts, sink chan<- *PolygonzkevmVerifyBatches, numBatch []uint64, aggregator []common.Address) (event.Subscription, error) { + + var numBatchRule []interface{} + for _, numBatchItem := range numBatch { + numBatchRule = append(numBatchRule, numBatchItem) + } + + var aggregatorRule []interface{} + for _, aggregatorItem := range aggregator { + aggregatorRule = append(aggregatorRule, aggregatorItem) + } + + logs, sub, err := _Polygonzkevm.contract.WatchLogs(opts, "VerifyBatches", numBatchRule, aggregatorRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PolygonzkevmVerifyBatches) + if err := _Polygonzkevm.contract.UnpackLog(event, "VerifyBatches", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseVerifyBatches is a log parse operation binding the contract event 0x9c72852172521097ba7e1482e6b44b351323df0155f97f4ea18fcec28e1f5966. +// +// Solidity: event VerifyBatches(uint64 indexed numBatch, bytes32 stateRoot, address indexed aggregator) +func (_Polygonzkevm *PolygonzkevmFilterer) ParseVerifyBatches(log types.Log) (*PolygonzkevmVerifyBatches, error) { + event := new(PolygonzkevmVerifyBatches) + if err := _Polygonzkevm.contract.UnpackLog(event, "VerifyBatches", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/etherman/smartcontracts/polygonzkevmbridge/polygonzkevmbridge.go b/etherman/smartcontracts/polygonzkevmbridge/polygonzkevmbridge.go new file mode 100644 index 0000000..bdd711e --- /dev/null +++ b/etherman/smartcontracts/polygonzkevmbridge/polygonzkevmbridge.go @@ -0,0 +1,1904 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package polygonzkevmbridge + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// PolygonzkevmbridgeMetaData contains all meta data concerning the Polygonzkevmbridge contract. +var PolygonzkevmbridgeMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[],\"name\":\"AlreadyClaimed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"AmountDoesNotMatchMsgValue\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DestinationNetworkInvalid\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"EtherTransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"GasTokenNetworkMustBeZeroOnEther\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"GlobalExitRootInvalid\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidSmtProof\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"MerkleTreeFull\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"MessageFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"MsgValueNotZero\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NativeTokenIsEther\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NoValueInMessagesOnGasTokenNetworks\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotValidAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotValidOwner\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotValidSignature\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotValidSpender\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OnlyEmergencyState\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OnlyNotEmergencyState\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OnlyRollupManager\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"leafType\",\"type\":\"uint8\"},{\"indexed\":false,\"internalType\":\"uint32\",\"name\":\"originNetwork\",\"type\":\"uint32\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"originAddress\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint32\",\"name\":\"destinationNetwork\",\"type\":\"uint32\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"destinationAddress\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"metadata\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint32\",\"name\":\"depositCount\",\"type\":\"uint32\"}],\"name\":\"BridgeEvent\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"globalIndex\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint32\",\"name\":\"originNetwork\",\"type\":\"uint32\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"originAddress\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"destinationAddress\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"ClaimEvent\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[],\"name\":\"EmergencyStateActivated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[],\"name\":\"EmergencyStateDeactivated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint32\",\"name\":\"originNetwork\",\"type\":\"uint32\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"originTokenAddress\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"wrappedTokenAddress\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"metadata\",\"type\":\"bytes\"}],\"name\":\"NewWrappedToken\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"WETHToken\",\"outputs\":[{\"internalType\":\"contractTokenWrapped\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"activateEmergencyState\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"destinationNetwork\",\"type\":\"uint32\"},{\"internalType\":\"address\",\"name\":\"destinationAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"forceUpdateGlobalExitRoot\",\"type\":\"bool\"},{\"internalType\":\"bytes\",\"name\":\"permitData\",\"type\":\"bytes\"}],\"name\":\"bridgeAsset\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"destinationNetwork\",\"type\":\"uint32\"},{\"internalType\":\"address\",\"name\":\"destinationAddress\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"forceUpdateGlobalExitRoot\",\"type\":\"bool\"},{\"internalType\":\"bytes\",\"name\":\"metadata\",\"type\":\"bytes\"}],\"name\":\"bridgeMessage\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"destinationNetwork\",\"type\":\"uint32\"},{\"internalType\":\"address\",\"name\":\"destinationAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amountWETH\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"forceUpdateGlobalExitRoot\",\"type\":\"bool\"},{\"internalType\":\"bytes\",\"name\":\"metadata\",\"type\":\"bytes\"}],\"name\":\"bridgeMessageWETH\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"leafHash\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32[32]\",\"name\":\"smtProof\",\"type\":\"bytes32[32]\"},{\"internalType\":\"uint32\",\"name\":\"index\",\"type\":\"uint32\"}],\"name\":\"calculateRoot\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"originNetwork\",\"type\":\"uint32\"},{\"internalType\":\"address\",\"name\":\"originTokenAddress\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"calculateTokenWrapperAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32[32]\",\"name\":\"smtProofLocalExitRoot\",\"type\":\"bytes32[32]\"},{\"internalType\":\"bytes32[32]\",\"name\":\"smtProofRollupExitRoot\",\"type\":\"bytes32[32]\"},{\"internalType\":\"uint256\",\"name\":\"globalIndex\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"mainnetExitRoot\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"rollupExitRoot\",\"type\":\"bytes32\"},{\"internalType\":\"uint32\",\"name\":\"originNetwork\",\"type\":\"uint32\"},{\"internalType\":\"address\",\"name\":\"originTokenAddress\",\"type\":\"address\"},{\"internalType\":\"uint32\",\"name\":\"destinationNetwork\",\"type\":\"uint32\"},{\"internalType\":\"address\",\"name\":\"destinationAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"metadata\",\"type\":\"bytes\"}],\"name\":\"claimAsset\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32[32]\",\"name\":\"smtProofLocalExitRoot\",\"type\":\"bytes32[32]\"},{\"internalType\":\"bytes32[32]\",\"name\":\"smtProofRollupExitRoot\",\"type\":\"bytes32[32]\"},{\"internalType\":\"uint256\",\"name\":\"globalIndex\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"mainnetExitRoot\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"rollupExitRoot\",\"type\":\"bytes32\"},{\"internalType\":\"uint32\",\"name\":\"originNetwork\",\"type\":\"uint32\"},{\"internalType\":\"address\",\"name\":\"originAddress\",\"type\":\"address\"},{\"internalType\":\"uint32\",\"name\":\"destinationNetwork\",\"type\":\"uint32\"},{\"internalType\":\"address\",\"name\":\"destinationAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"metadata\",\"type\":\"bytes\"}],\"name\":\"claimMessage\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"claimedBitMap\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"deactivateEmergencyState\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"depositCount\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"gasTokenAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"gasTokenMetadata\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"gasTokenNetwork\",\"outputs\":[{\"internalType\":\"uint32\",\"name\":\"\",\"type\":\"uint32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint8\",\"name\":\"leafType\",\"type\":\"uint8\"},{\"internalType\":\"uint32\",\"name\":\"originNetwork\",\"type\":\"uint32\"},{\"internalType\":\"address\",\"name\":\"originAddress\",\"type\":\"address\"},{\"internalType\":\"uint32\",\"name\":\"destinationNetwork\",\"type\":\"uint32\"},{\"internalType\":\"address\",\"name\":\"destinationAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"metadataHash\",\"type\":\"bytes32\"}],\"name\":\"getLeafValue\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getRoot\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"getTokenMetadata\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"originNetwork\",\"type\":\"uint32\"},{\"internalType\":\"address\",\"name\":\"originTokenAddress\",\"type\":\"address\"}],\"name\":\"getTokenWrappedAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"globalExitRootManager\",\"outputs\":[{\"internalType\":\"contractIBasePolygonZkEVMGlobalExitRoot\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"_networkID\",\"type\":\"uint32\"},{\"internalType\":\"address\",\"name\":\"_gasTokenAddress\",\"type\":\"address\"},{\"internalType\":\"uint32\",\"name\":\"_gasTokenNetwork\",\"type\":\"uint32\"},{\"internalType\":\"contractIBasePolygonZkEVMGlobalExitRoot\",\"name\":\"_globalExitRootManager\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_polygonRollupManager\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"_gasTokenMetadata\",\"type\":\"bytes\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"leafIndex\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"sourceBridgeNetwork\",\"type\":\"uint32\"}],\"name\":\"isClaimed\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"isEmergencyState\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"lastUpdatedDepositCount\",\"outputs\":[{\"internalType\":\"uint32\",\"name\":\"\",\"type\":\"uint32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"networkID\",\"outputs\":[{\"internalType\":\"uint32\",\"name\":\"\",\"type\":\"uint32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"polygonRollupManager\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"originNetwork\",\"type\":\"uint32\"},{\"internalType\":\"address\",\"name\":\"originTokenAddress\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"symbol\",\"type\":\"string\"},{\"internalType\":\"uint8\",\"name\":\"decimals\",\"type\":\"uint8\"}],\"name\":\"precalculatedWrapperAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"tokenInfoToWrappedToken\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"updateGlobalExitRoot\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"leafHash\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32[32]\",\"name\":\"smtProof\",\"type\":\"bytes32[32]\"},{\"internalType\":\"uint32\",\"name\":\"index\",\"type\":\"uint32\"},{\"internalType\":\"bytes32\",\"name\":\"root\",\"type\":\"bytes32\"}],\"name\":\"verifyMerkleProof\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"wrappedTokenToTokenInfo\",\"outputs\":[{\"internalType\":\"uint32\",\"name\":\"originNetwork\",\"type\":\"uint32\"},{\"internalType\":\"address\",\"name\":\"originTokenAddress\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", + Bin: "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", +} + +// PolygonzkevmbridgeABI is the input ABI used to generate the binding from. +// Deprecated: Use PolygonzkevmbridgeMetaData.ABI instead. +var PolygonzkevmbridgeABI = PolygonzkevmbridgeMetaData.ABI + +// PolygonzkevmbridgeBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use PolygonzkevmbridgeMetaData.Bin instead. +var PolygonzkevmbridgeBin = PolygonzkevmbridgeMetaData.Bin + +// DeployPolygonzkevmbridge deploys a new Ethereum contract, binding an instance of Polygonzkevmbridge to it. +func DeployPolygonzkevmbridge(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Polygonzkevmbridge, error) { + parsed, err := PolygonzkevmbridgeMetaData.GetAbi() + if err != nil { + return common.Address{}, nil, nil, err + } + if parsed == nil { + return common.Address{}, nil, nil, errors.New("GetABI returned nil") + } + + address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex(PolygonzkevmbridgeBin), backend) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &Polygonzkevmbridge{PolygonzkevmbridgeCaller: PolygonzkevmbridgeCaller{contract: contract}, PolygonzkevmbridgeTransactor: PolygonzkevmbridgeTransactor{contract: contract}, PolygonzkevmbridgeFilterer: PolygonzkevmbridgeFilterer{contract: contract}}, nil +} + +// Polygonzkevmbridge is an auto generated Go binding around an Ethereum contract. +type Polygonzkevmbridge struct { + PolygonzkevmbridgeCaller // Read-only binding to the contract + PolygonzkevmbridgeTransactor // Write-only binding to the contract + PolygonzkevmbridgeFilterer // Log filterer for contract events +} + +// PolygonzkevmbridgeCaller is an auto generated read-only Go binding around an Ethereum contract. +type PolygonzkevmbridgeCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// PolygonzkevmbridgeTransactor is an auto generated write-only Go binding around an Ethereum contract. +type PolygonzkevmbridgeTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// PolygonzkevmbridgeFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type PolygonzkevmbridgeFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// PolygonzkevmbridgeSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type PolygonzkevmbridgeSession struct { + Contract *Polygonzkevmbridge // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// PolygonzkevmbridgeCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type PolygonzkevmbridgeCallerSession struct { + Contract *PolygonzkevmbridgeCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// PolygonzkevmbridgeTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type PolygonzkevmbridgeTransactorSession struct { + Contract *PolygonzkevmbridgeTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// PolygonzkevmbridgeRaw is an auto generated low-level Go binding around an Ethereum contract. +type PolygonzkevmbridgeRaw struct { + Contract *Polygonzkevmbridge // Generic contract binding to access the raw methods on +} + +// PolygonzkevmbridgeCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type PolygonzkevmbridgeCallerRaw struct { + Contract *PolygonzkevmbridgeCaller // Generic read-only contract binding to access the raw methods on +} + +// PolygonzkevmbridgeTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type PolygonzkevmbridgeTransactorRaw struct { + Contract *PolygonzkevmbridgeTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewPolygonzkevmbridge creates a new instance of Polygonzkevmbridge, bound to a specific deployed contract. +func NewPolygonzkevmbridge(address common.Address, backend bind.ContractBackend) (*Polygonzkevmbridge, error) { + contract, err := bindPolygonzkevmbridge(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &Polygonzkevmbridge{PolygonzkevmbridgeCaller: PolygonzkevmbridgeCaller{contract: contract}, PolygonzkevmbridgeTransactor: PolygonzkevmbridgeTransactor{contract: contract}, PolygonzkevmbridgeFilterer: PolygonzkevmbridgeFilterer{contract: contract}}, nil +} + +// NewPolygonzkevmbridgeCaller creates a new read-only instance of Polygonzkevmbridge, bound to a specific deployed contract. +func NewPolygonzkevmbridgeCaller(address common.Address, caller bind.ContractCaller) (*PolygonzkevmbridgeCaller, error) { + contract, err := bindPolygonzkevmbridge(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &PolygonzkevmbridgeCaller{contract: contract}, nil +} + +// NewPolygonzkevmbridgeTransactor creates a new write-only instance of Polygonzkevmbridge, bound to a specific deployed contract. +func NewPolygonzkevmbridgeTransactor(address common.Address, transactor bind.ContractTransactor) (*PolygonzkevmbridgeTransactor, error) { + contract, err := bindPolygonzkevmbridge(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &PolygonzkevmbridgeTransactor{contract: contract}, nil +} + +// NewPolygonzkevmbridgeFilterer creates a new log filterer instance of Polygonzkevmbridge, bound to a specific deployed contract. +func NewPolygonzkevmbridgeFilterer(address common.Address, filterer bind.ContractFilterer) (*PolygonzkevmbridgeFilterer, error) { + contract, err := bindPolygonzkevmbridge(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &PolygonzkevmbridgeFilterer{contract: contract}, nil +} + +// bindPolygonzkevmbridge binds a generic wrapper to an already deployed contract. +func bindPolygonzkevmbridge(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := PolygonzkevmbridgeMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Polygonzkevmbridge *PolygonzkevmbridgeRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Polygonzkevmbridge.Contract.PolygonzkevmbridgeCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Polygonzkevmbridge *PolygonzkevmbridgeRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Polygonzkevmbridge.Contract.PolygonzkevmbridgeTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Polygonzkevmbridge *PolygonzkevmbridgeRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Polygonzkevmbridge.Contract.PolygonzkevmbridgeTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Polygonzkevmbridge *PolygonzkevmbridgeCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Polygonzkevmbridge.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Polygonzkevmbridge *PolygonzkevmbridgeTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Polygonzkevmbridge.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Polygonzkevmbridge *PolygonzkevmbridgeTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Polygonzkevmbridge.Contract.contract.Transact(opts, method, params...) +} + +// WETHToken is a free data retrieval call binding the contract method 0x4b2f336d. +// +// Solidity: function WETHToken() view returns(address) +func (_Polygonzkevmbridge *PolygonzkevmbridgeCaller) WETHToken(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Polygonzkevmbridge.contract.Call(opts, &out, "WETHToken") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// WETHToken is a free data retrieval call binding the contract method 0x4b2f336d. +// +// Solidity: function WETHToken() view returns(address) +func (_Polygonzkevmbridge *PolygonzkevmbridgeSession) WETHToken() (common.Address, error) { + return _Polygonzkevmbridge.Contract.WETHToken(&_Polygonzkevmbridge.CallOpts) +} + +// WETHToken is a free data retrieval call binding the contract method 0x4b2f336d. +// +// Solidity: function WETHToken() view returns(address) +func (_Polygonzkevmbridge *PolygonzkevmbridgeCallerSession) WETHToken() (common.Address, error) { + return _Polygonzkevmbridge.Contract.WETHToken(&_Polygonzkevmbridge.CallOpts) +} + +// CalculateRoot is a free data retrieval call binding the contract method 0x83f24403. +// +// Solidity: function calculateRoot(bytes32 leafHash, bytes32[32] smtProof, uint32 index) pure returns(bytes32) +func (_Polygonzkevmbridge *PolygonzkevmbridgeCaller) CalculateRoot(opts *bind.CallOpts, leafHash [32]byte, smtProof [32][32]byte, index uint32) ([32]byte, error) { + var out []interface{} + err := _Polygonzkevmbridge.contract.Call(opts, &out, "calculateRoot", leafHash, smtProof, index) + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// CalculateRoot is a free data retrieval call binding the contract method 0x83f24403. +// +// Solidity: function calculateRoot(bytes32 leafHash, bytes32[32] smtProof, uint32 index) pure returns(bytes32) +func (_Polygonzkevmbridge *PolygonzkevmbridgeSession) CalculateRoot(leafHash [32]byte, smtProof [32][32]byte, index uint32) ([32]byte, error) { + return _Polygonzkevmbridge.Contract.CalculateRoot(&_Polygonzkevmbridge.CallOpts, leafHash, smtProof, index) +} + +// CalculateRoot is a free data retrieval call binding the contract method 0x83f24403. +// +// Solidity: function calculateRoot(bytes32 leafHash, bytes32[32] smtProof, uint32 index) pure returns(bytes32) +func (_Polygonzkevmbridge *PolygonzkevmbridgeCallerSession) CalculateRoot(leafHash [32]byte, smtProof [32][32]byte, index uint32) ([32]byte, error) { + return _Polygonzkevmbridge.Contract.CalculateRoot(&_Polygonzkevmbridge.CallOpts, leafHash, smtProof, index) +} + +// CalculateTokenWrapperAddress is a free data retrieval call binding the contract method 0x7843298b. +// +// Solidity: function calculateTokenWrapperAddress(uint32 originNetwork, address originTokenAddress, address token) view returns(address) +func (_Polygonzkevmbridge *PolygonzkevmbridgeCaller) CalculateTokenWrapperAddress(opts *bind.CallOpts, originNetwork uint32, originTokenAddress common.Address, token common.Address) (common.Address, error) { + var out []interface{} + err := _Polygonzkevmbridge.contract.Call(opts, &out, "calculateTokenWrapperAddress", originNetwork, originTokenAddress, token) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// CalculateTokenWrapperAddress is a free data retrieval call binding the contract method 0x7843298b. +// +// Solidity: function calculateTokenWrapperAddress(uint32 originNetwork, address originTokenAddress, address token) view returns(address) +func (_Polygonzkevmbridge *PolygonzkevmbridgeSession) CalculateTokenWrapperAddress(originNetwork uint32, originTokenAddress common.Address, token common.Address) (common.Address, error) { + return _Polygonzkevmbridge.Contract.CalculateTokenWrapperAddress(&_Polygonzkevmbridge.CallOpts, originNetwork, originTokenAddress, token) +} + +// CalculateTokenWrapperAddress is a free data retrieval call binding the contract method 0x7843298b. +// +// Solidity: function calculateTokenWrapperAddress(uint32 originNetwork, address originTokenAddress, address token) view returns(address) +func (_Polygonzkevmbridge *PolygonzkevmbridgeCallerSession) CalculateTokenWrapperAddress(originNetwork uint32, originTokenAddress common.Address, token common.Address) (common.Address, error) { + return _Polygonzkevmbridge.Contract.CalculateTokenWrapperAddress(&_Polygonzkevmbridge.CallOpts, originNetwork, originTokenAddress, token) +} + +// ClaimedBitMap is a free data retrieval call binding the contract method 0xee25560b. +// +// Solidity: function claimedBitMap(uint256 ) view returns(uint256) +func (_Polygonzkevmbridge *PolygonzkevmbridgeCaller) ClaimedBitMap(opts *bind.CallOpts, arg0 *big.Int) (*big.Int, error) { + var out []interface{} + err := _Polygonzkevmbridge.contract.Call(opts, &out, "claimedBitMap", arg0) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// ClaimedBitMap is a free data retrieval call binding the contract method 0xee25560b. +// +// Solidity: function claimedBitMap(uint256 ) view returns(uint256) +func (_Polygonzkevmbridge *PolygonzkevmbridgeSession) ClaimedBitMap(arg0 *big.Int) (*big.Int, error) { + return _Polygonzkevmbridge.Contract.ClaimedBitMap(&_Polygonzkevmbridge.CallOpts, arg0) +} + +// ClaimedBitMap is a free data retrieval call binding the contract method 0xee25560b. +// +// Solidity: function claimedBitMap(uint256 ) view returns(uint256) +func (_Polygonzkevmbridge *PolygonzkevmbridgeCallerSession) ClaimedBitMap(arg0 *big.Int) (*big.Int, error) { + return _Polygonzkevmbridge.Contract.ClaimedBitMap(&_Polygonzkevmbridge.CallOpts, arg0) +} + +// DepositCount is a free data retrieval call binding the contract method 0x2dfdf0b5. +// +// Solidity: function depositCount() view returns(uint256) +func (_Polygonzkevmbridge *PolygonzkevmbridgeCaller) DepositCount(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _Polygonzkevmbridge.contract.Call(opts, &out, "depositCount") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// DepositCount is a free data retrieval call binding the contract method 0x2dfdf0b5. +// +// Solidity: function depositCount() view returns(uint256) +func (_Polygonzkevmbridge *PolygonzkevmbridgeSession) DepositCount() (*big.Int, error) { + return _Polygonzkevmbridge.Contract.DepositCount(&_Polygonzkevmbridge.CallOpts) +} + +// DepositCount is a free data retrieval call binding the contract method 0x2dfdf0b5. +// +// Solidity: function depositCount() view returns(uint256) +func (_Polygonzkevmbridge *PolygonzkevmbridgeCallerSession) DepositCount() (*big.Int, error) { + return _Polygonzkevmbridge.Contract.DepositCount(&_Polygonzkevmbridge.CallOpts) +} + +// GasTokenAddress is a free data retrieval call binding the contract method 0x3c351e10. +// +// Solidity: function gasTokenAddress() view returns(address) +func (_Polygonzkevmbridge *PolygonzkevmbridgeCaller) GasTokenAddress(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Polygonzkevmbridge.contract.Call(opts, &out, "gasTokenAddress") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// GasTokenAddress is a free data retrieval call binding the contract method 0x3c351e10. +// +// Solidity: function gasTokenAddress() view returns(address) +func (_Polygonzkevmbridge *PolygonzkevmbridgeSession) GasTokenAddress() (common.Address, error) { + return _Polygonzkevmbridge.Contract.GasTokenAddress(&_Polygonzkevmbridge.CallOpts) +} + +// GasTokenAddress is a free data retrieval call binding the contract method 0x3c351e10. +// +// Solidity: function gasTokenAddress() view returns(address) +func (_Polygonzkevmbridge *PolygonzkevmbridgeCallerSession) GasTokenAddress() (common.Address, error) { + return _Polygonzkevmbridge.Contract.GasTokenAddress(&_Polygonzkevmbridge.CallOpts) +} + +// GasTokenMetadata is a free data retrieval call binding the contract method 0x27aef4e8. +// +// Solidity: function gasTokenMetadata() view returns(bytes) +func (_Polygonzkevmbridge *PolygonzkevmbridgeCaller) GasTokenMetadata(opts *bind.CallOpts) ([]byte, error) { + var out []interface{} + err := _Polygonzkevmbridge.contract.Call(opts, &out, "gasTokenMetadata") + + if err != nil { + return *new([]byte), err + } + + out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte) + + return out0, err + +} + +// GasTokenMetadata is a free data retrieval call binding the contract method 0x27aef4e8. +// +// Solidity: function gasTokenMetadata() view returns(bytes) +func (_Polygonzkevmbridge *PolygonzkevmbridgeSession) GasTokenMetadata() ([]byte, error) { + return _Polygonzkevmbridge.Contract.GasTokenMetadata(&_Polygonzkevmbridge.CallOpts) +} + +// GasTokenMetadata is a free data retrieval call binding the contract method 0x27aef4e8. +// +// Solidity: function gasTokenMetadata() view returns(bytes) +func (_Polygonzkevmbridge *PolygonzkevmbridgeCallerSession) GasTokenMetadata() ([]byte, error) { + return _Polygonzkevmbridge.Contract.GasTokenMetadata(&_Polygonzkevmbridge.CallOpts) +} + +// GasTokenNetwork is a free data retrieval call binding the contract method 0x3cbc795b. +// +// Solidity: function gasTokenNetwork() view returns(uint32) +func (_Polygonzkevmbridge *PolygonzkevmbridgeCaller) GasTokenNetwork(opts *bind.CallOpts) (uint32, error) { + var out []interface{} + err := _Polygonzkevmbridge.contract.Call(opts, &out, "gasTokenNetwork") + + if err != nil { + return *new(uint32), err + } + + out0 := *abi.ConvertType(out[0], new(uint32)).(*uint32) + + return out0, err + +} + +// GasTokenNetwork is a free data retrieval call binding the contract method 0x3cbc795b. +// +// Solidity: function gasTokenNetwork() view returns(uint32) +func (_Polygonzkevmbridge *PolygonzkevmbridgeSession) GasTokenNetwork() (uint32, error) { + return _Polygonzkevmbridge.Contract.GasTokenNetwork(&_Polygonzkevmbridge.CallOpts) +} + +// GasTokenNetwork is a free data retrieval call binding the contract method 0x3cbc795b. +// +// Solidity: function gasTokenNetwork() view returns(uint32) +func (_Polygonzkevmbridge *PolygonzkevmbridgeCallerSession) GasTokenNetwork() (uint32, error) { + return _Polygonzkevmbridge.Contract.GasTokenNetwork(&_Polygonzkevmbridge.CallOpts) +} + +// GetLeafValue is a free data retrieval call binding the contract method 0x3e197043. +// +// Solidity: function getLeafValue(uint8 leafType, uint32 originNetwork, address originAddress, uint32 destinationNetwork, address destinationAddress, uint256 amount, bytes32 metadataHash) pure returns(bytes32) +func (_Polygonzkevmbridge *PolygonzkevmbridgeCaller) GetLeafValue(opts *bind.CallOpts, leafType uint8, originNetwork uint32, originAddress common.Address, destinationNetwork uint32, destinationAddress common.Address, amount *big.Int, metadataHash [32]byte) ([32]byte, error) { + var out []interface{} + err := _Polygonzkevmbridge.contract.Call(opts, &out, "getLeafValue", leafType, originNetwork, originAddress, destinationNetwork, destinationAddress, amount, metadataHash) + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// GetLeafValue is a free data retrieval call binding the contract method 0x3e197043. +// +// Solidity: function getLeafValue(uint8 leafType, uint32 originNetwork, address originAddress, uint32 destinationNetwork, address destinationAddress, uint256 amount, bytes32 metadataHash) pure returns(bytes32) +func (_Polygonzkevmbridge *PolygonzkevmbridgeSession) GetLeafValue(leafType uint8, originNetwork uint32, originAddress common.Address, destinationNetwork uint32, destinationAddress common.Address, amount *big.Int, metadataHash [32]byte) ([32]byte, error) { + return _Polygonzkevmbridge.Contract.GetLeafValue(&_Polygonzkevmbridge.CallOpts, leafType, originNetwork, originAddress, destinationNetwork, destinationAddress, amount, metadataHash) +} + +// GetLeafValue is a free data retrieval call binding the contract method 0x3e197043. +// +// Solidity: function getLeafValue(uint8 leafType, uint32 originNetwork, address originAddress, uint32 destinationNetwork, address destinationAddress, uint256 amount, bytes32 metadataHash) pure returns(bytes32) +func (_Polygonzkevmbridge *PolygonzkevmbridgeCallerSession) GetLeafValue(leafType uint8, originNetwork uint32, originAddress common.Address, destinationNetwork uint32, destinationAddress common.Address, amount *big.Int, metadataHash [32]byte) ([32]byte, error) { + return _Polygonzkevmbridge.Contract.GetLeafValue(&_Polygonzkevmbridge.CallOpts, leafType, originNetwork, originAddress, destinationNetwork, destinationAddress, amount, metadataHash) +} + +// GetRoot is a free data retrieval call binding the contract method 0x5ca1e165. +// +// Solidity: function getRoot() view returns(bytes32) +func (_Polygonzkevmbridge *PolygonzkevmbridgeCaller) GetRoot(opts *bind.CallOpts) ([32]byte, error) { + var out []interface{} + err := _Polygonzkevmbridge.contract.Call(opts, &out, "getRoot") + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// GetRoot is a free data retrieval call binding the contract method 0x5ca1e165. +// +// Solidity: function getRoot() view returns(bytes32) +func (_Polygonzkevmbridge *PolygonzkevmbridgeSession) GetRoot() ([32]byte, error) { + return _Polygonzkevmbridge.Contract.GetRoot(&_Polygonzkevmbridge.CallOpts) +} + +// GetRoot is a free data retrieval call binding the contract method 0x5ca1e165. +// +// Solidity: function getRoot() view returns(bytes32) +func (_Polygonzkevmbridge *PolygonzkevmbridgeCallerSession) GetRoot() ([32]byte, error) { + return _Polygonzkevmbridge.Contract.GetRoot(&_Polygonzkevmbridge.CallOpts) +} + +// GetTokenMetadata is a free data retrieval call binding the contract method 0xc00f14ab. +// +// Solidity: function getTokenMetadata(address token) view returns(bytes) +func (_Polygonzkevmbridge *PolygonzkevmbridgeCaller) GetTokenMetadata(opts *bind.CallOpts, token common.Address) ([]byte, error) { + var out []interface{} + err := _Polygonzkevmbridge.contract.Call(opts, &out, "getTokenMetadata", token) + + if err != nil { + return *new([]byte), err + } + + out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte) + + return out0, err + +} + +// GetTokenMetadata is a free data retrieval call binding the contract method 0xc00f14ab. +// +// Solidity: function getTokenMetadata(address token) view returns(bytes) +func (_Polygonzkevmbridge *PolygonzkevmbridgeSession) GetTokenMetadata(token common.Address) ([]byte, error) { + return _Polygonzkevmbridge.Contract.GetTokenMetadata(&_Polygonzkevmbridge.CallOpts, token) +} + +// GetTokenMetadata is a free data retrieval call binding the contract method 0xc00f14ab. +// +// Solidity: function getTokenMetadata(address token) view returns(bytes) +func (_Polygonzkevmbridge *PolygonzkevmbridgeCallerSession) GetTokenMetadata(token common.Address) ([]byte, error) { + return _Polygonzkevmbridge.Contract.GetTokenMetadata(&_Polygonzkevmbridge.CallOpts, token) +} + +// GetTokenWrappedAddress is a free data retrieval call binding the contract method 0x22e95f2c. +// +// Solidity: function getTokenWrappedAddress(uint32 originNetwork, address originTokenAddress) view returns(address) +func (_Polygonzkevmbridge *PolygonzkevmbridgeCaller) GetTokenWrappedAddress(opts *bind.CallOpts, originNetwork uint32, originTokenAddress common.Address) (common.Address, error) { + var out []interface{} + err := _Polygonzkevmbridge.contract.Call(opts, &out, "getTokenWrappedAddress", originNetwork, originTokenAddress) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// GetTokenWrappedAddress is a free data retrieval call binding the contract method 0x22e95f2c. +// +// Solidity: function getTokenWrappedAddress(uint32 originNetwork, address originTokenAddress) view returns(address) +func (_Polygonzkevmbridge *PolygonzkevmbridgeSession) GetTokenWrappedAddress(originNetwork uint32, originTokenAddress common.Address) (common.Address, error) { + return _Polygonzkevmbridge.Contract.GetTokenWrappedAddress(&_Polygonzkevmbridge.CallOpts, originNetwork, originTokenAddress) +} + +// GetTokenWrappedAddress is a free data retrieval call binding the contract method 0x22e95f2c. +// +// Solidity: function getTokenWrappedAddress(uint32 originNetwork, address originTokenAddress) view returns(address) +func (_Polygonzkevmbridge *PolygonzkevmbridgeCallerSession) GetTokenWrappedAddress(originNetwork uint32, originTokenAddress common.Address) (common.Address, error) { + return _Polygonzkevmbridge.Contract.GetTokenWrappedAddress(&_Polygonzkevmbridge.CallOpts, originNetwork, originTokenAddress) +} + +// GlobalExitRootManager is a free data retrieval call binding the contract method 0xd02103ca. +// +// Solidity: function globalExitRootManager() view returns(address) +func (_Polygonzkevmbridge *PolygonzkevmbridgeCaller) GlobalExitRootManager(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Polygonzkevmbridge.contract.Call(opts, &out, "globalExitRootManager") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// GlobalExitRootManager is a free data retrieval call binding the contract method 0xd02103ca. +// +// Solidity: function globalExitRootManager() view returns(address) +func (_Polygonzkevmbridge *PolygonzkevmbridgeSession) GlobalExitRootManager() (common.Address, error) { + return _Polygonzkevmbridge.Contract.GlobalExitRootManager(&_Polygonzkevmbridge.CallOpts) +} + +// GlobalExitRootManager is a free data retrieval call binding the contract method 0xd02103ca. +// +// Solidity: function globalExitRootManager() view returns(address) +func (_Polygonzkevmbridge *PolygonzkevmbridgeCallerSession) GlobalExitRootManager() (common.Address, error) { + return _Polygonzkevmbridge.Contract.GlobalExitRootManager(&_Polygonzkevmbridge.CallOpts) +} + +// IsClaimed is a free data retrieval call binding the contract method 0xcc461632. +// +// Solidity: function isClaimed(uint32 leafIndex, uint32 sourceBridgeNetwork) view returns(bool) +func (_Polygonzkevmbridge *PolygonzkevmbridgeCaller) IsClaimed(opts *bind.CallOpts, leafIndex uint32, sourceBridgeNetwork uint32) (bool, error) { + var out []interface{} + err := _Polygonzkevmbridge.contract.Call(opts, &out, "isClaimed", leafIndex, sourceBridgeNetwork) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// IsClaimed is a free data retrieval call binding the contract method 0xcc461632. +// +// Solidity: function isClaimed(uint32 leafIndex, uint32 sourceBridgeNetwork) view returns(bool) +func (_Polygonzkevmbridge *PolygonzkevmbridgeSession) IsClaimed(leafIndex uint32, sourceBridgeNetwork uint32) (bool, error) { + return _Polygonzkevmbridge.Contract.IsClaimed(&_Polygonzkevmbridge.CallOpts, leafIndex, sourceBridgeNetwork) +} + +// IsClaimed is a free data retrieval call binding the contract method 0xcc461632. +// +// Solidity: function isClaimed(uint32 leafIndex, uint32 sourceBridgeNetwork) view returns(bool) +func (_Polygonzkevmbridge *PolygonzkevmbridgeCallerSession) IsClaimed(leafIndex uint32, sourceBridgeNetwork uint32) (bool, error) { + return _Polygonzkevmbridge.Contract.IsClaimed(&_Polygonzkevmbridge.CallOpts, leafIndex, sourceBridgeNetwork) +} + +// IsEmergencyState is a free data retrieval call binding the contract method 0x15064c96. +// +// Solidity: function isEmergencyState() view returns(bool) +func (_Polygonzkevmbridge *PolygonzkevmbridgeCaller) IsEmergencyState(opts *bind.CallOpts) (bool, error) { + var out []interface{} + err := _Polygonzkevmbridge.contract.Call(opts, &out, "isEmergencyState") + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// IsEmergencyState is a free data retrieval call binding the contract method 0x15064c96. +// +// Solidity: function isEmergencyState() view returns(bool) +func (_Polygonzkevmbridge *PolygonzkevmbridgeSession) IsEmergencyState() (bool, error) { + return _Polygonzkevmbridge.Contract.IsEmergencyState(&_Polygonzkevmbridge.CallOpts) +} + +// IsEmergencyState is a free data retrieval call binding the contract method 0x15064c96. +// +// Solidity: function isEmergencyState() view returns(bool) +func (_Polygonzkevmbridge *PolygonzkevmbridgeCallerSession) IsEmergencyState() (bool, error) { + return _Polygonzkevmbridge.Contract.IsEmergencyState(&_Polygonzkevmbridge.CallOpts) +} + +// LastUpdatedDepositCount is a free data retrieval call binding the contract method 0xbe5831c7. +// +// Solidity: function lastUpdatedDepositCount() view returns(uint32) +func (_Polygonzkevmbridge *PolygonzkevmbridgeCaller) LastUpdatedDepositCount(opts *bind.CallOpts) (uint32, error) { + var out []interface{} + err := _Polygonzkevmbridge.contract.Call(opts, &out, "lastUpdatedDepositCount") + + if err != nil { + return *new(uint32), err + } + + out0 := *abi.ConvertType(out[0], new(uint32)).(*uint32) + + return out0, err + +} + +// LastUpdatedDepositCount is a free data retrieval call binding the contract method 0xbe5831c7. +// +// Solidity: function lastUpdatedDepositCount() view returns(uint32) +func (_Polygonzkevmbridge *PolygonzkevmbridgeSession) LastUpdatedDepositCount() (uint32, error) { + return _Polygonzkevmbridge.Contract.LastUpdatedDepositCount(&_Polygonzkevmbridge.CallOpts) +} + +// LastUpdatedDepositCount is a free data retrieval call binding the contract method 0xbe5831c7. +// +// Solidity: function lastUpdatedDepositCount() view returns(uint32) +func (_Polygonzkevmbridge *PolygonzkevmbridgeCallerSession) LastUpdatedDepositCount() (uint32, error) { + return _Polygonzkevmbridge.Contract.LastUpdatedDepositCount(&_Polygonzkevmbridge.CallOpts) +} + +// NetworkID is a free data retrieval call binding the contract method 0xbab161bf. +// +// Solidity: function networkID() view returns(uint32) +func (_Polygonzkevmbridge *PolygonzkevmbridgeCaller) NetworkID(opts *bind.CallOpts) (uint32, error) { + var out []interface{} + err := _Polygonzkevmbridge.contract.Call(opts, &out, "networkID") + + if err != nil { + return *new(uint32), err + } + + out0 := *abi.ConvertType(out[0], new(uint32)).(*uint32) + + return out0, err + +} + +// NetworkID is a free data retrieval call binding the contract method 0xbab161bf. +// +// Solidity: function networkID() view returns(uint32) +func (_Polygonzkevmbridge *PolygonzkevmbridgeSession) NetworkID() (uint32, error) { + return _Polygonzkevmbridge.Contract.NetworkID(&_Polygonzkevmbridge.CallOpts) +} + +// NetworkID is a free data retrieval call binding the contract method 0xbab161bf. +// +// Solidity: function networkID() view returns(uint32) +func (_Polygonzkevmbridge *PolygonzkevmbridgeCallerSession) NetworkID() (uint32, error) { + return _Polygonzkevmbridge.Contract.NetworkID(&_Polygonzkevmbridge.CallOpts) +} + +// PolygonRollupManager is a free data retrieval call binding the contract method 0x8ed7e3f2. +// +// Solidity: function polygonRollupManager() view returns(address) +func (_Polygonzkevmbridge *PolygonzkevmbridgeCaller) PolygonRollupManager(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Polygonzkevmbridge.contract.Call(opts, &out, "polygonRollupManager") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// PolygonRollupManager is a free data retrieval call binding the contract method 0x8ed7e3f2. +// +// Solidity: function polygonRollupManager() view returns(address) +func (_Polygonzkevmbridge *PolygonzkevmbridgeSession) PolygonRollupManager() (common.Address, error) { + return _Polygonzkevmbridge.Contract.PolygonRollupManager(&_Polygonzkevmbridge.CallOpts) +} + +// PolygonRollupManager is a free data retrieval call binding the contract method 0x8ed7e3f2. +// +// Solidity: function polygonRollupManager() view returns(address) +func (_Polygonzkevmbridge *PolygonzkevmbridgeCallerSession) PolygonRollupManager() (common.Address, error) { + return _Polygonzkevmbridge.Contract.PolygonRollupManager(&_Polygonzkevmbridge.CallOpts) +} + +// PrecalculatedWrapperAddress is a free data retrieval call binding the contract method 0xaaa13cc2. +// +// Solidity: function precalculatedWrapperAddress(uint32 originNetwork, address originTokenAddress, string name, string symbol, uint8 decimals) view returns(address) +func (_Polygonzkevmbridge *PolygonzkevmbridgeCaller) PrecalculatedWrapperAddress(opts *bind.CallOpts, originNetwork uint32, originTokenAddress common.Address, name string, symbol string, decimals uint8) (common.Address, error) { + var out []interface{} + err := _Polygonzkevmbridge.contract.Call(opts, &out, "precalculatedWrapperAddress", originNetwork, originTokenAddress, name, symbol, decimals) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// PrecalculatedWrapperAddress is a free data retrieval call binding the contract method 0xaaa13cc2. +// +// Solidity: function precalculatedWrapperAddress(uint32 originNetwork, address originTokenAddress, string name, string symbol, uint8 decimals) view returns(address) +func (_Polygonzkevmbridge *PolygonzkevmbridgeSession) PrecalculatedWrapperAddress(originNetwork uint32, originTokenAddress common.Address, name string, symbol string, decimals uint8) (common.Address, error) { + return _Polygonzkevmbridge.Contract.PrecalculatedWrapperAddress(&_Polygonzkevmbridge.CallOpts, originNetwork, originTokenAddress, name, symbol, decimals) +} + +// PrecalculatedWrapperAddress is a free data retrieval call binding the contract method 0xaaa13cc2. +// +// Solidity: function precalculatedWrapperAddress(uint32 originNetwork, address originTokenAddress, string name, string symbol, uint8 decimals) view returns(address) +func (_Polygonzkevmbridge *PolygonzkevmbridgeCallerSession) PrecalculatedWrapperAddress(originNetwork uint32, originTokenAddress common.Address, name string, symbol string, decimals uint8) (common.Address, error) { + return _Polygonzkevmbridge.Contract.PrecalculatedWrapperAddress(&_Polygonzkevmbridge.CallOpts, originNetwork, originTokenAddress, name, symbol, decimals) +} + +// TokenInfoToWrappedToken is a free data retrieval call binding the contract method 0x81b1c174. +// +// Solidity: function tokenInfoToWrappedToken(bytes32 ) view returns(address) +func (_Polygonzkevmbridge *PolygonzkevmbridgeCaller) TokenInfoToWrappedToken(opts *bind.CallOpts, arg0 [32]byte) (common.Address, error) { + var out []interface{} + err := _Polygonzkevmbridge.contract.Call(opts, &out, "tokenInfoToWrappedToken", arg0) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// TokenInfoToWrappedToken is a free data retrieval call binding the contract method 0x81b1c174. +// +// Solidity: function tokenInfoToWrappedToken(bytes32 ) view returns(address) +func (_Polygonzkevmbridge *PolygonzkevmbridgeSession) TokenInfoToWrappedToken(arg0 [32]byte) (common.Address, error) { + return _Polygonzkevmbridge.Contract.TokenInfoToWrappedToken(&_Polygonzkevmbridge.CallOpts, arg0) +} + +// TokenInfoToWrappedToken is a free data retrieval call binding the contract method 0x81b1c174. +// +// Solidity: function tokenInfoToWrappedToken(bytes32 ) view returns(address) +func (_Polygonzkevmbridge *PolygonzkevmbridgeCallerSession) TokenInfoToWrappedToken(arg0 [32]byte) (common.Address, error) { + return _Polygonzkevmbridge.Contract.TokenInfoToWrappedToken(&_Polygonzkevmbridge.CallOpts, arg0) +} + +// VerifyMerkleProof is a free data retrieval call binding the contract method 0xfb570834. +// +// Solidity: function verifyMerkleProof(bytes32 leafHash, bytes32[32] smtProof, uint32 index, bytes32 root) pure returns(bool) +func (_Polygonzkevmbridge *PolygonzkevmbridgeCaller) VerifyMerkleProof(opts *bind.CallOpts, leafHash [32]byte, smtProof [32][32]byte, index uint32, root [32]byte) (bool, error) { + var out []interface{} + err := _Polygonzkevmbridge.contract.Call(opts, &out, "verifyMerkleProof", leafHash, smtProof, index, root) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// VerifyMerkleProof is a free data retrieval call binding the contract method 0xfb570834. +// +// Solidity: function verifyMerkleProof(bytes32 leafHash, bytes32[32] smtProof, uint32 index, bytes32 root) pure returns(bool) +func (_Polygonzkevmbridge *PolygonzkevmbridgeSession) VerifyMerkleProof(leafHash [32]byte, smtProof [32][32]byte, index uint32, root [32]byte) (bool, error) { + return _Polygonzkevmbridge.Contract.VerifyMerkleProof(&_Polygonzkevmbridge.CallOpts, leafHash, smtProof, index, root) +} + +// VerifyMerkleProof is a free data retrieval call binding the contract method 0xfb570834. +// +// Solidity: function verifyMerkleProof(bytes32 leafHash, bytes32[32] smtProof, uint32 index, bytes32 root) pure returns(bool) +func (_Polygonzkevmbridge *PolygonzkevmbridgeCallerSession) VerifyMerkleProof(leafHash [32]byte, smtProof [32][32]byte, index uint32, root [32]byte) (bool, error) { + return _Polygonzkevmbridge.Contract.VerifyMerkleProof(&_Polygonzkevmbridge.CallOpts, leafHash, smtProof, index, root) +} + +// WrappedTokenToTokenInfo is a free data retrieval call binding the contract method 0x318aee3d. +// +// Solidity: function wrappedTokenToTokenInfo(address ) view returns(uint32 originNetwork, address originTokenAddress) +func (_Polygonzkevmbridge *PolygonzkevmbridgeCaller) WrappedTokenToTokenInfo(opts *bind.CallOpts, arg0 common.Address) (struct { + OriginNetwork uint32 + OriginTokenAddress common.Address +}, error) { + var out []interface{} + err := _Polygonzkevmbridge.contract.Call(opts, &out, "wrappedTokenToTokenInfo", arg0) + + outstruct := new(struct { + OriginNetwork uint32 + OriginTokenAddress common.Address + }) + if err != nil { + return *outstruct, err + } + + outstruct.OriginNetwork = *abi.ConvertType(out[0], new(uint32)).(*uint32) + outstruct.OriginTokenAddress = *abi.ConvertType(out[1], new(common.Address)).(*common.Address) + + return *outstruct, err + +} + +// WrappedTokenToTokenInfo is a free data retrieval call binding the contract method 0x318aee3d. +// +// Solidity: function wrappedTokenToTokenInfo(address ) view returns(uint32 originNetwork, address originTokenAddress) +func (_Polygonzkevmbridge *PolygonzkevmbridgeSession) WrappedTokenToTokenInfo(arg0 common.Address) (struct { + OriginNetwork uint32 + OriginTokenAddress common.Address +}, error) { + return _Polygonzkevmbridge.Contract.WrappedTokenToTokenInfo(&_Polygonzkevmbridge.CallOpts, arg0) +} + +// WrappedTokenToTokenInfo is a free data retrieval call binding the contract method 0x318aee3d. +// +// Solidity: function wrappedTokenToTokenInfo(address ) view returns(uint32 originNetwork, address originTokenAddress) +func (_Polygonzkevmbridge *PolygonzkevmbridgeCallerSession) WrappedTokenToTokenInfo(arg0 common.Address) (struct { + OriginNetwork uint32 + OriginTokenAddress common.Address +}, error) { + return _Polygonzkevmbridge.Contract.WrappedTokenToTokenInfo(&_Polygonzkevmbridge.CallOpts, arg0) +} + +// ActivateEmergencyState is a paid mutator transaction binding the contract method 0x2072f6c5. +// +// Solidity: function activateEmergencyState() returns() +func (_Polygonzkevmbridge *PolygonzkevmbridgeTransactor) ActivateEmergencyState(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Polygonzkevmbridge.contract.Transact(opts, "activateEmergencyState") +} + +// ActivateEmergencyState is a paid mutator transaction binding the contract method 0x2072f6c5. +// +// Solidity: function activateEmergencyState() returns() +func (_Polygonzkevmbridge *PolygonzkevmbridgeSession) ActivateEmergencyState() (*types.Transaction, error) { + return _Polygonzkevmbridge.Contract.ActivateEmergencyState(&_Polygonzkevmbridge.TransactOpts) +} + +// ActivateEmergencyState is a paid mutator transaction binding the contract method 0x2072f6c5. +// +// Solidity: function activateEmergencyState() returns() +func (_Polygonzkevmbridge *PolygonzkevmbridgeTransactorSession) ActivateEmergencyState() (*types.Transaction, error) { + return _Polygonzkevmbridge.Contract.ActivateEmergencyState(&_Polygonzkevmbridge.TransactOpts) +} + +// BridgeAsset is a paid mutator transaction binding the contract method 0xcd586579. +// +// Solidity: function bridgeAsset(uint32 destinationNetwork, address destinationAddress, uint256 amount, address token, bool forceUpdateGlobalExitRoot, bytes permitData) payable returns() +func (_Polygonzkevmbridge *PolygonzkevmbridgeTransactor) BridgeAsset(opts *bind.TransactOpts, destinationNetwork uint32, destinationAddress common.Address, amount *big.Int, token common.Address, forceUpdateGlobalExitRoot bool, permitData []byte) (*types.Transaction, error) { + return _Polygonzkevmbridge.contract.Transact(opts, "bridgeAsset", destinationNetwork, destinationAddress, amount, token, forceUpdateGlobalExitRoot, permitData) +} + +// BridgeAsset is a paid mutator transaction binding the contract method 0xcd586579. +// +// Solidity: function bridgeAsset(uint32 destinationNetwork, address destinationAddress, uint256 amount, address token, bool forceUpdateGlobalExitRoot, bytes permitData) payable returns() +func (_Polygonzkevmbridge *PolygonzkevmbridgeSession) BridgeAsset(destinationNetwork uint32, destinationAddress common.Address, amount *big.Int, token common.Address, forceUpdateGlobalExitRoot bool, permitData []byte) (*types.Transaction, error) { + return _Polygonzkevmbridge.Contract.BridgeAsset(&_Polygonzkevmbridge.TransactOpts, destinationNetwork, destinationAddress, amount, token, forceUpdateGlobalExitRoot, permitData) +} + +// BridgeAsset is a paid mutator transaction binding the contract method 0xcd586579. +// +// Solidity: function bridgeAsset(uint32 destinationNetwork, address destinationAddress, uint256 amount, address token, bool forceUpdateGlobalExitRoot, bytes permitData) payable returns() +func (_Polygonzkevmbridge *PolygonzkevmbridgeTransactorSession) BridgeAsset(destinationNetwork uint32, destinationAddress common.Address, amount *big.Int, token common.Address, forceUpdateGlobalExitRoot bool, permitData []byte) (*types.Transaction, error) { + return _Polygonzkevmbridge.Contract.BridgeAsset(&_Polygonzkevmbridge.TransactOpts, destinationNetwork, destinationAddress, amount, token, forceUpdateGlobalExitRoot, permitData) +} + +// BridgeMessage is a paid mutator transaction binding the contract method 0x240ff378. +// +// Solidity: function bridgeMessage(uint32 destinationNetwork, address destinationAddress, bool forceUpdateGlobalExitRoot, bytes metadata) payable returns() +func (_Polygonzkevmbridge *PolygonzkevmbridgeTransactor) BridgeMessage(opts *bind.TransactOpts, destinationNetwork uint32, destinationAddress common.Address, forceUpdateGlobalExitRoot bool, metadata []byte) (*types.Transaction, error) { + return _Polygonzkevmbridge.contract.Transact(opts, "bridgeMessage", destinationNetwork, destinationAddress, forceUpdateGlobalExitRoot, metadata) +} + +// BridgeMessage is a paid mutator transaction binding the contract method 0x240ff378. +// +// Solidity: function bridgeMessage(uint32 destinationNetwork, address destinationAddress, bool forceUpdateGlobalExitRoot, bytes metadata) payable returns() +func (_Polygonzkevmbridge *PolygonzkevmbridgeSession) BridgeMessage(destinationNetwork uint32, destinationAddress common.Address, forceUpdateGlobalExitRoot bool, metadata []byte) (*types.Transaction, error) { + return _Polygonzkevmbridge.Contract.BridgeMessage(&_Polygonzkevmbridge.TransactOpts, destinationNetwork, destinationAddress, forceUpdateGlobalExitRoot, metadata) +} + +// BridgeMessage is a paid mutator transaction binding the contract method 0x240ff378. +// +// Solidity: function bridgeMessage(uint32 destinationNetwork, address destinationAddress, bool forceUpdateGlobalExitRoot, bytes metadata) payable returns() +func (_Polygonzkevmbridge *PolygonzkevmbridgeTransactorSession) BridgeMessage(destinationNetwork uint32, destinationAddress common.Address, forceUpdateGlobalExitRoot bool, metadata []byte) (*types.Transaction, error) { + return _Polygonzkevmbridge.Contract.BridgeMessage(&_Polygonzkevmbridge.TransactOpts, destinationNetwork, destinationAddress, forceUpdateGlobalExitRoot, metadata) +} + +// BridgeMessageWETH is a paid mutator transaction binding the contract method 0xb8b284d0. +// +// Solidity: function bridgeMessageWETH(uint32 destinationNetwork, address destinationAddress, uint256 amountWETH, bool forceUpdateGlobalExitRoot, bytes metadata) returns() +func (_Polygonzkevmbridge *PolygonzkevmbridgeTransactor) BridgeMessageWETH(opts *bind.TransactOpts, destinationNetwork uint32, destinationAddress common.Address, amountWETH *big.Int, forceUpdateGlobalExitRoot bool, metadata []byte) (*types.Transaction, error) { + return _Polygonzkevmbridge.contract.Transact(opts, "bridgeMessageWETH", destinationNetwork, destinationAddress, amountWETH, forceUpdateGlobalExitRoot, metadata) +} + +// BridgeMessageWETH is a paid mutator transaction binding the contract method 0xb8b284d0. +// +// Solidity: function bridgeMessageWETH(uint32 destinationNetwork, address destinationAddress, uint256 amountWETH, bool forceUpdateGlobalExitRoot, bytes metadata) returns() +func (_Polygonzkevmbridge *PolygonzkevmbridgeSession) BridgeMessageWETH(destinationNetwork uint32, destinationAddress common.Address, amountWETH *big.Int, forceUpdateGlobalExitRoot bool, metadata []byte) (*types.Transaction, error) { + return _Polygonzkevmbridge.Contract.BridgeMessageWETH(&_Polygonzkevmbridge.TransactOpts, destinationNetwork, destinationAddress, amountWETH, forceUpdateGlobalExitRoot, metadata) +} + +// BridgeMessageWETH is a paid mutator transaction binding the contract method 0xb8b284d0. +// +// Solidity: function bridgeMessageWETH(uint32 destinationNetwork, address destinationAddress, uint256 amountWETH, bool forceUpdateGlobalExitRoot, bytes metadata) returns() +func (_Polygonzkevmbridge *PolygonzkevmbridgeTransactorSession) BridgeMessageWETH(destinationNetwork uint32, destinationAddress common.Address, amountWETH *big.Int, forceUpdateGlobalExitRoot bool, metadata []byte) (*types.Transaction, error) { + return _Polygonzkevmbridge.Contract.BridgeMessageWETH(&_Polygonzkevmbridge.TransactOpts, destinationNetwork, destinationAddress, amountWETH, forceUpdateGlobalExitRoot, metadata) +} + +// ClaimAsset is a paid mutator transaction binding the contract method 0xccaa2d11. +// +// Solidity: function claimAsset(bytes32[32] smtProofLocalExitRoot, bytes32[32] smtProofRollupExitRoot, uint256 globalIndex, bytes32 mainnetExitRoot, bytes32 rollupExitRoot, uint32 originNetwork, address originTokenAddress, uint32 destinationNetwork, address destinationAddress, uint256 amount, bytes metadata) returns() +func (_Polygonzkevmbridge *PolygonzkevmbridgeTransactor) ClaimAsset(opts *bind.TransactOpts, smtProofLocalExitRoot [32][32]byte, smtProofRollupExitRoot [32][32]byte, globalIndex *big.Int, mainnetExitRoot [32]byte, rollupExitRoot [32]byte, originNetwork uint32, originTokenAddress common.Address, destinationNetwork uint32, destinationAddress common.Address, amount *big.Int, metadata []byte) (*types.Transaction, error) { + return _Polygonzkevmbridge.contract.Transact(opts, "claimAsset", smtProofLocalExitRoot, smtProofRollupExitRoot, globalIndex, mainnetExitRoot, rollupExitRoot, originNetwork, originTokenAddress, destinationNetwork, destinationAddress, amount, metadata) +} + +// ClaimAsset is a paid mutator transaction binding the contract method 0xccaa2d11. +// +// Solidity: function claimAsset(bytes32[32] smtProofLocalExitRoot, bytes32[32] smtProofRollupExitRoot, uint256 globalIndex, bytes32 mainnetExitRoot, bytes32 rollupExitRoot, uint32 originNetwork, address originTokenAddress, uint32 destinationNetwork, address destinationAddress, uint256 amount, bytes metadata) returns() +func (_Polygonzkevmbridge *PolygonzkevmbridgeSession) ClaimAsset(smtProofLocalExitRoot [32][32]byte, smtProofRollupExitRoot [32][32]byte, globalIndex *big.Int, mainnetExitRoot [32]byte, rollupExitRoot [32]byte, originNetwork uint32, originTokenAddress common.Address, destinationNetwork uint32, destinationAddress common.Address, amount *big.Int, metadata []byte) (*types.Transaction, error) { + return _Polygonzkevmbridge.Contract.ClaimAsset(&_Polygonzkevmbridge.TransactOpts, smtProofLocalExitRoot, smtProofRollupExitRoot, globalIndex, mainnetExitRoot, rollupExitRoot, originNetwork, originTokenAddress, destinationNetwork, destinationAddress, amount, metadata) +} + +// ClaimAsset is a paid mutator transaction binding the contract method 0xccaa2d11. +// +// Solidity: function claimAsset(bytes32[32] smtProofLocalExitRoot, bytes32[32] smtProofRollupExitRoot, uint256 globalIndex, bytes32 mainnetExitRoot, bytes32 rollupExitRoot, uint32 originNetwork, address originTokenAddress, uint32 destinationNetwork, address destinationAddress, uint256 amount, bytes metadata) returns() +func (_Polygonzkevmbridge *PolygonzkevmbridgeTransactorSession) ClaimAsset(smtProofLocalExitRoot [32][32]byte, smtProofRollupExitRoot [32][32]byte, globalIndex *big.Int, mainnetExitRoot [32]byte, rollupExitRoot [32]byte, originNetwork uint32, originTokenAddress common.Address, destinationNetwork uint32, destinationAddress common.Address, amount *big.Int, metadata []byte) (*types.Transaction, error) { + return _Polygonzkevmbridge.Contract.ClaimAsset(&_Polygonzkevmbridge.TransactOpts, smtProofLocalExitRoot, smtProofRollupExitRoot, globalIndex, mainnetExitRoot, rollupExitRoot, originNetwork, originTokenAddress, destinationNetwork, destinationAddress, amount, metadata) +} + +// ClaimMessage is a paid mutator transaction binding the contract method 0xf5efcd79. +// +// Solidity: function claimMessage(bytes32[32] smtProofLocalExitRoot, bytes32[32] smtProofRollupExitRoot, uint256 globalIndex, bytes32 mainnetExitRoot, bytes32 rollupExitRoot, uint32 originNetwork, address originAddress, uint32 destinationNetwork, address destinationAddress, uint256 amount, bytes metadata) returns() +func (_Polygonzkevmbridge *PolygonzkevmbridgeTransactor) ClaimMessage(opts *bind.TransactOpts, smtProofLocalExitRoot [32][32]byte, smtProofRollupExitRoot [32][32]byte, globalIndex *big.Int, mainnetExitRoot [32]byte, rollupExitRoot [32]byte, originNetwork uint32, originAddress common.Address, destinationNetwork uint32, destinationAddress common.Address, amount *big.Int, metadata []byte) (*types.Transaction, error) { + return _Polygonzkevmbridge.contract.Transact(opts, "claimMessage", smtProofLocalExitRoot, smtProofRollupExitRoot, globalIndex, mainnetExitRoot, rollupExitRoot, originNetwork, originAddress, destinationNetwork, destinationAddress, amount, metadata) +} + +// ClaimMessage is a paid mutator transaction binding the contract method 0xf5efcd79. +// +// Solidity: function claimMessage(bytes32[32] smtProofLocalExitRoot, bytes32[32] smtProofRollupExitRoot, uint256 globalIndex, bytes32 mainnetExitRoot, bytes32 rollupExitRoot, uint32 originNetwork, address originAddress, uint32 destinationNetwork, address destinationAddress, uint256 amount, bytes metadata) returns() +func (_Polygonzkevmbridge *PolygonzkevmbridgeSession) ClaimMessage(smtProofLocalExitRoot [32][32]byte, smtProofRollupExitRoot [32][32]byte, globalIndex *big.Int, mainnetExitRoot [32]byte, rollupExitRoot [32]byte, originNetwork uint32, originAddress common.Address, destinationNetwork uint32, destinationAddress common.Address, amount *big.Int, metadata []byte) (*types.Transaction, error) { + return _Polygonzkevmbridge.Contract.ClaimMessage(&_Polygonzkevmbridge.TransactOpts, smtProofLocalExitRoot, smtProofRollupExitRoot, globalIndex, mainnetExitRoot, rollupExitRoot, originNetwork, originAddress, destinationNetwork, destinationAddress, amount, metadata) +} + +// ClaimMessage is a paid mutator transaction binding the contract method 0xf5efcd79. +// +// Solidity: function claimMessage(bytes32[32] smtProofLocalExitRoot, bytes32[32] smtProofRollupExitRoot, uint256 globalIndex, bytes32 mainnetExitRoot, bytes32 rollupExitRoot, uint32 originNetwork, address originAddress, uint32 destinationNetwork, address destinationAddress, uint256 amount, bytes metadata) returns() +func (_Polygonzkevmbridge *PolygonzkevmbridgeTransactorSession) ClaimMessage(smtProofLocalExitRoot [32][32]byte, smtProofRollupExitRoot [32][32]byte, globalIndex *big.Int, mainnetExitRoot [32]byte, rollupExitRoot [32]byte, originNetwork uint32, originAddress common.Address, destinationNetwork uint32, destinationAddress common.Address, amount *big.Int, metadata []byte) (*types.Transaction, error) { + return _Polygonzkevmbridge.Contract.ClaimMessage(&_Polygonzkevmbridge.TransactOpts, smtProofLocalExitRoot, smtProofRollupExitRoot, globalIndex, mainnetExitRoot, rollupExitRoot, originNetwork, originAddress, destinationNetwork, destinationAddress, amount, metadata) +} + +// DeactivateEmergencyState is a paid mutator transaction binding the contract method 0xdbc16976. +// +// Solidity: function deactivateEmergencyState() returns() +func (_Polygonzkevmbridge *PolygonzkevmbridgeTransactor) DeactivateEmergencyState(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Polygonzkevmbridge.contract.Transact(opts, "deactivateEmergencyState") +} + +// DeactivateEmergencyState is a paid mutator transaction binding the contract method 0xdbc16976. +// +// Solidity: function deactivateEmergencyState() returns() +func (_Polygonzkevmbridge *PolygonzkevmbridgeSession) DeactivateEmergencyState() (*types.Transaction, error) { + return _Polygonzkevmbridge.Contract.DeactivateEmergencyState(&_Polygonzkevmbridge.TransactOpts) +} + +// DeactivateEmergencyState is a paid mutator transaction binding the contract method 0xdbc16976. +// +// Solidity: function deactivateEmergencyState() returns() +func (_Polygonzkevmbridge *PolygonzkevmbridgeTransactorSession) DeactivateEmergencyState() (*types.Transaction, error) { + return _Polygonzkevmbridge.Contract.DeactivateEmergencyState(&_Polygonzkevmbridge.TransactOpts) +} + +// Initialize is a paid mutator transaction binding the contract method 0xf811bff7. +// +// Solidity: function initialize(uint32 _networkID, address _gasTokenAddress, uint32 _gasTokenNetwork, address _globalExitRootManager, address _polygonRollupManager, bytes _gasTokenMetadata) returns() +func (_Polygonzkevmbridge *PolygonzkevmbridgeTransactor) Initialize(opts *bind.TransactOpts, _networkID uint32, _gasTokenAddress common.Address, _gasTokenNetwork uint32, _globalExitRootManager common.Address, _polygonRollupManager common.Address, _gasTokenMetadata []byte) (*types.Transaction, error) { + return _Polygonzkevmbridge.contract.Transact(opts, "initialize", _networkID, _gasTokenAddress, _gasTokenNetwork, _globalExitRootManager, _polygonRollupManager, _gasTokenMetadata) +} + +// Initialize is a paid mutator transaction binding the contract method 0xf811bff7. +// +// Solidity: function initialize(uint32 _networkID, address _gasTokenAddress, uint32 _gasTokenNetwork, address _globalExitRootManager, address _polygonRollupManager, bytes _gasTokenMetadata) returns() +func (_Polygonzkevmbridge *PolygonzkevmbridgeSession) Initialize(_networkID uint32, _gasTokenAddress common.Address, _gasTokenNetwork uint32, _globalExitRootManager common.Address, _polygonRollupManager common.Address, _gasTokenMetadata []byte) (*types.Transaction, error) { + return _Polygonzkevmbridge.Contract.Initialize(&_Polygonzkevmbridge.TransactOpts, _networkID, _gasTokenAddress, _gasTokenNetwork, _globalExitRootManager, _polygonRollupManager, _gasTokenMetadata) +} + +// Initialize is a paid mutator transaction binding the contract method 0xf811bff7. +// +// Solidity: function initialize(uint32 _networkID, address _gasTokenAddress, uint32 _gasTokenNetwork, address _globalExitRootManager, address _polygonRollupManager, bytes _gasTokenMetadata) returns() +func (_Polygonzkevmbridge *PolygonzkevmbridgeTransactorSession) Initialize(_networkID uint32, _gasTokenAddress common.Address, _gasTokenNetwork uint32, _globalExitRootManager common.Address, _polygonRollupManager common.Address, _gasTokenMetadata []byte) (*types.Transaction, error) { + return _Polygonzkevmbridge.Contract.Initialize(&_Polygonzkevmbridge.TransactOpts, _networkID, _gasTokenAddress, _gasTokenNetwork, _globalExitRootManager, _polygonRollupManager, _gasTokenMetadata) +} + +// UpdateGlobalExitRoot is a paid mutator transaction binding the contract method 0x79e2cf97. +// +// Solidity: function updateGlobalExitRoot() returns() +func (_Polygonzkevmbridge *PolygonzkevmbridgeTransactor) UpdateGlobalExitRoot(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Polygonzkevmbridge.contract.Transact(opts, "updateGlobalExitRoot") +} + +// UpdateGlobalExitRoot is a paid mutator transaction binding the contract method 0x79e2cf97. +// +// Solidity: function updateGlobalExitRoot() returns() +func (_Polygonzkevmbridge *PolygonzkevmbridgeSession) UpdateGlobalExitRoot() (*types.Transaction, error) { + return _Polygonzkevmbridge.Contract.UpdateGlobalExitRoot(&_Polygonzkevmbridge.TransactOpts) +} + +// UpdateGlobalExitRoot is a paid mutator transaction binding the contract method 0x79e2cf97. +// +// Solidity: function updateGlobalExitRoot() returns() +func (_Polygonzkevmbridge *PolygonzkevmbridgeTransactorSession) UpdateGlobalExitRoot() (*types.Transaction, error) { + return _Polygonzkevmbridge.Contract.UpdateGlobalExitRoot(&_Polygonzkevmbridge.TransactOpts) +} + +// PolygonzkevmbridgeBridgeEventIterator is returned from FilterBridgeEvent and is used to iterate over the raw logs and unpacked data for BridgeEvent events raised by the Polygonzkevmbridge contract. +type PolygonzkevmbridgeBridgeEventIterator struct { + Event *PolygonzkevmbridgeBridgeEvent // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PolygonzkevmbridgeBridgeEventIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PolygonzkevmbridgeBridgeEvent) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PolygonzkevmbridgeBridgeEvent) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PolygonzkevmbridgeBridgeEventIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolygonzkevmbridgeBridgeEventIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolygonzkevmbridgeBridgeEvent represents a BridgeEvent event raised by the Polygonzkevmbridge contract. +type PolygonzkevmbridgeBridgeEvent struct { + LeafType uint8 + OriginNetwork uint32 + OriginAddress common.Address + DestinationNetwork uint32 + DestinationAddress common.Address + Amount *big.Int + Metadata []byte + DepositCount uint32 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterBridgeEvent is a free log retrieval operation binding the contract event 0x501781209a1f8899323b96b4ef08b168df93e0a90c673d1e4cce39366cb62f9b. +// +// Solidity: event BridgeEvent(uint8 leafType, uint32 originNetwork, address originAddress, uint32 destinationNetwork, address destinationAddress, uint256 amount, bytes metadata, uint32 depositCount) +func (_Polygonzkevmbridge *PolygonzkevmbridgeFilterer) FilterBridgeEvent(opts *bind.FilterOpts) (*PolygonzkevmbridgeBridgeEventIterator, error) { + + logs, sub, err := _Polygonzkevmbridge.contract.FilterLogs(opts, "BridgeEvent") + if err != nil { + return nil, err + } + return &PolygonzkevmbridgeBridgeEventIterator{contract: _Polygonzkevmbridge.contract, event: "BridgeEvent", logs: logs, sub: sub}, nil +} + +// WatchBridgeEvent is a free log subscription operation binding the contract event 0x501781209a1f8899323b96b4ef08b168df93e0a90c673d1e4cce39366cb62f9b. +// +// Solidity: event BridgeEvent(uint8 leafType, uint32 originNetwork, address originAddress, uint32 destinationNetwork, address destinationAddress, uint256 amount, bytes metadata, uint32 depositCount) +func (_Polygonzkevmbridge *PolygonzkevmbridgeFilterer) WatchBridgeEvent(opts *bind.WatchOpts, sink chan<- *PolygonzkevmbridgeBridgeEvent) (event.Subscription, error) { + + logs, sub, err := _Polygonzkevmbridge.contract.WatchLogs(opts, "BridgeEvent") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PolygonzkevmbridgeBridgeEvent) + if err := _Polygonzkevmbridge.contract.UnpackLog(event, "BridgeEvent", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseBridgeEvent is a log parse operation binding the contract event 0x501781209a1f8899323b96b4ef08b168df93e0a90c673d1e4cce39366cb62f9b. +// +// Solidity: event BridgeEvent(uint8 leafType, uint32 originNetwork, address originAddress, uint32 destinationNetwork, address destinationAddress, uint256 amount, bytes metadata, uint32 depositCount) +func (_Polygonzkevmbridge *PolygonzkevmbridgeFilterer) ParseBridgeEvent(log types.Log) (*PolygonzkevmbridgeBridgeEvent, error) { + event := new(PolygonzkevmbridgeBridgeEvent) + if err := _Polygonzkevmbridge.contract.UnpackLog(event, "BridgeEvent", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PolygonzkevmbridgeClaimEventIterator is returned from FilterClaimEvent and is used to iterate over the raw logs and unpacked data for ClaimEvent events raised by the Polygonzkevmbridge contract. +type PolygonzkevmbridgeClaimEventIterator struct { + Event *PolygonzkevmbridgeClaimEvent // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PolygonzkevmbridgeClaimEventIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PolygonzkevmbridgeClaimEvent) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PolygonzkevmbridgeClaimEvent) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PolygonzkevmbridgeClaimEventIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolygonzkevmbridgeClaimEventIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolygonzkevmbridgeClaimEvent represents a ClaimEvent event raised by the Polygonzkevmbridge contract. +type PolygonzkevmbridgeClaimEvent struct { + GlobalIndex *big.Int + OriginNetwork uint32 + OriginAddress common.Address + DestinationAddress common.Address + Amount *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterClaimEvent is a free log retrieval operation binding the contract event 0x1df3f2a973a00d6635911755c260704e95e8a5876997546798770f76396fda4d. +// +// Solidity: event ClaimEvent(uint256 globalIndex, uint32 originNetwork, address originAddress, address destinationAddress, uint256 amount) +func (_Polygonzkevmbridge *PolygonzkevmbridgeFilterer) FilterClaimEvent(opts *bind.FilterOpts) (*PolygonzkevmbridgeClaimEventIterator, error) { + + logs, sub, err := _Polygonzkevmbridge.contract.FilterLogs(opts, "ClaimEvent") + if err != nil { + return nil, err + } + return &PolygonzkevmbridgeClaimEventIterator{contract: _Polygonzkevmbridge.contract, event: "ClaimEvent", logs: logs, sub: sub}, nil +} + +// WatchClaimEvent is a free log subscription operation binding the contract event 0x1df3f2a973a00d6635911755c260704e95e8a5876997546798770f76396fda4d. +// +// Solidity: event ClaimEvent(uint256 globalIndex, uint32 originNetwork, address originAddress, address destinationAddress, uint256 amount) +func (_Polygonzkevmbridge *PolygonzkevmbridgeFilterer) WatchClaimEvent(opts *bind.WatchOpts, sink chan<- *PolygonzkevmbridgeClaimEvent) (event.Subscription, error) { + + logs, sub, err := _Polygonzkevmbridge.contract.WatchLogs(opts, "ClaimEvent") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PolygonzkevmbridgeClaimEvent) + if err := _Polygonzkevmbridge.contract.UnpackLog(event, "ClaimEvent", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseClaimEvent is a log parse operation binding the contract event 0x1df3f2a973a00d6635911755c260704e95e8a5876997546798770f76396fda4d. +// +// Solidity: event ClaimEvent(uint256 globalIndex, uint32 originNetwork, address originAddress, address destinationAddress, uint256 amount) +func (_Polygonzkevmbridge *PolygonzkevmbridgeFilterer) ParseClaimEvent(log types.Log) (*PolygonzkevmbridgeClaimEvent, error) { + event := new(PolygonzkevmbridgeClaimEvent) + if err := _Polygonzkevmbridge.contract.UnpackLog(event, "ClaimEvent", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PolygonzkevmbridgeEmergencyStateActivatedIterator is returned from FilterEmergencyStateActivated and is used to iterate over the raw logs and unpacked data for EmergencyStateActivated events raised by the Polygonzkevmbridge contract. +type PolygonzkevmbridgeEmergencyStateActivatedIterator struct { + Event *PolygonzkevmbridgeEmergencyStateActivated // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PolygonzkevmbridgeEmergencyStateActivatedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PolygonzkevmbridgeEmergencyStateActivated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PolygonzkevmbridgeEmergencyStateActivated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PolygonzkevmbridgeEmergencyStateActivatedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolygonzkevmbridgeEmergencyStateActivatedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolygonzkevmbridgeEmergencyStateActivated represents a EmergencyStateActivated event raised by the Polygonzkevmbridge contract. +type PolygonzkevmbridgeEmergencyStateActivated struct { + Raw types.Log // Blockchain specific contextual infos +} + +// FilterEmergencyStateActivated is a free log retrieval operation binding the contract event 0x2261efe5aef6fedc1fd1550b25facc9181745623049c7901287030b9ad1a5497. +// +// Solidity: event EmergencyStateActivated() +func (_Polygonzkevmbridge *PolygonzkevmbridgeFilterer) FilterEmergencyStateActivated(opts *bind.FilterOpts) (*PolygonzkevmbridgeEmergencyStateActivatedIterator, error) { + + logs, sub, err := _Polygonzkevmbridge.contract.FilterLogs(opts, "EmergencyStateActivated") + if err != nil { + return nil, err + } + return &PolygonzkevmbridgeEmergencyStateActivatedIterator{contract: _Polygonzkevmbridge.contract, event: "EmergencyStateActivated", logs: logs, sub: sub}, nil +} + +// WatchEmergencyStateActivated is a free log subscription operation binding the contract event 0x2261efe5aef6fedc1fd1550b25facc9181745623049c7901287030b9ad1a5497. +// +// Solidity: event EmergencyStateActivated() +func (_Polygonzkevmbridge *PolygonzkevmbridgeFilterer) WatchEmergencyStateActivated(opts *bind.WatchOpts, sink chan<- *PolygonzkevmbridgeEmergencyStateActivated) (event.Subscription, error) { + + logs, sub, err := _Polygonzkevmbridge.contract.WatchLogs(opts, "EmergencyStateActivated") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PolygonzkevmbridgeEmergencyStateActivated) + if err := _Polygonzkevmbridge.contract.UnpackLog(event, "EmergencyStateActivated", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseEmergencyStateActivated is a log parse operation binding the contract event 0x2261efe5aef6fedc1fd1550b25facc9181745623049c7901287030b9ad1a5497. +// +// Solidity: event EmergencyStateActivated() +func (_Polygonzkevmbridge *PolygonzkevmbridgeFilterer) ParseEmergencyStateActivated(log types.Log) (*PolygonzkevmbridgeEmergencyStateActivated, error) { + event := new(PolygonzkevmbridgeEmergencyStateActivated) + if err := _Polygonzkevmbridge.contract.UnpackLog(event, "EmergencyStateActivated", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PolygonzkevmbridgeEmergencyStateDeactivatedIterator is returned from FilterEmergencyStateDeactivated and is used to iterate over the raw logs and unpacked data for EmergencyStateDeactivated events raised by the Polygonzkevmbridge contract. +type PolygonzkevmbridgeEmergencyStateDeactivatedIterator struct { + Event *PolygonzkevmbridgeEmergencyStateDeactivated // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PolygonzkevmbridgeEmergencyStateDeactivatedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PolygonzkevmbridgeEmergencyStateDeactivated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PolygonzkevmbridgeEmergencyStateDeactivated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PolygonzkevmbridgeEmergencyStateDeactivatedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolygonzkevmbridgeEmergencyStateDeactivatedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolygonzkevmbridgeEmergencyStateDeactivated represents a EmergencyStateDeactivated event raised by the Polygonzkevmbridge contract. +type PolygonzkevmbridgeEmergencyStateDeactivated struct { + Raw types.Log // Blockchain specific contextual infos +} + +// FilterEmergencyStateDeactivated is a free log retrieval operation binding the contract event 0x1e5e34eea33501aecf2ebec9fe0e884a40804275ea7fe10b2ba084c8374308b3. +// +// Solidity: event EmergencyStateDeactivated() +func (_Polygonzkevmbridge *PolygonzkevmbridgeFilterer) FilterEmergencyStateDeactivated(opts *bind.FilterOpts) (*PolygonzkevmbridgeEmergencyStateDeactivatedIterator, error) { + + logs, sub, err := _Polygonzkevmbridge.contract.FilterLogs(opts, "EmergencyStateDeactivated") + if err != nil { + return nil, err + } + return &PolygonzkevmbridgeEmergencyStateDeactivatedIterator{contract: _Polygonzkevmbridge.contract, event: "EmergencyStateDeactivated", logs: logs, sub: sub}, nil +} + +// WatchEmergencyStateDeactivated is a free log subscription operation binding the contract event 0x1e5e34eea33501aecf2ebec9fe0e884a40804275ea7fe10b2ba084c8374308b3. +// +// Solidity: event EmergencyStateDeactivated() +func (_Polygonzkevmbridge *PolygonzkevmbridgeFilterer) WatchEmergencyStateDeactivated(opts *bind.WatchOpts, sink chan<- *PolygonzkevmbridgeEmergencyStateDeactivated) (event.Subscription, error) { + + logs, sub, err := _Polygonzkevmbridge.contract.WatchLogs(opts, "EmergencyStateDeactivated") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PolygonzkevmbridgeEmergencyStateDeactivated) + if err := _Polygonzkevmbridge.contract.UnpackLog(event, "EmergencyStateDeactivated", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseEmergencyStateDeactivated is a log parse operation binding the contract event 0x1e5e34eea33501aecf2ebec9fe0e884a40804275ea7fe10b2ba084c8374308b3. +// +// Solidity: event EmergencyStateDeactivated() +func (_Polygonzkevmbridge *PolygonzkevmbridgeFilterer) ParseEmergencyStateDeactivated(log types.Log) (*PolygonzkevmbridgeEmergencyStateDeactivated, error) { + event := new(PolygonzkevmbridgeEmergencyStateDeactivated) + if err := _Polygonzkevmbridge.contract.UnpackLog(event, "EmergencyStateDeactivated", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PolygonzkevmbridgeInitializedIterator is returned from FilterInitialized and is used to iterate over the raw logs and unpacked data for Initialized events raised by the Polygonzkevmbridge contract. +type PolygonzkevmbridgeInitializedIterator struct { + Event *PolygonzkevmbridgeInitialized // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PolygonzkevmbridgeInitializedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PolygonzkevmbridgeInitialized) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PolygonzkevmbridgeInitialized) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PolygonzkevmbridgeInitializedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolygonzkevmbridgeInitializedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolygonzkevmbridgeInitialized represents a Initialized event raised by the Polygonzkevmbridge contract. +type PolygonzkevmbridgeInitialized struct { + Version uint8 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterInitialized is a free log retrieval operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_Polygonzkevmbridge *PolygonzkevmbridgeFilterer) FilterInitialized(opts *bind.FilterOpts) (*PolygonzkevmbridgeInitializedIterator, error) { + + logs, sub, err := _Polygonzkevmbridge.contract.FilterLogs(opts, "Initialized") + if err != nil { + return nil, err + } + return &PolygonzkevmbridgeInitializedIterator{contract: _Polygonzkevmbridge.contract, event: "Initialized", logs: logs, sub: sub}, nil +} + +// WatchInitialized is a free log subscription operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_Polygonzkevmbridge *PolygonzkevmbridgeFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *PolygonzkevmbridgeInitialized) (event.Subscription, error) { + + logs, sub, err := _Polygonzkevmbridge.contract.WatchLogs(opts, "Initialized") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PolygonzkevmbridgeInitialized) + if err := _Polygonzkevmbridge.contract.UnpackLog(event, "Initialized", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseInitialized is a log parse operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_Polygonzkevmbridge *PolygonzkevmbridgeFilterer) ParseInitialized(log types.Log) (*PolygonzkevmbridgeInitialized, error) { + event := new(PolygonzkevmbridgeInitialized) + if err := _Polygonzkevmbridge.contract.UnpackLog(event, "Initialized", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PolygonzkevmbridgeNewWrappedTokenIterator is returned from FilterNewWrappedToken and is used to iterate over the raw logs and unpacked data for NewWrappedToken events raised by the Polygonzkevmbridge contract. +type PolygonzkevmbridgeNewWrappedTokenIterator struct { + Event *PolygonzkevmbridgeNewWrappedToken // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PolygonzkevmbridgeNewWrappedTokenIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PolygonzkevmbridgeNewWrappedToken) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PolygonzkevmbridgeNewWrappedToken) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PolygonzkevmbridgeNewWrappedTokenIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolygonzkevmbridgeNewWrappedTokenIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolygonzkevmbridgeNewWrappedToken represents a NewWrappedToken event raised by the Polygonzkevmbridge contract. +type PolygonzkevmbridgeNewWrappedToken struct { + OriginNetwork uint32 + OriginTokenAddress common.Address + WrappedTokenAddress common.Address + Metadata []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterNewWrappedToken is a free log retrieval operation binding the contract event 0x490e59a1701b938786ac72570a1efeac994a3dbe96e2e883e19e902ace6e6a39. +// +// Solidity: event NewWrappedToken(uint32 originNetwork, address originTokenAddress, address wrappedTokenAddress, bytes metadata) +func (_Polygonzkevmbridge *PolygonzkevmbridgeFilterer) FilterNewWrappedToken(opts *bind.FilterOpts) (*PolygonzkevmbridgeNewWrappedTokenIterator, error) { + + logs, sub, err := _Polygonzkevmbridge.contract.FilterLogs(opts, "NewWrappedToken") + if err != nil { + return nil, err + } + return &PolygonzkevmbridgeNewWrappedTokenIterator{contract: _Polygonzkevmbridge.contract, event: "NewWrappedToken", logs: logs, sub: sub}, nil +} + +// WatchNewWrappedToken is a free log subscription operation binding the contract event 0x490e59a1701b938786ac72570a1efeac994a3dbe96e2e883e19e902ace6e6a39. +// +// Solidity: event NewWrappedToken(uint32 originNetwork, address originTokenAddress, address wrappedTokenAddress, bytes metadata) +func (_Polygonzkevmbridge *PolygonzkevmbridgeFilterer) WatchNewWrappedToken(opts *bind.WatchOpts, sink chan<- *PolygonzkevmbridgeNewWrappedToken) (event.Subscription, error) { + + logs, sub, err := _Polygonzkevmbridge.contract.WatchLogs(opts, "NewWrappedToken") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PolygonzkevmbridgeNewWrappedToken) + if err := _Polygonzkevmbridge.contract.UnpackLog(event, "NewWrappedToken", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseNewWrappedToken is a log parse operation binding the contract event 0x490e59a1701b938786ac72570a1efeac994a3dbe96e2e883e19e902ace6e6a39. +// +// Solidity: event NewWrappedToken(uint32 originNetwork, address originTokenAddress, address wrappedTokenAddress, bytes metadata) +func (_Polygonzkevmbridge *PolygonzkevmbridgeFilterer) ParseNewWrappedToken(log types.Log) (*PolygonzkevmbridgeNewWrappedToken, error) { + event := new(PolygonzkevmbridgeNewWrappedToken) + if err := _Polygonzkevmbridge.contract.UnpackLog(event, "NewWrappedToken", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/etherman/smartcontracts/polygonzkevmglobalexitroot/polygonzkevmglobalexitroot.go b/etherman/smartcontracts/polygonzkevmglobalexitroot/polygonzkevmglobalexitroot.go new file mode 100644 index 0000000..97c2b3e --- /dev/null +++ b/etherman/smartcontracts/polygonzkevmglobalexitroot/polygonzkevmglobalexitroot.go @@ -0,0 +1,718 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package polygonzkevmglobalexitroot + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// PolygonzkevmglobalexitrootMetaData contains all meta data concerning the Polygonzkevmglobalexitroot contract. +var PolygonzkevmglobalexitrootMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_rollupManager\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_bridgeAddress\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"MerkleTreeFull\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OnlyAllowedContracts\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"mainnetExitRoot\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"rollupExitRoot\",\"type\":\"bytes32\"}],\"name\":\"UpdateL1InfoTree\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"bridgeAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"leafHash\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32[32]\",\"name\":\"smtProof\",\"type\":\"bytes32[32]\"},{\"internalType\":\"uint32\",\"name\":\"index\",\"type\":\"uint32\"}],\"name\":\"calculateRoot\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"depositCount\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getLastGlobalExitRoot\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"newGlobalExitRoot\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"lastBlockHash\",\"type\":\"uint256\"},{\"internalType\":\"uint64\",\"name\":\"timestamp\",\"type\":\"uint64\"}],\"name\":\"getLeafValue\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getRoot\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"globalExitRootMap\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"lastMainnetExitRoot\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"lastRollupExitRoot\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"rollupManager\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"newRoot\",\"type\":\"bytes32\"}],\"name\":\"updateExitRoot\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"leafHash\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32[32]\",\"name\":\"smtProof\",\"type\":\"bytes32[32]\"},{\"internalType\":\"uint32\",\"name\":\"index\",\"type\":\"uint32\"},{\"internalType\":\"bytes32\",\"name\":\"root\",\"type\":\"bytes32\"}],\"name\":\"verifyMerkleProof\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}]", + Bin: "0x60c060405234801561001057600080fd5b50604051610b37380380610b3783398101604081905261002f91610062565b6001600160a01b0391821660a05216608052610095565b80516001600160a01b038116811461005d57600080fd5b919050565b6000806040838503121561007557600080fd5b61007e83610046565b915061008c60208401610046565b90509250929050565b60805160a051610a6f6100c86000396000818161014901526102c3015260008181610218015261027a0152610a6f6000f3fe608060405234801561001057600080fd5b50600436106100d45760003560e01c806349b7b8021161008157806383f244031161005b57806383f2440314610200578063a3c573eb14610213578063fb5708341461023a57600080fd5b806349b7b802146101445780635ca1e165146101905780635d8105011461019857600080fd5b8063319cf735116100b2578063319cf7351461011e57806333d6247d146101275780633ed691ef1461013c57600080fd5b806301fd9044146100d9578063257b3632146100f55780632dfdf0b514610115575b600080fd5b6100e260005481565b6040519081526020015b60405180910390f35b6100e261010336600461071d565b60026020526000908152604090205481565b6100e260235481565b6100e260015481565b61013a61013536600461071d565b61025d565b005b6100e2610401565b61016b7f000000000000000000000000000000000000000000000000000000000000000081565b60405173ffffffffffffffffffffffffffffffffffffffff90911681526020016100ec565b6100e2610416565b6100e26101a6366004610736565b604080516020808201959095528082019390935260c09190911b7fffffffffffffffff0000000000000000000000000000000000000000000000001660608301528051604881840301815260689092019052805191012090565b6100e261020e3660046107a7565b610420565b61016b7f000000000000000000000000000000000000000000000000000000000000000081565b61024d6102483660046107e6565b6104f6565b60405190151581526020016100ec565b60005460015473ffffffffffffffffffffffffffffffffffffffff7f00000000000000000000000000000000000000000000000000000000000000001633036102ac5750600182905581610328565b73ffffffffffffffffffffffffffffffffffffffff7f00000000000000000000000000000000000000000000000000000000000000001633036102f6576000839055829150610328565b6040517fb49365dd00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6000610334828461050e565b600081815260026020526040812054919250036103fb57600061035860014361085d565b60008381526002602090815260409182902092409283905581518082018690528083018490527fffffffffffffffff0000000000000000000000000000000000000000000000004260c01b16606082015282518082036048018152606890910190925281519101209091506103cc9061053d565b604051849084907fda61aa7823fcd807e37b95aabcbe17f03a6f3efd514176444dae191d27fd66b390600090a3505b50505050565b600061041160015460005461050e565b905090565b6000610411610640565b600083815b60208110156104ed57600163ffffffff8516821c811690036104905784816020811061045357610453610870565b602002013582604051602001610473929190918252602082015260400190565b6040516020818303038152906040528051906020012091506104db565b818582602081106104a3576104a3610870565b60200201356040516020016104c2929190918252602082015260400190565b6040516020818303038152906040528051906020012091505b806104e58161089f565b915050610425565b50949350505050565b600081610504868686610420565b1495945050505050565b604080516020808201859052818301849052825180830384018152606090920190925280519101205b92915050565b80600161054c602060026109f7565b610556919061085d565b60235410610590576040517fef5ccf6600000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60006023600081546105a19061089f565b9182905550905060005b6020811015610632578082901c6001166001036105de5782600382602081106105d6576105d6610870565b015550505050565b600381602081106105f1576105f1610870565b01546040805160208101929092528101849052606001604051602081830303815290604052805190602001209250808061062a9061089f565b9150506105ab565b5061063b610a0a565b505050565b602354600090819081805b6020811015610714578083901c6001166001036106a8576003816020811061067557610675610870565b015460408051602081019290925281018590526060016040516020818303038152906040528051906020012093506106d5565b60408051602081018690529081018390526060016040516020818303038152906040528051906020012093505b6040805160208101849052908101839052606001604051602081830303815290604052805190602001209150808061070c9061089f565b91505061064b565b50919392505050565b60006020828403121561072f57600080fd5b5035919050565b60008060006060848603121561074b57600080fd5b8335925060208401359150604084013567ffffffffffffffff8116811461077157600080fd5b809150509250925092565b80610400810183101561053757600080fd5b803563ffffffff811681146107a257600080fd5b919050565b600080600061044084860312156107bd57600080fd5b833592506107ce856020860161077c565b91506107dd610420850161078e565b90509250925092565b60008060008061046085870312156107fd57600080fd5b8435935061080e866020870161077c565b925061081d610420860161078e565b939692955092936104400135925050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b818103818111156105375761053761082e565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff82036108d0576108d061082e565b5060010190565b600181815b8085111561093057817fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff048211156109165761091661082e565b8085161561092357918102915b93841c93908002906108dc565b509250929050565b60008261094757506001610537565b8161095457506000610537565b816001811461096a576002811461097457610990565b6001915050610537565b60ff8411156109855761098561082e565b50506001821b610537565b5060208310610133831016604e8410600b84101617156109b3575081810a610537565b6109bd83836108d7565b807fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff048211156109ef576109ef61082e565b029392505050565b6000610a038383610938565b9392505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052600160045260246000fdfea2646970667358221220085253bac61681748496caf7cd5c09a387c4551b2b1cabbc8ff512cdeb63bfcc64736f6c63430008140033", +} + +// PolygonzkevmglobalexitrootABI is the input ABI used to generate the binding from. +// Deprecated: Use PolygonzkevmglobalexitrootMetaData.ABI instead. +var PolygonzkevmglobalexitrootABI = PolygonzkevmglobalexitrootMetaData.ABI + +// PolygonzkevmglobalexitrootBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use PolygonzkevmglobalexitrootMetaData.Bin instead. +var PolygonzkevmglobalexitrootBin = PolygonzkevmglobalexitrootMetaData.Bin + +// DeployPolygonzkevmglobalexitroot deploys a new Ethereum contract, binding an instance of Polygonzkevmglobalexitroot to it. +func DeployPolygonzkevmglobalexitroot(auth *bind.TransactOpts, backend bind.ContractBackend, _rollupManager common.Address, _bridgeAddress common.Address) (common.Address, *types.Transaction, *Polygonzkevmglobalexitroot, error) { + parsed, err := PolygonzkevmglobalexitrootMetaData.GetAbi() + if err != nil { + return common.Address{}, nil, nil, err + } + if parsed == nil { + return common.Address{}, nil, nil, errors.New("GetABI returned nil") + } + + address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex(PolygonzkevmglobalexitrootBin), backend, _rollupManager, _bridgeAddress) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &Polygonzkevmglobalexitroot{PolygonzkevmglobalexitrootCaller: PolygonzkevmglobalexitrootCaller{contract: contract}, PolygonzkevmglobalexitrootTransactor: PolygonzkevmglobalexitrootTransactor{contract: contract}, PolygonzkevmglobalexitrootFilterer: PolygonzkevmglobalexitrootFilterer{contract: contract}}, nil +} + +// Polygonzkevmglobalexitroot is an auto generated Go binding around an Ethereum contract. +type Polygonzkevmglobalexitroot struct { + PolygonzkevmglobalexitrootCaller // Read-only binding to the contract + PolygonzkevmglobalexitrootTransactor // Write-only binding to the contract + PolygonzkevmglobalexitrootFilterer // Log filterer for contract events +} + +// PolygonzkevmglobalexitrootCaller is an auto generated read-only Go binding around an Ethereum contract. +type PolygonzkevmglobalexitrootCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// PolygonzkevmglobalexitrootTransactor is an auto generated write-only Go binding around an Ethereum contract. +type PolygonzkevmglobalexitrootTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// PolygonzkevmglobalexitrootFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type PolygonzkevmglobalexitrootFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// PolygonzkevmglobalexitrootSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type PolygonzkevmglobalexitrootSession struct { + Contract *Polygonzkevmglobalexitroot // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// PolygonzkevmglobalexitrootCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type PolygonzkevmglobalexitrootCallerSession struct { + Contract *PolygonzkevmglobalexitrootCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// PolygonzkevmglobalexitrootTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type PolygonzkevmglobalexitrootTransactorSession struct { + Contract *PolygonzkevmglobalexitrootTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// PolygonzkevmglobalexitrootRaw is an auto generated low-level Go binding around an Ethereum contract. +type PolygonzkevmglobalexitrootRaw struct { + Contract *Polygonzkevmglobalexitroot // Generic contract binding to access the raw methods on +} + +// PolygonzkevmglobalexitrootCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type PolygonzkevmglobalexitrootCallerRaw struct { + Contract *PolygonzkevmglobalexitrootCaller // Generic read-only contract binding to access the raw methods on +} + +// PolygonzkevmglobalexitrootTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type PolygonzkevmglobalexitrootTransactorRaw struct { + Contract *PolygonzkevmglobalexitrootTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewPolygonzkevmglobalexitroot creates a new instance of Polygonzkevmglobalexitroot, bound to a specific deployed contract. +func NewPolygonzkevmglobalexitroot(address common.Address, backend bind.ContractBackend) (*Polygonzkevmglobalexitroot, error) { + contract, err := bindPolygonzkevmglobalexitroot(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &Polygonzkevmglobalexitroot{PolygonzkevmglobalexitrootCaller: PolygonzkevmglobalexitrootCaller{contract: contract}, PolygonzkevmglobalexitrootTransactor: PolygonzkevmglobalexitrootTransactor{contract: contract}, PolygonzkevmglobalexitrootFilterer: PolygonzkevmglobalexitrootFilterer{contract: contract}}, nil +} + +// NewPolygonzkevmglobalexitrootCaller creates a new read-only instance of Polygonzkevmglobalexitroot, bound to a specific deployed contract. +func NewPolygonzkevmglobalexitrootCaller(address common.Address, caller bind.ContractCaller) (*PolygonzkevmglobalexitrootCaller, error) { + contract, err := bindPolygonzkevmglobalexitroot(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &PolygonzkevmglobalexitrootCaller{contract: contract}, nil +} + +// NewPolygonzkevmglobalexitrootTransactor creates a new write-only instance of Polygonzkevmglobalexitroot, bound to a specific deployed contract. +func NewPolygonzkevmglobalexitrootTransactor(address common.Address, transactor bind.ContractTransactor) (*PolygonzkevmglobalexitrootTransactor, error) { + contract, err := bindPolygonzkevmglobalexitroot(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &PolygonzkevmglobalexitrootTransactor{contract: contract}, nil +} + +// NewPolygonzkevmglobalexitrootFilterer creates a new log filterer instance of Polygonzkevmglobalexitroot, bound to a specific deployed contract. +func NewPolygonzkevmglobalexitrootFilterer(address common.Address, filterer bind.ContractFilterer) (*PolygonzkevmglobalexitrootFilterer, error) { + contract, err := bindPolygonzkevmglobalexitroot(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &PolygonzkevmglobalexitrootFilterer{contract: contract}, nil +} + +// bindPolygonzkevmglobalexitroot binds a generic wrapper to an already deployed contract. +func bindPolygonzkevmglobalexitroot(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := PolygonzkevmglobalexitrootMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Polygonzkevmglobalexitroot *PolygonzkevmglobalexitrootRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Polygonzkevmglobalexitroot.Contract.PolygonzkevmglobalexitrootCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Polygonzkevmglobalexitroot *PolygonzkevmglobalexitrootRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Polygonzkevmglobalexitroot.Contract.PolygonzkevmglobalexitrootTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Polygonzkevmglobalexitroot *PolygonzkevmglobalexitrootRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Polygonzkevmglobalexitroot.Contract.PolygonzkevmglobalexitrootTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Polygonzkevmglobalexitroot *PolygonzkevmglobalexitrootCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Polygonzkevmglobalexitroot.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Polygonzkevmglobalexitroot *PolygonzkevmglobalexitrootTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Polygonzkevmglobalexitroot.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Polygonzkevmglobalexitroot *PolygonzkevmglobalexitrootTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Polygonzkevmglobalexitroot.Contract.contract.Transact(opts, method, params...) +} + +// BridgeAddress is a free data retrieval call binding the contract method 0xa3c573eb. +// +// Solidity: function bridgeAddress() view returns(address) +func (_Polygonzkevmglobalexitroot *PolygonzkevmglobalexitrootCaller) BridgeAddress(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Polygonzkevmglobalexitroot.contract.Call(opts, &out, "bridgeAddress") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// BridgeAddress is a free data retrieval call binding the contract method 0xa3c573eb. +// +// Solidity: function bridgeAddress() view returns(address) +func (_Polygonzkevmglobalexitroot *PolygonzkevmglobalexitrootSession) BridgeAddress() (common.Address, error) { + return _Polygonzkevmglobalexitroot.Contract.BridgeAddress(&_Polygonzkevmglobalexitroot.CallOpts) +} + +// BridgeAddress is a free data retrieval call binding the contract method 0xa3c573eb. +// +// Solidity: function bridgeAddress() view returns(address) +func (_Polygonzkevmglobalexitroot *PolygonzkevmglobalexitrootCallerSession) BridgeAddress() (common.Address, error) { + return _Polygonzkevmglobalexitroot.Contract.BridgeAddress(&_Polygonzkevmglobalexitroot.CallOpts) +} + +// CalculateRoot is a free data retrieval call binding the contract method 0x83f24403. +// +// Solidity: function calculateRoot(bytes32 leafHash, bytes32[32] smtProof, uint32 index) pure returns(bytes32) +func (_Polygonzkevmglobalexitroot *PolygonzkevmglobalexitrootCaller) CalculateRoot(opts *bind.CallOpts, leafHash [32]byte, smtProof [32][32]byte, index uint32) ([32]byte, error) { + var out []interface{} + err := _Polygonzkevmglobalexitroot.contract.Call(opts, &out, "calculateRoot", leafHash, smtProof, index) + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// CalculateRoot is a free data retrieval call binding the contract method 0x83f24403. +// +// Solidity: function calculateRoot(bytes32 leafHash, bytes32[32] smtProof, uint32 index) pure returns(bytes32) +func (_Polygonzkevmglobalexitroot *PolygonzkevmglobalexitrootSession) CalculateRoot(leafHash [32]byte, smtProof [32][32]byte, index uint32) ([32]byte, error) { + return _Polygonzkevmglobalexitroot.Contract.CalculateRoot(&_Polygonzkevmglobalexitroot.CallOpts, leafHash, smtProof, index) +} + +// CalculateRoot is a free data retrieval call binding the contract method 0x83f24403. +// +// Solidity: function calculateRoot(bytes32 leafHash, bytes32[32] smtProof, uint32 index) pure returns(bytes32) +func (_Polygonzkevmglobalexitroot *PolygonzkevmglobalexitrootCallerSession) CalculateRoot(leafHash [32]byte, smtProof [32][32]byte, index uint32) ([32]byte, error) { + return _Polygonzkevmglobalexitroot.Contract.CalculateRoot(&_Polygonzkevmglobalexitroot.CallOpts, leafHash, smtProof, index) +} + +// DepositCount is a free data retrieval call binding the contract method 0x2dfdf0b5. +// +// Solidity: function depositCount() view returns(uint256) +func (_Polygonzkevmglobalexitroot *PolygonzkevmglobalexitrootCaller) DepositCount(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _Polygonzkevmglobalexitroot.contract.Call(opts, &out, "depositCount") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// DepositCount is a free data retrieval call binding the contract method 0x2dfdf0b5. +// +// Solidity: function depositCount() view returns(uint256) +func (_Polygonzkevmglobalexitroot *PolygonzkevmglobalexitrootSession) DepositCount() (*big.Int, error) { + return _Polygonzkevmglobalexitroot.Contract.DepositCount(&_Polygonzkevmglobalexitroot.CallOpts) +} + +// DepositCount is a free data retrieval call binding the contract method 0x2dfdf0b5. +// +// Solidity: function depositCount() view returns(uint256) +func (_Polygonzkevmglobalexitroot *PolygonzkevmglobalexitrootCallerSession) DepositCount() (*big.Int, error) { + return _Polygonzkevmglobalexitroot.Contract.DepositCount(&_Polygonzkevmglobalexitroot.CallOpts) +} + +// GetLastGlobalExitRoot is a free data retrieval call binding the contract method 0x3ed691ef. +// +// Solidity: function getLastGlobalExitRoot() view returns(bytes32) +func (_Polygonzkevmglobalexitroot *PolygonzkevmglobalexitrootCaller) GetLastGlobalExitRoot(opts *bind.CallOpts) ([32]byte, error) { + var out []interface{} + err := _Polygonzkevmglobalexitroot.contract.Call(opts, &out, "getLastGlobalExitRoot") + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// GetLastGlobalExitRoot is a free data retrieval call binding the contract method 0x3ed691ef. +// +// Solidity: function getLastGlobalExitRoot() view returns(bytes32) +func (_Polygonzkevmglobalexitroot *PolygonzkevmglobalexitrootSession) GetLastGlobalExitRoot() ([32]byte, error) { + return _Polygonzkevmglobalexitroot.Contract.GetLastGlobalExitRoot(&_Polygonzkevmglobalexitroot.CallOpts) +} + +// GetLastGlobalExitRoot is a free data retrieval call binding the contract method 0x3ed691ef. +// +// Solidity: function getLastGlobalExitRoot() view returns(bytes32) +func (_Polygonzkevmglobalexitroot *PolygonzkevmglobalexitrootCallerSession) GetLastGlobalExitRoot() ([32]byte, error) { + return _Polygonzkevmglobalexitroot.Contract.GetLastGlobalExitRoot(&_Polygonzkevmglobalexitroot.CallOpts) +} + +// GetLeafValue is a free data retrieval call binding the contract method 0x5d810501. +// +// Solidity: function getLeafValue(bytes32 newGlobalExitRoot, uint256 lastBlockHash, uint64 timestamp) pure returns(bytes32) +func (_Polygonzkevmglobalexitroot *PolygonzkevmglobalexitrootCaller) GetLeafValue(opts *bind.CallOpts, newGlobalExitRoot [32]byte, lastBlockHash *big.Int, timestamp uint64) ([32]byte, error) { + var out []interface{} + err := _Polygonzkevmglobalexitroot.contract.Call(opts, &out, "getLeafValue", newGlobalExitRoot, lastBlockHash, timestamp) + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// GetLeafValue is a free data retrieval call binding the contract method 0x5d810501. +// +// Solidity: function getLeafValue(bytes32 newGlobalExitRoot, uint256 lastBlockHash, uint64 timestamp) pure returns(bytes32) +func (_Polygonzkevmglobalexitroot *PolygonzkevmglobalexitrootSession) GetLeafValue(newGlobalExitRoot [32]byte, lastBlockHash *big.Int, timestamp uint64) ([32]byte, error) { + return _Polygonzkevmglobalexitroot.Contract.GetLeafValue(&_Polygonzkevmglobalexitroot.CallOpts, newGlobalExitRoot, lastBlockHash, timestamp) +} + +// GetLeafValue is a free data retrieval call binding the contract method 0x5d810501. +// +// Solidity: function getLeafValue(bytes32 newGlobalExitRoot, uint256 lastBlockHash, uint64 timestamp) pure returns(bytes32) +func (_Polygonzkevmglobalexitroot *PolygonzkevmglobalexitrootCallerSession) GetLeafValue(newGlobalExitRoot [32]byte, lastBlockHash *big.Int, timestamp uint64) ([32]byte, error) { + return _Polygonzkevmglobalexitroot.Contract.GetLeafValue(&_Polygonzkevmglobalexitroot.CallOpts, newGlobalExitRoot, lastBlockHash, timestamp) +} + +// GetRoot is a free data retrieval call binding the contract method 0x5ca1e165. +// +// Solidity: function getRoot() view returns(bytes32) +func (_Polygonzkevmglobalexitroot *PolygonzkevmglobalexitrootCaller) GetRoot(opts *bind.CallOpts) ([32]byte, error) { + var out []interface{} + err := _Polygonzkevmglobalexitroot.contract.Call(opts, &out, "getRoot") + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// GetRoot is a free data retrieval call binding the contract method 0x5ca1e165. +// +// Solidity: function getRoot() view returns(bytes32) +func (_Polygonzkevmglobalexitroot *PolygonzkevmglobalexitrootSession) GetRoot() ([32]byte, error) { + return _Polygonzkevmglobalexitroot.Contract.GetRoot(&_Polygonzkevmglobalexitroot.CallOpts) +} + +// GetRoot is a free data retrieval call binding the contract method 0x5ca1e165. +// +// Solidity: function getRoot() view returns(bytes32) +func (_Polygonzkevmglobalexitroot *PolygonzkevmglobalexitrootCallerSession) GetRoot() ([32]byte, error) { + return _Polygonzkevmglobalexitroot.Contract.GetRoot(&_Polygonzkevmglobalexitroot.CallOpts) +} + +// GlobalExitRootMap is a free data retrieval call binding the contract method 0x257b3632. +// +// Solidity: function globalExitRootMap(bytes32 ) view returns(uint256) +func (_Polygonzkevmglobalexitroot *PolygonzkevmglobalexitrootCaller) GlobalExitRootMap(opts *bind.CallOpts, arg0 [32]byte) (*big.Int, error) { + var out []interface{} + err := _Polygonzkevmglobalexitroot.contract.Call(opts, &out, "globalExitRootMap", arg0) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// GlobalExitRootMap is a free data retrieval call binding the contract method 0x257b3632. +// +// Solidity: function globalExitRootMap(bytes32 ) view returns(uint256) +func (_Polygonzkevmglobalexitroot *PolygonzkevmglobalexitrootSession) GlobalExitRootMap(arg0 [32]byte) (*big.Int, error) { + return _Polygonzkevmglobalexitroot.Contract.GlobalExitRootMap(&_Polygonzkevmglobalexitroot.CallOpts, arg0) +} + +// GlobalExitRootMap is a free data retrieval call binding the contract method 0x257b3632. +// +// Solidity: function globalExitRootMap(bytes32 ) view returns(uint256) +func (_Polygonzkevmglobalexitroot *PolygonzkevmglobalexitrootCallerSession) GlobalExitRootMap(arg0 [32]byte) (*big.Int, error) { + return _Polygonzkevmglobalexitroot.Contract.GlobalExitRootMap(&_Polygonzkevmglobalexitroot.CallOpts, arg0) +} + +// LastMainnetExitRoot is a free data retrieval call binding the contract method 0x319cf735. +// +// Solidity: function lastMainnetExitRoot() view returns(bytes32) +func (_Polygonzkevmglobalexitroot *PolygonzkevmglobalexitrootCaller) LastMainnetExitRoot(opts *bind.CallOpts) ([32]byte, error) { + var out []interface{} + err := _Polygonzkevmglobalexitroot.contract.Call(opts, &out, "lastMainnetExitRoot") + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// LastMainnetExitRoot is a free data retrieval call binding the contract method 0x319cf735. +// +// Solidity: function lastMainnetExitRoot() view returns(bytes32) +func (_Polygonzkevmglobalexitroot *PolygonzkevmglobalexitrootSession) LastMainnetExitRoot() ([32]byte, error) { + return _Polygonzkevmglobalexitroot.Contract.LastMainnetExitRoot(&_Polygonzkevmglobalexitroot.CallOpts) +} + +// LastMainnetExitRoot is a free data retrieval call binding the contract method 0x319cf735. +// +// Solidity: function lastMainnetExitRoot() view returns(bytes32) +func (_Polygonzkevmglobalexitroot *PolygonzkevmglobalexitrootCallerSession) LastMainnetExitRoot() ([32]byte, error) { + return _Polygonzkevmglobalexitroot.Contract.LastMainnetExitRoot(&_Polygonzkevmglobalexitroot.CallOpts) +} + +// LastRollupExitRoot is a free data retrieval call binding the contract method 0x01fd9044. +// +// Solidity: function lastRollupExitRoot() view returns(bytes32) +func (_Polygonzkevmglobalexitroot *PolygonzkevmglobalexitrootCaller) LastRollupExitRoot(opts *bind.CallOpts) ([32]byte, error) { + var out []interface{} + err := _Polygonzkevmglobalexitroot.contract.Call(opts, &out, "lastRollupExitRoot") + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// LastRollupExitRoot is a free data retrieval call binding the contract method 0x01fd9044. +// +// Solidity: function lastRollupExitRoot() view returns(bytes32) +func (_Polygonzkevmglobalexitroot *PolygonzkevmglobalexitrootSession) LastRollupExitRoot() ([32]byte, error) { + return _Polygonzkevmglobalexitroot.Contract.LastRollupExitRoot(&_Polygonzkevmglobalexitroot.CallOpts) +} + +// LastRollupExitRoot is a free data retrieval call binding the contract method 0x01fd9044. +// +// Solidity: function lastRollupExitRoot() view returns(bytes32) +func (_Polygonzkevmglobalexitroot *PolygonzkevmglobalexitrootCallerSession) LastRollupExitRoot() ([32]byte, error) { + return _Polygonzkevmglobalexitroot.Contract.LastRollupExitRoot(&_Polygonzkevmglobalexitroot.CallOpts) +} + +// RollupManager is a free data retrieval call binding the contract method 0x49b7b802. +// +// Solidity: function rollupManager() view returns(address) +func (_Polygonzkevmglobalexitroot *PolygonzkevmglobalexitrootCaller) RollupManager(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Polygonzkevmglobalexitroot.contract.Call(opts, &out, "rollupManager") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// RollupManager is a free data retrieval call binding the contract method 0x49b7b802. +// +// Solidity: function rollupManager() view returns(address) +func (_Polygonzkevmglobalexitroot *PolygonzkevmglobalexitrootSession) RollupManager() (common.Address, error) { + return _Polygonzkevmglobalexitroot.Contract.RollupManager(&_Polygonzkevmglobalexitroot.CallOpts) +} + +// RollupManager is a free data retrieval call binding the contract method 0x49b7b802. +// +// Solidity: function rollupManager() view returns(address) +func (_Polygonzkevmglobalexitroot *PolygonzkevmglobalexitrootCallerSession) RollupManager() (common.Address, error) { + return _Polygonzkevmglobalexitroot.Contract.RollupManager(&_Polygonzkevmglobalexitroot.CallOpts) +} + +// VerifyMerkleProof is a free data retrieval call binding the contract method 0xfb570834. +// +// Solidity: function verifyMerkleProof(bytes32 leafHash, bytes32[32] smtProof, uint32 index, bytes32 root) pure returns(bool) +func (_Polygonzkevmglobalexitroot *PolygonzkevmglobalexitrootCaller) VerifyMerkleProof(opts *bind.CallOpts, leafHash [32]byte, smtProof [32][32]byte, index uint32, root [32]byte) (bool, error) { + var out []interface{} + err := _Polygonzkevmglobalexitroot.contract.Call(opts, &out, "verifyMerkleProof", leafHash, smtProof, index, root) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// VerifyMerkleProof is a free data retrieval call binding the contract method 0xfb570834. +// +// Solidity: function verifyMerkleProof(bytes32 leafHash, bytes32[32] smtProof, uint32 index, bytes32 root) pure returns(bool) +func (_Polygonzkevmglobalexitroot *PolygonzkevmglobalexitrootSession) VerifyMerkleProof(leafHash [32]byte, smtProof [32][32]byte, index uint32, root [32]byte) (bool, error) { + return _Polygonzkevmglobalexitroot.Contract.VerifyMerkleProof(&_Polygonzkevmglobalexitroot.CallOpts, leafHash, smtProof, index, root) +} + +// VerifyMerkleProof is a free data retrieval call binding the contract method 0xfb570834. +// +// Solidity: function verifyMerkleProof(bytes32 leafHash, bytes32[32] smtProof, uint32 index, bytes32 root) pure returns(bool) +func (_Polygonzkevmglobalexitroot *PolygonzkevmglobalexitrootCallerSession) VerifyMerkleProof(leafHash [32]byte, smtProof [32][32]byte, index uint32, root [32]byte) (bool, error) { + return _Polygonzkevmglobalexitroot.Contract.VerifyMerkleProof(&_Polygonzkevmglobalexitroot.CallOpts, leafHash, smtProof, index, root) +} + +// UpdateExitRoot is a paid mutator transaction binding the contract method 0x33d6247d. +// +// Solidity: function updateExitRoot(bytes32 newRoot) returns() +func (_Polygonzkevmglobalexitroot *PolygonzkevmglobalexitrootTransactor) UpdateExitRoot(opts *bind.TransactOpts, newRoot [32]byte) (*types.Transaction, error) { + return _Polygonzkevmglobalexitroot.contract.Transact(opts, "updateExitRoot", newRoot) +} + +// UpdateExitRoot is a paid mutator transaction binding the contract method 0x33d6247d. +// +// Solidity: function updateExitRoot(bytes32 newRoot) returns() +func (_Polygonzkevmglobalexitroot *PolygonzkevmglobalexitrootSession) UpdateExitRoot(newRoot [32]byte) (*types.Transaction, error) { + return _Polygonzkevmglobalexitroot.Contract.UpdateExitRoot(&_Polygonzkevmglobalexitroot.TransactOpts, newRoot) +} + +// UpdateExitRoot is a paid mutator transaction binding the contract method 0x33d6247d. +// +// Solidity: function updateExitRoot(bytes32 newRoot) returns() +func (_Polygonzkevmglobalexitroot *PolygonzkevmglobalexitrootTransactorSession) UpdateExitRoot(newRoot [32]byte) (*types.Transaction, error) { + return _Polygonzkevmglobalexitroot.Contract.UpdateExitRoot(&_Polygonzkevmglobalexitroot.TransactOpts, newRoot) +} + +// PolygonzkevmglobalexitrootUpdateL1InfoTreeIterator is returned from FilterUpdateL1InfoTree and is used to iterate over the raw logs and unpacked data for UpdateL1InfoTree events raised by the Polygonzkevmglobalexitroot contract. +type PolygonzkevmglobalexitrootUpdateL1InfoTreeIterator struct { + Event *PolygonzkevmglobalexitrootUpdateL1InfoTree // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PolygonzkevmglobalexitrootUpdateL1InfoTreeIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PolygonzkevmglobalexitrootUpdateL1InfoTree) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PolygonzkevmglobalexitrootUpdateL1InfoTree) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PolygonzkevmglobalexitrootUpdateL1InfoTreeIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolygonzkevmglobalexitrootUpdateL1InfoTreeIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolygonzkevmglobalexitrootUpdateL1InfoTree represents a UpdateL1InfoTree event raised by the Polygonzkevmglobalexitroot contract. +type PolygonzkevmglobalexitrootUpdateL1InfoTree struct { + MainnetExitRoot [32]byte + RollupExitRoot [32]byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterUpdateL1InfoTree is a free log retrieval operation binding the contract event 0xda61aa7823fcd807e37b95aabcbe17f03a6f3efd514176444dae191d27fd66b3. +// +// Solidity: event UpdateL1InfoTree(bytes32 indexed mainnetExitRoot, bytes32 indexed rollupExitRoot) +func (_Polygonzkevmglobalexitroot *PolygonzkevmglobalexitrootFilterer) FilterUpdateL1InfoTree(opts *bind.FilterOpts, mainnetExitRoot [][32]byte, rollupExitRoot [][32]byte) (*PolygonzkevmglobalexitrootUpdateL1InfoTreeIterator, error) { + + var mainnetExitRootRule []interface{} + for _, mainnetExitRootItem := range mainnetExitRoot { + mainnetExitRootRule = append(mainnetExitRootRule, mainnetExitRootItem) + } + var rollupExitRootRule []interface{} + for _, rollupExitRootItem := range rollupExitRoot { + rollupExitRootRule = append(rollupExitRootRule, rollupExitRootItem) + } + + logs, sub, err := _Polygonzkevmglobalexitroot.contract.FilterLogs(opts, "UpdateL1InfoTree", mainnetExitRootRule, rollupExitRootRule) + if err != nil { + return nil, err + } + return &PolygonzkevmglobalexitrootUpdateL1InfoTreeIterator{contract: _Polygonzkevmglobalexitroot.contract, event: "UpdateL1InfoTree", logs: logs, sub: sub}, nil +} + +// WatchUpdateL1InfoTree is a free log subscription operation binding the contract event 0xda61aa7823fcd807e37b95aabcbe17f03a6f3efd514176444dae191d27fd66b3. +// +// Solidity: event UpdateL1InfoTree(bytes32 indexed mainnetExitRoot, bytes32 indexed rollupExitRoot) +func (_Polygonzkevmglobalexitroot *PolygonzkevmglobalexitrootFilterer) WatchUpdateL1InfoTree(opts *bind.WatchOpts, sink chan<- *PolygonzkevmglobalexitrootUpdateL1InfoTree, mainnetExitRoot [][32]byte, rollupExitRoot [][32]byte) (event.Subscription, error) { + + var mainnetExitRootRule []interface{} + for _, mainnetExitRootItem := range mainnetExitRoot { + mainnetExitRootRule = append(mainnetExitRootRule, mainnetExitRootItem) + } + var rollupExitRootRule []interface{} + for _, rollupExitRootItem := range rollupExitRoot { + rollupExitRootRule = append(rollupExitRootRule, rollupExitRootItem) + } + + logs, sub, err := _Polygonzkevmglobalexitroot.contract.WatchLogs(opts, "UpdateL1InfoTree", mainnetExitRootRule, rollupExitRootRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PolygonzkevmglobalexitrootUpdateL1InfoTree) + if err := _Polygonzkevmglobalexitroot.contract.UnpackLog(event, "UpdateL1InfoTree", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseUpdateL1InfoTree is a log parse operation binding the contract event 0xda61aa7823fcd807e37b95aabcbe17f03a6f3efd514176444dae191d27fd66b3. +// +// Solidity: event UpdateL1InfoTree(bytes32 indexed mainnetExitRoot, bytes32 indexed rollupExitRoot) +func (_Polygonzkevmglobalexitroot *PolygonzkevmglobalexitrootFilterer) ParseUpdateL1InfoTree(log types.Log) (*PolygonzkevmglobalexitrootUpdateL1InfoTree, error) { + event := new(PolygonzkevmglobalexitrootUpdateL1InfoTree) + if err := _Polygonzkevmglobalexitroot.contract.UnpackLog(event, "UpdateL1InfoTree", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/etherman/smartcontracts/script.sh b/etherman/smartcontracts/script.sh new file mode 100755 index 0000000..143efb8 --- /dev/null +++ b/etherman/smartcontracts/script.sh @@ -0,0 +1,20 @@ +#!/bin/sh + +set -e + +gen() { + local package=$1 + + abigen --bin bin/${package}.bin --abi abi/${package}.abi --pkg=${package} --out=${package}/${package}.go +} + +gen oldpolygonzkevmglobalexitroot +gen oldpolygonzkevmbridge +gen oldpolygonzkevm +gen polygonzkevm +gen polygonzkevmbridge +gen pol +gen polygonzkevmglobalexitroot +gen polygonrollupmanager +gen mockpolygonrollupmanager +gen mockverifier \ No newline at end of file diff --git a/etherman/types.go b/etherman/types.go new file mode 100644 index 0000000..1049500 --- /dev/null +++ b/etherman/types.go @@ -0,0 +1,84 @@ +package etherman + +import ( + "time" + + "github.com/0xPolygonHermez/zkevm-ethtx-manager/etherman/smartcontracts/oldpolygonzkevm" + "github.com/0xPolygonHermez/zkevm-ethtx-manager/etherman/smartcontracts/polygonzkevm" + "github.com/ethereum/go-ethereum/common" +) + +// Block struct +type Block struct { + BlockNumber uint64 + BlockHash common.Hash + ParentHash common.Hash + ForcedBatches []ForcedBatch + SequencedBatches [][]SequencedBatch + VerifiedBatches []VerifiedBatch + SequencedForceBatches [][]SequencedForceBatch + ForkIDs []ForkID + ReceivedAt time.Time + // GER data + GlobalExitRoots, L1InfoTree []GlobalExitRoot +} + +// GlobalExitRoot struct +type GlobalExitRoot struct { + BlockNumber uint64 + MainnetExitRoot common.Hash + RollupExitRoot common.Hash + GlobalExitRoot common.Hash + Timestamp time.Time + PreviousBlockHash common.Hash +} + +// SequencedBatch represents virtual batch +type SequencedBatch struct { + BatchNumber uint64 + L1InfoRoot *common.Hash + SequencerAddr common.Address + TxHash common.Hash + Nonce uint64 + Coinbase common.Address + // Struct used in preEtrog forks + *oldpolygonzkevm.PolygonZkEVMBatchData + // Struct used in Etrog + *polygonzkevm.PolygonRollupBaseEtrogBatchData +} + +// ForcedBatch represents a ForcedBatch +type ForcedBatch struct { + BlockNumber uint64 + ForcedBatchNumber uint64 + Sequencer common.Address + GlobalExitRoot common.Hash + RawTxsData []byte + ForcedAt time.Time +} + +// VerifiedBatch represents a VerifiedBatch +type VerifiedBatch struct { + BlockNumber uint64 + BatchNumber uint64 + Aggregator common.Address + StateRoot common.Hash + TxHash common.Hash +} + +// SequencedForceBatch is a sturct to track the ForceSequencedBatches event. +type SequencedForceBatch struct { + BatchNumber uint64 + Coinbase common.Address + TxHash common.Hash + Timestamp time.Time + Nonce uint64 + polygonzkevm.PolygonRollupBaseEtrogBatchData +} + +// ForkID is a sturct to track the ForkID event. +type ForkID struct { + BatchNumber uint64 + ForkID uint64 + Version string +} diff --git a/etherman/types/finalproofinputs.go b/etherman/types/finalproofinputs.go new file mode 100644 index 0000000..ee20926 --- /dev/null +++ b/etherman/types/finalproofinputs.go @@ -0,0 +1,10 @@ +package types + +import "github.com/0xPolygonHermez/zkevm-ethtx-manager/aggregator/prover" + +// FinalProofInputs struct +type FinalProofInputs struct { + FinalProof *prover.FinalProof + NewLocalExitRoot []byte + NewStateRoot []byte +} diff --git a/etherman/types/sequence.go b/etherman/types/sequence.go new file mode 100644 index 0000000..8e4f89e --- /dev/null +++ b/etherman/types/sequence.go @@ -0,0 +1,25 @@ +package types + +import ( + "reflect" + + "github.com/ethereum/go-ethereum/common" +) + +// Sequence represents an operation sent to the PoE smart contract to be +// processed. +type Sequence struct { + GlobalExitRoot, StateRoot, LocalExitRoot common.Hash + AccInputHash common.Hash + Timestamp int64 + BatchL2Data []byte + IsSequenceTooBig bool + BatchNumber uint64 + ForcedBatchTimestamp int64 + PrevBlockHash common.Hash +} + +// IsEmpty checks is sequence struct is empty +func (s Sequence) IsEmpty() bool { + return reflect.DeepEqual(s, Sequence{}) +} diff --git a/etherman/wait.go b/etherman/wait.go new file mode 100644 index 0000000..103dea0 --- /dev/null +++ b/etherman/wait.go @@ -0,0 +1,175 @@ +package etherman + +import ( + "context" + "errors" + "fmt" + "math/big" + "os" + "os/signal" + "time" + + "github.com/0xPolygonHermez/zkevm-ethtx-manager/log" + "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/ethclient" +) + +const ( + // DefaultInterval is a time interval + DefaultInterval = 2 * time.Millisecond + // DefaultDeadline is a time interval + DefaultDeadline = 2 * time.Minute + // DefaultTxMinedDeadline is a time interval + DefaultTxMinedDeadline = 5 * time.Second +) + +var ( + // ErrTimeoutReached is thrown when the timeout is reached and + // because the condition is not matched + ErrTimeoutReached = fmt.Errorf("timeout has been reached") +) + +// Wait handles polliing until conditions are met. +type Wait struct{} + +// NewWait is the Wait constructor. +func NewWait() *Wait { + return &Wait{} +} + +// Poll retries the given condition with the given interval until it succeeds +// or the given deadline expires. +func Poll(interval, deadline time.Duration, condition ConditionFunc) error { + timeout := time.After(deadline) + tick := time.NewTicker(interval) + + for { + select { + case <-timeout: + return ErrTimeoutReached + case <-tick.C: + ok, err := condition() + if err != nil { + return err + } + if ok { + return nil + } + } + } +} + +type ethClienter interface { + ethereum.TransactionReader + ethereum.ContractCaller + bind.DeployBackend +} + +// WaitTxToBeMined waits until a tx has been mined or the given timeout expires. +func WaitTxToBeMined(parentCtx context.Context, client ethClienter, tx *types.Transaction, timeout time.Duration) error { + ctx, cancel := context.WithTimeout(parentCtx, timeout) + defer cancel() + receipt, err := bind.WaitMined(ctx, client, tx) + if errors.Is(err, context.DeadlineExceeded) { + return err + } else if err != nil { + log.Errorf("error waiting tx %s to be mined: %w", tx.Hash(), err) + return err + } + if receipt.Status == types.ReceiptStatusFailed { + // Get revert reason + reason, reasonErr := RevertReason(ctx, client, tx, receipt.BlockNumber) + if reasonErr != nil { + reason = reasonErr.Error() + } + return fmt.Errorf("transaction has failed, reason: %s, receipt: %+v. tx: %+v, gas: %v", reason, receipt, tx, tx.Gas()) + } + log.Debug("Transaction successfully mined: ", tx.Hash()) + return nil +} + +// RevertReason returns the revert reason for a tx that has a receipt with failed status +func RevertReason(ctx context.Context, c ethClienter, tx *types.Transaction, blockNumber *big.Int) (string, error) { + if tx == nil { + return "", nil + } + + from, err := types.Sender(types.NewEIP155Signer(tx.ChainId()), tx) + if err != nil { + signer := types.LatestSignerForChainID(tx.ChainId()) + from, err = types.Sender(signer, tx) + if err != nil { + return "", err + } + } + msg := ethereum.CallMsg{ + From: from, + To: tx.To(), + Gas: tx.Gas(), + + Value: tx.Value(), + Data: tx.Data(), + } + hex, err := c.CallContract(ctx, msg, blockNumber) + if err != nil { + return "", err + } + + unpackedMsg, err := abi.UnpackRevert(hex) + if err != nil { + log.Warnf("failed to get the revert message for tx %v: %v", tx.Hash(), err) + return "", errors.New("execution reverted") + } + + return unpackedMsg, nil +} + +// WaitTxReceipt waits until a tx receipt is available or the given timeout expires. +func WaitTxReceipt(ctx context.Context, txHash common.Hash, timeout time.Duration, client *ethclient.Client) (*types.Receipt, error) { + if client == nil { + return nil, fmt.Errorf("client is nil") + } + var receipt *types.Receipt + pollErr := Poll(DefaultInterval, timeout, func() (bool, error) { + var err error + receipt, err = client.TransactionReceipt(ctx, txHash) + if err != nil { + if errors.Is(err, ethereum.NotFound) { + time.Sleep(time.Second) + return false, nil + } else { + return false, err + } + } + return true, nil + }) + if pollErr != nil { + return nil, pollErr + } + return receipt, nil +} + +// ConditionFunc is a generic function +type ConditionFunc func() (done bool, err error) + +// WaitSignal blocks until an Interrupt or Kill signal is received, then it +// executes the given cleanup functions and returns. +func WaitSignal(cleanupFuncs ...func()) { + signals := make(chan os.Signal, 1) + signal.Notify(signals, os.Interrupt) + + for sig := range signals { + switch sig { + case os.Interrupt, os.Kill: + log.Info("terminating application gracefully...") + for _, cleanup := range cleanupFuncs { + cleanup() + } + return + } + } +} diff --git a/ethtxmanager/config.go b/ethtxmanager/config.go new file mode 100644 index 0000000..156ac40 --- /dev/null +++ b/ethtxmanager/config.go @@ -0,0 +1,56 @@ +package ethtxmanager + +import ( + "github.com/0xPolygonHermez/zkevm-ethtx-manager/config/types" + "github.com/0xPolygonHermez/zkevm-ethtx-manager/db" +) + +// Config is configuration for ethereum transaction manager +type Config struct { + // FrequencyToMonitorTxs frequency of the resending failed txs + FrequencyToMonitorTxs types.Duration `mapstructure:"FrequencyToMonitorTxs"` + // WaitTxToBeMined time to wait after transaction was sent to the ethereum + WaitTxToBeMined types.Duration `mapstructure:"WaitTxToBeMined"` + + // PrivateKeys defines all the key store files that are going + // to be read in order to provide the private keys to sign the L1 txs + PrivateKeys []types.KeystoreFileConfig `mapstructure:"PrivateKeys"` + + // ForcedGas is the amount of gas to be forced in case of gas estimation error + ForcedGas uint64 `mapstructure:"ForcedGas"` + + // GasPriceMarginFactor is used to multiply the suggested gas price provided by the network + // in order to allow a different gas price to be set for all the transactions and making it + // easier to have the txs prioritized in the pool, default value is 1. + // + // ex: + // suggested gas price: 100 + // GasPriceMarginFactor: 1 + // gas price = 100 + // + // suggested gas price: 100 + // GasPriceMarginFactor: 1.1 + // gas price = 110 + GasPriceMarginFactor float64 `mapstructure:"GasPriceMarginFactor"` + + // MaxGasPriceLimit helps avoiding transactions to be sent over an specified + // gas price amount, default value is 0, which means no limit. + // If the gas price provided by the network and adjusted by the GasPriceMarginFactor + // is greater than this configuration, transaction will have its gas price set to + // the value configured in this config as the limit. + // + // ex: + // + // suggested gas price: 100 + // gas price margin factor: 20% + // max gas price limit: 150 + // tx gas price = 120 + // + // suggested gas price: 100 + // gas price margin factor: 20% + // max gas price limit: 110 + // tx gas price = 110 + MaxGasPriceLimit uint64 `mapstructure:"MaxGasPriceLimit"` + // DB is the database configuration + DB db.Config `mapstructure:"DB"` +} diff --git a/ethtxmanager/ethtxmanager.go b/ethtxmanager/ethtxmanager.go new file mode 100644 index 0000000..1e00a34 --- /dev/null +++ b/ethtxmanager/ethtxmanager.go @@ -0,0 +1,727 @@ +// Package ethtxmanager handles ethereum transactions: It makes +// calls to send and to aggregate batch, checks possible errors, like wrong nonce or gas limit too low +// and make correct adjustments to request according to it. Also, it tracks transaction receipt and status +// of tx in case tx is rejected and send signals to sequencer/aggregator to resend sequence/batch +package ethtxmanager + +import ( + "context" + "errors" + "fmt" + "math/big" + "sync" + "time" + + "github.com/0xPolygonHermez/zkevm-ethtx-manager/log" + "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/jackc/pgx/v4" +) + +const ( + failureIntervalInSeconds = 5 + // maxHistorySize = 10 +) + +var ( + // ErrNotFound when the object is not found + ErrNotFound = errors.New("not found") + // ErrAlreadyExists when the object already exists + ErrAlreadyExists = errors.New("already exists") + + // ErrExecutionReverted returned when trying to get the revert message + // but the call fails without revealing the revert reason + ErrExecutionReverted = errors.New("execution reverted") +) + +// Client for eth tx manager +type Client struct { + ctx context.Context + cancel context.CancelFunc + + cfg Config + etherman ethermanInterface + storage storageInterface + // state stateInterface +} + +// New creates new eth tx manager +// func New(cfg Config, ethMan ethermanInterface, storage storageInterface, state stateInterface) *Client { +func New(cfg Config, ethMan ethermanInterface, storage storageInterface) *Client { + c := &Client{ + cfg: cfg, + etherman: ethMan, + storage: storage, + // state: state, + } + + return c +} + +// Add a transaction to be sent and monitored +func (c *Client) Add(ctx context.Context, owner, id string, from common.Address, to *common.Address, value *big.Int, data []byte, gasOffset uint64, dbTx pgx.Tx) error { + // get next nonce + nonce, err := c.etherman.CurrentNonce(ctx, from) + if err != nil { + err := fmt.Errorf("failed to get current nonce: %w", err) + log.Errorf(err.Error()) + return err + } + // get gas + gas, err := c.etherman.EstimateGas(ctx, from, to, value, data) + if err != nil { + err := fmt.Errorf("failed to estimate gas: %w, data: %v", err, common.Bytes2Hex(data)) + log.Error(err.Error()) + if c.cfg.ForcedGas > 0 { + gas = c.cfg.ForcedGas + } else { + return err + } + } + + // get gas price + gasPrice, err := c.suggestedGasPrice(ctx) + if err != nil { + err := fmt.Errorf("failed to get suggested gas price: %w", err) + log.Errorf(err.Error()) + return err + } + + // create monitored tx + mTx := monitoredTx{ + owner: owner, id: id, from: from, to: to, + nonce: nonce, value: value, data: data, + gas: gas, gasOffset: gasOffset, gasPrice: gasPrice, + status: MonitoredTxStatusCreated, + } + + // add to storage + err = c.storage.Add(ctx, mTx, dbTx) + if err != nil { + err := fmt.Errorf("failed to add tx to get monitored: %w", err) + log.Errorf(err.Error()) + return err + } + + mTxLog := log.WithFields("monitoredTx", mTx.id, "createdAt", mTx.createdAt) + mTxLog.Infof("created") + + return nil +} + +// ResultsByStatus returns all the results for all the monitored txs related to the owner and matching the provided statuses +// if the statuses are empty, all the statuses are considered. +// +// the slice is returned is in order by created_at field ascending +func (c *Client) ResultsByStatus(ctx context.Context, owner string, statuses []MonitoredTxStatus, dbTx pgx.Tx) ([]MonitoredTxResult, error) { + mTxs, err := c.storage.GetByStatus(ctx, &owner, statuses, dbTx) + if err != nil { + return nil, err + } + + results := make([]MonitoredTxResult, 0, len(mTxs)) + + for _, mTx := range mTxs { + result, err := c.buildResult(ctx, mTx) + if err != nil { + return nil, err + } + results = append(results, result) + } + + return results, nil +} + +// Result returns the current result of the transaction execution with all the details +func (c *Client) Result(ctx context.Context, owner, id string, dbTx pgx.Tx) (MonitoredTxResult, error) { + mTx, err := c.storage.Get(ctx, owner, id, dbTx) + if err != nil { + return MonitoredTxResult{}, err + } + + return c.buildResult(ctx, mTx) +} + +// SetStatusDone sets the status of a monitored tx to MonitoredStatusDone. +// this method is provided to the callers to decide when a monitored tx should be +// considered done, so they can start to ignore it when querying it by Status. +func (c *Client) setStatusDone(ctx context.Context, owner, id string, dbTx pgx.Tx) error { + mTx, err := c.storage.Get(ctx, owner, id, nil) + if err != nil { + return err + } + + mTx.status = MonitoredTxStatusDone + + return c.storage.Update(ctx, mTx, dbTx) +} + +func (c *Client) buildResult(ctx context.Context, mTx monitoredTx) (MonitoredTxResult, error) { + history := mTx.historyHashSlice() + txs := make(map[common.Hash]TxResult, len(history)) + + for _, txHash := range history { + tx, _, err := c.etherman.GetTx(ctx, txHash) + if !errors.Is(err, ethereum.NotFound) && err != nil { + return MonitoredTxResult{}, err + } + + receipt, err := c.etherman.GetTxReceipt(ctx, txHash) + if !errors.Is(err, ethereum.NotFound) && err != nil { + return MonitoredTxResult{}, err + } + + revertMessage, err := c.etherman.GetRevertMessage(ctx, tx) + if !errors.Is(err, ethereum.NotFound) && err != nil && err.Error() != ErrExecutionReverted.Error() { + return MonitoredTxResult{}, err + } + + txs[txHash] = TxResult{ + Tx: tx, + Receipt: receipt, + RevertMessage: revertMessage, + } + } + + result := MonitoredTxResult{ + ID: mTx.id, + Status: mTx.status, + Txs: txs, + } + + return result, nil +} + +// Start will start the tx management, reading txs from storage, +// send then to the blockchain and keep monitoring them until they +// get mined +func (c *Client) Start() { + // infinite loop to manage txs as they arrive + c.ctx, c.cancel = context.WithCancel(context.Background()) + + for { + select { + case <-c.ctx.Done(): + return + case <-time.After(c.cfg.FrequencyToMonitorTxs.Duration): + err := c.monitorTxs(context.Background()) + if err != nil { + c.logErrorAndWait("failed to monitor txs: %v", err) + } + } + } +} + +// Stop will stops the monitored tx management +func (c *Client) Stop() { + c.cancel() +} + +// Reorg updates all monitored txs from provided block number until the last one to +// Reorged status, allowing it to be reprocessed by the tx monitoring +func (c *Client) Reorg(ctx context.Context, fromBlockNumber uint64, dbTx pgx.Tx) error { + log.Infof("processing reorg from block: %v", fromBlockNumber) + mTxs, err := c.storage.GetByBlock(ctx, &fromBlockNumber, nil, dbTx) + if err != nil { + log.Errorf("failed to monitored tx by block: %v", err) + return err + } + log.Infof("updating %v monitored txs to reorged", len(mTxs)) + for _, mTx := range mTxs { + mTxLogger := createMonitoredTxLogger(mTx) + mTx.blockNumber = nil + mTx.status = MonitoredTxStatusReorged + + err = c.storage.Update(ctx, mTx, dbTx) + if err != nil { + mTxLogger.Errorf("failed to update monitored tx to reorg status: %v", err) + return err + } + mTxLogger.Infof("monitored tx status updated to reorged") + } + log.Infof("reorg from block %v processed successfully", fromBlockNumber) + return nil +} + +// monitorTxs process all pending monitored tx +func (c *Client) monitorTxs(ctx context.Context) error { + statusesFilter := []MonitoredTxStatus{MonitoredTxStatusCreated, MonitoredTxStatusSent, MonitoredTxStatusReorged} + mTxs, err := c.storage.GetByStatus(ctx, nil, statusesFilter, nil) + if err != nil { + return fmt.Errorf("failed to get created monitored txs: %v", err) + } + + log.Infof("found %v monitored tx to process", len(mTxs)) + + wg := sync.WaitGroup{} + wg.Add(len(mTxs)) + for _, mTx := range mTxs { + mTx := mTx // force variable shadowing to avoid pointer conflicts + go func(c *Client, mTx monitoredTx) { + mTxLogger := createMonitoredTxLogger(mTx) + defer func(mTx monitoredTx, mTxLogger *log.Logger) { + if err := recover(); err != nil { + mTxLogger.Error("monitoring recovered from this err: %v", err) + } + wg.Done() + }(mTx, mTxLogger) + c.monitorTx(ctx, mTx, mTxLogger) + }(c, mTx) + } + wg.Wait() + + return nil +} + +// monitorTx does all the monitoring steps to the monitored tx +func (c *Client) monitorTx(ctx context.Context, mTx monitoredTx, logger *log.Logger) { + var err error + logger.Info("processing") + // check if any of the txs in the history was confirmed + var lastReceiptChecked types.Receipt + // monitored tx is confirmed until we find a successful receipt + confirmed := false + // monitored tx doesn't have a failed receipt until we find a failed receipt for any + // tx in the monitored tx history + hasFailedReceipts := false + // all history txs are considered mined until we can't find a receipt for any + // tx in the monitored tx history + allHistoryTxsWereMined := true + for txHash := range mTx.history { + mined, receipt, err := c.etherman.CheckTxWasMined(ctx, txHash) + if err != nil { + logger.Errorf("failed to check if tx %v was mined: %v", txHash.String(), err) + continue + } + + // if the tx is not mined yet, check that not all the tx were mined and go to the next + if !mined { + allHistoryTxsWereMined = false + continue + } + + lastReceiptChecked = *receipt + + // if the tx was mined successfully we can set it as confirmed and break the loop + if lastReceiptChecked.Status == types.ReceiptStatusSuccessful { + confirmed = true + break + } + + // if the tx was mined but failed, we continue to consider it was not confirmed + // and set that we have found a failed receipt. This info will be used later + // to check if nonce needs to be reviewed + confirmed = false + hasFailedReceipts = true + } + + // we need to check if we need to review the nonce carefully, to avoid sending + // duplicated data to the roll-up and causing an unnecessary trusted state reorg. + // + // if we have failed receipts, this means at least one of the generated txs was mined, + // in this case maybe the current nonce was already consumed(if this is the first iteration + // of this cycle, next iteration might have the nonce already updated by the preivous one), + // then we need to check if there are tx that were not mined yet, if so, we just need to wait + // because maybe one of them will get mined successfully + // + // in case of the monitored tx is not confirmed yet, all tx were mined and none of them were + // mined successfully, we need to review the nonce + if !confirmed && hasFailedReceipts && allHistoryTxsWereMined { + logger.Infof("nonce needs to be updated") + err := c.reviewMonitoredTxNonce(ctx, &mTx, logger) + if err != nil { + logger.Errorf("failed to review monitored tx nonce: %v", err) + return + } + err = c.storage.Update(ctx, mTx, nil) + if err != nil { + logger.Errorf("failed to update monitored tx nonce change: %v", err) + return + } + } + + // if the history size reaches the max history size, this means something is really wrong with + // this Tx and we are not able to identify automatically, so we mark this as failed to let the + // caller know something is not right and needs to be review and to avoid to monitor this + // tx infinitely + // if len(mTx.history) == maxHistorySize { + // mTx.status = MonitoredTxStatusFailed + // mTxLogger.Infof("marked as failed because reached the history size limit: %v", err) + // // update monitored tx changes into storage + // err = c.storage.Update(ctx, mTx, nil) + // if err != nil { + // mTxLogger.Errorf("failed to update monitored tx when max history size limit reached: %v", err) + // continue + // } + // } + + var signedTx *types.Transaction + if !confirmed { + // if is a reorged, move to the next + if mTx.status == MonitoredTxStatusReorged { + return + } + + // review tx and increase gas and gas price if needed + if mTx.status == MonitoredTxStatusSent { + err := c.reviewMonitoredTx(ctx, &mTx, logger) + if err != nil { + logger.Errorf("failed to review monitored tx: %v", err) + return + } + err = c.storage.Update(ctx, mTx, nil) + if err != nil { + logger.Errorf("failed to update monitored tx review change: %v", err) + return + } + } + + // rebuild transaction + tx := mTx.Tx() + logger.Debugf("unsigned tx %v created", tx.Hash().String()) + + // sign tx + signedTx, err = c.etherman.SignTx(ctx, mTx.from, tx) + if err != nil { + logger.Errorf("failed to sign tx %v: %v", tx.Hash().String(), err) + return + } + logger.Debugf("signed tx %v created", signedTx.Hash().String()) + + // add tx to monitored tx history + err = mTx.AddHistory(signedTx) + if errors.Is(err, ErrAlreadyExists) { + logger.Infof("signed tx already existed in the history") + } else if err != nil { + logger.Errorf("failed to add signed tx %v to monitored tx history: %v", signedTx.Hash().String(), err) + return + } else { + // update monitored tx changes into storage + err = c.storage.Update(ctx, mTx, nil) + if err != nil { + logger.Errorf("failed to update monitored tx: %v", err) + return + } + logger.Debugf("signed tx added to the monitored tx history") + } + + // check if the tx is already in the network, if not, send it + _, _, err = c.etherman.GetTx(ctx, signedTx.Hash()) + // if not found, send it tx to the network + if errors.Is(err, ethereum.NotFound) { + logger.Debugf("signed tx not found in the network") + err := c.etherman.SendTx(ctx, signedTx) + if err != nil { + logger.Errorf("failed to send tx %v to network: %v", signedTx.Hash().String(), err) + return + } + logger.Infof("signed tx sent to the network: %v", signedTx.Hash().String()) + if mTx.status == MonitoredTxStatusCreated { + // update tx status to sent + mTx.status = MonitoredTxStatusSent + logger.Debugf("status changed to %v", string(mTx.status)) + // update monitored tx changes into storage + err = c.storage.Update(ctx, mTx, nil) + if err != nil { + logger.Errorf("failed to update monitored tx changes: %v", err) + return + } + } + } else { + logger.Infof("signed tx already found in the network") + } + + log.Infof("waiting signedTx to be mined...") + + // wait tx to get mined + confirmed, err = c.etherman.WaitTxToBeMined(ctx, signedTx, c.cfg.WaitTxToBeMined.Duration) + if err != nil { + logger.Errorf("failed to wait tx to be mined: %v", err) + return + } + if !confirmed { + log.Infof("signedTx not mined yet and timeout has been reached") + return + } + + // get tx receipt + var txReceipt *types.Receipt + txReceipt, err = c.etherman.GetTxReceipt(ctx, signedTx.Hash()) + if err != nil { + logger.Errorf("failed to get tx receipt for tx %v: %v", signedTx.Hash().String(), err) + return + } + lastReceiptChecked = *txReceipt + } + + // if mined, check receipt and mark as Failed or Confirmed + if lastReceiptChecked.Status == types.ReceiptStatusSuccessful { + /* + receiptBlockNum := lastReceiptChecked.BlockNumber.Uint64() + // check if state is already synchronized until the block + // where the tx was mined + block, err := c.state.GetLastBlock(ctx, nil) + if errors.Is(err, state.ErrStateNotSynchronized) { + logger.Debugf("state not synchronized yet, waiting for L1 block %v to be synced", receiptBlockNum) + return + } else if err != nil { + logger.Errorf("failed to check if L1 block %v is already synced: %v", receiptBlockNum, err) + return + } else if block.BlockNumber < receiptBlockNum { + logger.Debugf("L1 block %v not synchronized yet, waiting for L1 block to be synced in order to confirm monitored tx", receiptBlockNum) + return + } else { + mTx.status = MonitoredTxStatusConfirmed + mTx.blockNumber = lastReceiptChecked.BlockNumber + logger.Info("confirmed") + } + */ + mTx.status = MonitoredTxStatusConfirmed + mTx.blockNumber = lastReceiptChecked.BlockNumber + logger.Info("confirmed") + } else { + // if we should continue to monitor, we move to the next one and this will + // be reviewed in the next monitoring cycle + if c.shouldContinueToMonitorThisTx(ctx, lastReceiptChecked) { + return + } + // otherwise we understand this monitored tx has failed + mTx.status = MonitoredTxStatusFailed + mTx.blockNumber = lastReceiptChecked.BlockNumber + logger.Info("failed") + } + + // update monitored tx changes into storage + err = c.storage.Update(ctx, mTx, nil) + if err != nil { + logger.Errorf("failed to update monitored tx: %v", err) + return + } +} + +// shouldContinueToMonitorThisTx checks the the tx receipt and decides if it should +// continue or not to monitor the monitored tx related to the tx from this receipt +func (c *Client) shouldContinueToMonitorThisTx(ctx context.Context, receipt types.Receipt) bool { + // if the receipt has a is successful result, stop monitoring + if receipt.Status == types.ReceiptStatusSuccessful { + return false + } + + tx, _, err := c.etherman.GetTx(ctx, receipt.TxHash) + if err != nil { + log.Errorf("failed to get tx when monitored tx identified as failed, tx : %v", receipt.TxHash.String(), err) + return false + } + _, err = c.etherman.GetRevertMessage(ctx, tx) + if err != nil { + // if the error when getting the revert message is not identified, continue to monitor + if err.Error() == ErrExecutionReverted.Error() { + return true + } else { + log.Errorf("failed to get revert message for monitored tx identified as failed, tx %v: %v", receipt.TxHash.String(), err) + } + } + // if nothing weird was found, stop monitoring + return false +} + +// reviewMonitoredTx checks if some field needs to be updated +// accordingly to the current information stored and the current +// state of the blockchain +func (c *Client) reviewMonitoredTx(ctx context.Context, mTx *monitoredTx, mTxLogger *log.Logger) error { + mTxLogger.Debug("reviewing") + // get gas + gas, err := c.etherman.EstimateGas(ctx, mTx.from, mTx.to, mTx.value, mTx.data) + if err != nil { + err := fmt.Errorf("failed to estimate gas: %w", err) + mTxLogger.Errorf(err.Error()) + return err + } + + // check gas + if gas > mTx.gas { + mTxLogger.Infof("monitored tx gas updated from %v to %v", mTx.gas, gas) + mTx.gas = gas + } + + // get gas price + gasPrice, err := c.suggestedGasPrice(ctx) + if err != nil { + err := fmt.Errorf("failed to get suggested gas price: %w", err) + mTxLogger.Errorf(err.Error()) + return err + } + + // check gas price + if gasPrice.Cmp(mTx.gasPrice) == 1 { + mTxLogger.Infof("monitored tx gas price updated from %v to %v", mTx.gasPrice.String(), gasPrice.String()) + mTx.gasPrice = gasPrice + } + return nil +} + +// reviewMonitoredTxNonce checks if the nonce needs to be updated accordingly to +// the current nonce of the sender account. +// +// IMPORTANT: Nonce is reviewed apart from the other fields because it is a very +// sensible information and can make duplicated data to be sent to the blockchain, +// causing possible side effects and wasting resources. +func (c *Client) reviewMonitoredTxNonce(ctx context.Context, mTx *monitoredTx, mTxLogger *log.Logger) error { + mTxLogger.Debug("reviewing nonce") + nonce, err := c.etherman.CurrentNonce(ctx, mTx.from) + if err != nil { + err := fmt.Errorf("failed to load current nonce for acc %v: %w", mTx.from.String(), err) + mTxLogger.Errorf(err.Error()) + return err + } + + if nonce > mTx.nonce { + mTxLogger.Infof("monitored tx nonce updated from %v to %v", mTx.nonce, nonce) + mTx.nonce = nonce + } + + return nil +} + +func (c *Client) suggestedGasPrice(ctx context.Context) (*big.Int, error) { + // get gas price + gasPrice, err := c.etherman.SuggestedGasPrice(ctx) + if err != nil { + return nil, err + } + + // adjust the gas price by the margin factor + marginFactor := big.NewFloat(0).SetFloat64(c.cfg.GasPriceMarginFactor) + fGasPrice := big.NewFloat(0).SetInt(gasPrice) + adjustedGasPrice, _ := big.NewFloat(0).Mul(fGasPrice, marginFactor).Int(big.NewInt(0)) + + // if there is a max gas price limit configured and the current + // adjusted gas price is over this limit, set the gas price as the limit + if c.cfg.MaxGasPriceLimit > 0 { + maxGasPrice := big.NewInt(0).SetUint64(c.cfg.MaxGasPriceLimit) + if adjustedGasPrice.Cmp(maxGasPrice) == 1 { + adjustedGasPrice.Set(maxGasPrice) + } + } + + return adjustedGasPrice, nil +} + +// logErrorAndWait used when an error is detected before trying again +func (c *Client) logErrorAndWait(msg string, err error) { + log.Errorf(msg, err) + time.Sleep(failureIntervalInSeconds * time.Second) +} + +// ResultHandler used by the caller to handle results +// when processing monitored txs +type ResultHandler func(MonitoredTxResult, pgx.Tx) + +// ProcessPendingMonitoredTxs will check all monitored txs of this owner +// and wait until all of them are either confirmed or failed before continuing +// +// for the confirmed and failed ones, the resultHandler will be triggered +func (c *Client) ProcessPendingMonitoredTxs(ctx context.Context, owner string, resultHandler ResultHandler, dbTx pgx.Tx) { + statusesFilter := []MonitoredTxStatus{ + MonitoredTxStatusCreated, + MonitoredTxStatusSent, + MonitoredTxStatusFailed, + MonitoredTxStatusConfirmed, + MonitoredTxStatusReorged, + } + // keep running until there are pending monitored txs + for { + results, err := c.ResultsByStatus(ctx, owner, statusesFilter, dbTx) + if err != nil { + // if something goes wrong here, we log, wait a bit and keep it in the infinite loop to not unlock the caller. + log.Errorf("failed to get results by statuses from eth tx manager to monitored txs err: ", err) + time.Sleep(time.Second) + continue + } + + if len(results) == 0 { + // if there are not pending monitored txs, stop + return + } + + for _, result := range results { + mTxResultLogger := CreateMonitoredTxResultLogger(owner, result) + + // if the result is confirmed, we set it as done do stop looking into this monitored tx + if result.Status == MonitoredTxStatusConfirmed { + err := c.setStatusDone(ctx, owner, result.ID, dbTx) + if err != nil { + mTxResultLogger.Errorf("failed to set monitored tx as done, err: %v", err) + // if something goes wrong at this point, we skip this result and move to the next. + // this result is going to be handled again in the next cycle by the outer loop. + continue + } else { + mTxResultLogger.Info("monitored tx confirmed") + } + resultHandler(result, dbTx) + continue + } + + // if the result is failed, we need to go around it and rebuild a batch verification + if result.Status == MonitoredTxStatusFailed { + resultHandler(result, dbTx) + continue + } + + // if the result is either not confirmed or failed, it means we need to wait until it gets confirmed of failed. + for { + // wait before refreshing the result info + time.Sleep(time.Second) + + // refresh the result info + result, err := c.Result(ctx, owner, result.ID, dbTx) + if err != nil { + mTxResultLogger.Errorf("failed to get monitored tx result, err: %v", err) + continue + } + + // if the result status is confirmed or failed, breaks the wait loop + if result.Status == MonitoredTxStatusConfirmed || result.Status == MonitoredTxStatusFailed { + break + } + + mTxResultLogger.Infof("waiting for monitored tx to get confirmed, status: %v", result.Status.String()) + } + } + } +} + +// createMonitoredTxLogger creates an instance of logger with all the important +// fields already set for a monitoredTx +func createMonitoredTxLogger(mTx monitoredTx) *log.Logger { + return log.WithFields( + "owner", mTx.owner, + "monitoredTxId", mTx.id, + "createdAt", mTx.createdAt, + "from", mTx.from, + "to", mTx.to, + ) +} + +// CreateLogger creates an instance of logger with all the important +// fields already set for a monitoredTx without requiring an instance of +// monitoredTx, this should be use in for callers before calling the ADD +// method +func CreateLogger(owner, monitoredTxId string, from common.Address, to *common.Address) *log.Logger { + return log.WithFields( + "owner", owner, + "monitoredTxId", monitoredTxId, + "from", from, + "to", to, + ) +} + +// CreateMonitoredTxResultLogger creates an instance of logger with all the important +// fields already set for a MonitoredTxResult +func CreateMonitoredTxResultLogger(owner string, mTxResult MonitoredTxResult) *log.Logger { + return log.WithFields( + "owner", owner, + "monitoredTxId", mTxResult.ID, + ) +} diff --git a/ethtxmanager/interfaces.go b/ethtxmanager/interfaces.go new file mode 100644 index 0000000..45e078d --- /dev/null +++ b/ethtxmanager/interfaces.go @@ -0,0 +1,32 @@ +package ethtxmanager + +import ( + "context" + "math/big" + "time" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/jackc/pgx/v4" +) + +type ethermanInterface interface { + GetTx(ctx context.Context, txHash common.Hash) (*types.Transaction, bool, error) + GetTxReceipt(ctx context.Context, txHash common.Hash) (*types.Receipt, error) + WaitTxToBeMined(ctx context.Context, tx *types.Transaction, timeout time.Duration) (bool, error) + SendTx(ctx context.Context, tx *types.Transaction) error + CurrentNonce(ctx context.Context, account common.Address) (uint64, error) + SuggestedGasPrice(ctx context.Context) (*big.Int, error) + EstimateGas(ctx context.Context, from common.Address, to *common.Address, value *big.Int, data []byte) (uint64, error) + CheckTxWasMined(ctx context.Context, txHash common.Hash) (bool, *types.Receipt, error) + SignTx(ctx context.Context, sender common.Address, tx *types.Transaction) (*types.Transaction, error) + GetRevertMessage(ctx context.Context, tx *types.Transaction) (string, error) +} + +type storageInterface interface { + Add(ctx context.Context, mTx monitoredTx, dbTx pgx.Tx) error + Get(ctx context.Context, owner, id string, dbTx pgx.Tx) (monitoredTx, error) + GetByStatus(ctx context.Context, owner *string, statuses []MonitoredTxStatus, dbTx pgx.Tx) ([]monitoredTx, error) + GetByBlock(ctx context.Context, fromBlock, toBlock *uint64, dbTx pgx.Tx) ([]monitoredTx, error) + Update(ctx context.Context, mTx monitoredTx, dbTx pgx.Tx) error +} diff --git a/ethtxmanager/monitoredtx.go b/ethtxmanager/monitoredtx.go new file mode 100644 index 0000000..7160307 --- /dev/null +++ b/ethtxmanager/monitoredtx.go @@ -0,0 +1,195 @@ +package ethtxmanager + +import ( + "encoding/hex" + "math/big" + "time" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +const ( + // MonitoredTxStatusCreated mean the tx was just added to the storage + MonitoredTxStatusCreated = MonitoredTxStatus("created") + + // MonitoredTxStatusSent means that at least a eth tx was sent to the network + MonitoredTxStatusSent = MonitoredTxStatus("sent") + + // MonitoredTxStatusFailed means the tx was already mined and failed with an + // error that can't be recovered automatically, ex: the data in the tx is invalid + // and the tx gets reverted + MonitoredTxStatusFailed = MonitoredTxStatus("failed") + + // MonitoredTxStatusConfirmed means the tx was already mined and the receipt + // status is Successful + MonitoredTxStatusConfirmed = MonitoredTxStatus("confirmed") + + // MonitoredTxStatusReorged is used when a monitored tx was already confirmed but + // the L1 block where this tx was confirmed has been reorged, in this situation + // the caller needs to review this information and wait until it gets confirmed + // again in a future block + MonitoredTxStatusReorged = MonitoredTxStatus("reorged") + + // MonitoredTxStatusDone means the tx was set by the owner as done + MonitoredTxStatusDone = MonitoredTxStatus("done") +) + +// MonitoredTxStatus represents the status of a monitored tx +type MonitoredTxStatus string + +// String returns a string representation of the status +func (s MonitoredTxStatus) String() string { + return string(s) +} + +// monitoredTx represents a set of information used to build tx +// plus information to monitor if the transactions was sent successfully +type monitoredTx struct { + // owner is the common identifier among all the monitored tx to identify who + // created this, it's a identification provided by the caller in order to be + // used in the future to query the monitored tx by the owner, this allows the + // caller to be free of implementing a persistence layer to monitor the txs + owner string + + // id is the tx identifier controller by the caller + id string + + // sender of the tx, used to identify which private key should be used to sing the tx + from common.Address + + // receiver of the tx + to *common.Address + + // nonce used to create the tx + nonce uint64 + + // tx value + value *big.Int + + // tx data + data []byte + + // tx gas + gas uint64 + + // tx gas offset + gasOffset uint64 + + // tx gas price + gasPrice *big.Int + + // status of this monitoring + status MonitoredTxStatus + + // blockNumber represents the block where the tx was identified + // to be mined, it's the same as the block number found in the + // tx receipt, this is used to control reorged monitored txs + blockNumber *big.Int + + // history represent all transaction hashes from + // transactions created using this struct data and + // sent to the network + history map[common.Hash]bool + + // createdAt date time it was created + createdAt time.Time + + // updatedAt last date time it was updated + updatedAt time.Time +} + +// Tx uses the current information to build a tx +func (mTx monitoredTx) Tx() *types.Transaction { + tx := types.NewTx(&types.LegacyTx{ + To: mTx.to, + Nonce: mTx.nonce, + Value: mTx.value, + Data: mTx.data, + Gas: mTx.gas + mTx.gasOffset, + GasPrice: mTx.gasPrice, + }) + + return tx +} + +// AddHistory adds a transaction to the monitoring history +func (mTx monitoredTx) AddHistory(tx *types.Transaction) error { + if _, found := mTx.history[tx.Hash()]; found { + return ErrAlreadyExists + } + mTx.history[tx.Hash()] = true + return nil +} + +// toStringPtr returns the current to field as a string pointer +func (mTx *monitoredTx) toStringPtr() *string { + var to *string + if mTx.to != nil { + s := mTx.to.String() + to = &s + } + return to +} + +// valueU64Ptr returns the current value field as a uint64 pointer +func (mTx *monitoredTx) valueU64Ptr() *uint64 { + var value *uint64 + if mTx.value != nil { + tmp := mTx.value.Uint64() + value = &tmp + } + return value +} + +// dataStringPtr returns the current data field as a string pointer +func (mTx *monitoredTx) dataStringPtr() *string { + var data *string + if mTx.data != nil { + tmp := hex.EncodeToString(mTx.data) + data = &tmp + } + return data +} + +// historyStringSlice returns the current history field as a string slice +func (mTx *monitoredTx) historyStringSlice() []string { + history := make([]string, 0, len(mTx.history)) + for h := range mTx.history { + history = append(history, h.String()) + } + return history +} + +// historyHashSlice returns the current history field as a string slice +func (mTx *monitoredTx) historyHashSlice() []common.Hash { + history := make([]common.Hash, 0, len(mTx.history)) + for h := range mTx.history { + history = append(history, h) + } + return history +} + +// blockNumberU64Ptr returns the current blockNumber as a uint64 pointer +func (mTx *monitoredTx) blockNumberU64Ptr() *uint64 { + var blockNumber *uint64 + if mTx.blockNumber != nil { + tmp := mTx.blockNumber.Uint64() + blockNumber = &tmp + } + return blockNumber +} + +// MonitoredTxResult represents the result of a execution of a monitored tx +type MonitoredTxResult struct { + ID string + Status MonitoredTxStatus + Txs map[common.Hash]TxResult +} + +// TxResult represents the result of a execution of a ethereum transaction in the block chain +type TxResult struct { + Tx *types.Transaction + Receipt *types.Receipt + RevertMessage string +} diff --git a/ethtxmanager/monitoredtx_test.go b/ethtxmanager/monitoredtx_test.go new file mode 100644 index 0000000..8e973aa --- /dev/null +++ b/ethtxmanager/monitoredtx_test.go @@ -0,0 +1,38 @@ +package ethtxmanager + +import ( + "math/big" + "testing" + + "github.com/ethereum/go-ethereum/common" + "github.com/stretchr/testify/assert" +) + +func TestTx(t *testing.T) { + to := common.HexToAddress("0x2") + nonce := uint64(1) + value := big.NewInt(2) + data := []byte("data") + gas := uint64(3) + gasOffset := uint64(4) + gasPrice := big.NewInt(5) + + mTx := monitoredTx{ + to: &to, + nonce: nonce, + value: value, + data: data, + gas: gas, + gasOffset: gasOffset, + gasPrice: gasPrice, + } + + tx := mTx.Tx() + + assert.Equal(t, &to, tx.To()) + assert.Equal(t, nonce, tx.Nonce()) + assert.Equal(t, value, tx.Value()) + assert.Equal(t, data, tx.Data()) + assert.Equal(t, gas+gasOffset, tx.Gas()) + assert.Equal(t, gasPrice, tx.GasPrice()) +} diff --git a/ethtxmanager/pgstorage.go b/ethtxmanager/pgstorage.go new file mode 100644 index 0000000..c955ffd --- /dev/null +++ b/ethtxmanager/pgstorage.go @@ -0,0 +1,278 @@ +package ethtxmanager + +import ( + "context" + "encoding/hex" + "errors" + "math/big" + "time" + + "github.com/0xPolygonHermez/zkevm-ethtx-manager/db" + "github.com/ethereum/go-ethereum/common" + "github.com/jackc/pgconn" + "github.com/jackc/pgx/v4" + "github.com/jackc/pgx/v4/pgxpool" +) + +// PostgresStorage hold txs to be managed +type PostgresStorage struct { + *pgxpool.Pool +} + +// NewPostgresStorage creates a new instance of storage that use +// postgres to store data +func NewPostgresStorage(dbCfg db.Config) (*PostgresStorage, error) { + db, err := db.NewSQLDB(dbCfg) + if err != nil { + return nil, err + } + + return &PostgresStorage{ + db, + }, nil +} + +// Add persist a monitored tx +func (s *PostgresStorage) Add(ctx context.Context, mTx monitoredTx, dbTx pgx.Tx) error { + conn := s.dbConn(dbTx) + cmd := ` + INSERT INTO ethtxmgr.monitored_txs (owner, id, from_addr, to_addr, nonce, value, data, gas, gas_offset, gas_price, status, block_num, history, created_at, updated_at) + VALUES ( $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15)` + + _, err := conn.Exec(ctx, cmd, mTx.owner, + mTx.id, mTx.from.String(), mTx.toStringPtr(), + mTx.nonce, mTx.valueU64Ptr(), mTx.dataStringPtr(), + mTx.gas, mTx.gasOffset, mTx.gasPrice.Uint64(), string(mTx.status), mTx.blockNumberU64Ptr(), + mTx.historyStringSlice(), time.Now().UTC().Round(time.Microsecond), + time.Now().UTC().Round(time.Microsecond)) + + if err != nil { + if pgErr, ok := err.(*pgconn.PgError); ok && pgErr.ConstraintName == "monitored_txs_pkey" { + return ErrAlreadyExists + } else { + return err + } + } + + return nil +} + +// Get loads a persisted monitored tx +func (s *PostgresStorage) Get(ctx context.Context, owner, id string, dbTx pgx.Tx) (monitoredTx, error) { + conn := s.dbConn(dbTx) + cmd := ` + SELECT owner, id, from_addr, to_addr, nonce, value, data, gas, gas_offset, gas_price, status, block_num, history, created_at, updated_at + FROM ethtxmgr.monitored_txs + WHERE owner = $1 + AND id = $2` + + mTx := monitoredTx{} + + row := conn.QueryRow(ctx, cmd, owner, id) + err := s.scanMtx(row, &mTx) + if errors.Is(err, pgx.ErrNoRows) { + return mTx, ErrNotFound + } else if err != nil { + return mTx, err + } + + return mTx, nil +} + +// GetByStatus loads all monitored tx that match the provided status +func (s *PostgresStorage) GetByStatus(ctx context.Context, owner *string, statuses []MonitoredTxStatus, dbTx pgx.Tx) ([]monitoredTx, error) { + hasStatusToFilter := len(statuses) > 0 + + conn := s.dbConn(dbTx) + cmd := ` + SELECT owner, id, from_addr, to_addr, nonce, value, data, gas, gas_offset, gas_price, status, block_num, history, created_at, updated_at + FROM ethtxmgr.monitored_txs + WHERE (owner = $1 OR $1 IS NULL)` + if hasStatusToFilter { + cmd += ` + AND status = ANY($2)` + } + cmd += ` + ORDER BY created_at` + + mTxs := []monitoredTx{} + + var rows pgx.Rows + var err error + if hasStatusToFilter { + rows, err = conn.Query(ctx, cmd, owner, statuses) + } else { + rows, err = conn.Query(ctx, cmd, owner) + } + + if errors.Is(err, pgx.ErrNoRows) { + return []monitoredTx{}, nil + } else if err != nil { + return nil, err + } + + for rows.Next() { + mTx := monitoredTx{} + err := s.scanMtx(rows, &mTx) + if err != nil { + return nil, err + } + mTxs = append(mTxs, mTx) + } + + return mTxs, nil +} + +// GetByBlock loads all monitored tx that have the blockNumber between +// fromBlock and toBlock +func (s *PostgresStorage) GetByBlock(ctx context.Context, fromBlock, toBlock *uint64, dbTx pgx.Tx) ([]monitoredTx, error) { + conn := s.dbConn(dbTx) + cmd := ` + SELECT owner, id, from_addr, to_addr, nonce, value, data, gas, gas_offset, gas_price, status, block_num, history, created_at, updated_at + FROM ethtxmgr.monitored_txs + WHERE (block_num >= $1 OR $1 IS NULL) + AND (block_num <= $2 OR $2 IS NULL) + AND block_num IS NOT NULL + ORDER BY created_at` + + const numberOfArgs = 2 + args := make([]interface{}, 0, numberOfArgs) + + if fromBlock != nil { + args = append(args, *fromBlock) + } else { + args = append(args, fromBlock) + } + + if toBlock != nil { + args = append(args, *toBlock) + } else { + args = append(args, toBlock) + } + + mTxs := []monitoredTx{} + rows, err := conn.Query(ctx, cmd, args...) + + if errors.Is(err, pgx.ErrNoRows) { + return []monitoredTx{}, nil + } else if err != nil { + return nil, err + } + + for rows.Next() { + mTx := monitoredTx{} + err := s.scanMtx(rows, &mTx) + if err != nil { + return nil, err + } + mTxs = append(mTxs, mTx) + } + + return mTxs, nil +} + +// Update a persisted monitored tx +func (s *PostgresStorage) Update(ctx context.Context, mTx monitoredTx, dbTx pgx.Tx) error { + conn := s.dbConn(dbTx) + cmd := ` + UPDATE ethtxmgr.monitored_txs + SET from_addr = $3 + , to_addr = $4 + , nonce = $5 + , value = $6 + , data = $7 + , gas = $8 + , gas_offset = $9 + , gas_price = $10 + , status = $11 + , block_num = $12 + , history = $13 + , updated_at = $14 + WHERE owner = $1 + AND id = $2` + + var bn *uint64 + if mTx.blockNumber != nil { + tmp := mTx.blockNumber.Uint64() + bn = &tmp + } + + _, err := conn.Exec(ctx, cmd, mTx.owner, + mTx.id, mTx.from.String(), mTx.toStringPtr(), + mTx.nonce, mTx.valueU64Ptr(), mTx.dataStringPtr(), + mTx.gas, mTx.gasOffset, mTx.gasPrice.Uint64(), string(mTx.status), bn, + mTx.historyStringSlice(), time.Now().UTC().Round(time.Microsecond)) + + if err != nil { + return err + } + + return nil +} + +// scanMtx scans a row and fill the provided instance of monitoredTx with +// the row data +func (s *PostgresStorage) scanMtx(row pgx.Row, mTx *monitoredTx) error { + // id, from, to, nonce, value, data, gas, gas_offset, gas_price, status, history, created_at, updated_at + var from, status string + var to, data *string + var history []string + var value, blockNumber *uint64 + var gasPrice uint64 + + err := row.Scan(&mTx.owner, &mTx.id, &from, &to, &mTx.nonce, &value, + &data, &mTx.gas, &mTx.gasOffset, &gasPrice, &status, &blockNumber, &history, + &mTx.createdAt, &mTx.updatedAt) + if err != nil { + return err + } + + mTx.from = common.HexToAddress(from) + mTx.gasPrice = big.NewInt(0).SetUint64(gasPrice) + mTx.status = MonitoredTxStatus(status) + + if to != nil { + tmp := common.HexToAddress(*to) + mTx.to = &tmp + } + if value != nil { + tmp := *value + mTx.value = big.NewInt(0).SetUint64(tmp) + } + if data != nil { + tmp := *data + bytes, err := hex.DecodeString(tmp) + if err != nil { + return err + } + mTx.data = bytes + } + if blockNumber != nil { + tmp := *blockNumber + mTx.blockNumber = big.NewInt(0).SetUint64(tmp) + } + + h := make(map[common.Hash]bool, len(history)) + for _, txHash := range history { + h[common.HexToHash(txHash)] = true + } + mTx.history = h + + return nil +} + +// dbConn represents an instance of an object that can +// connect to a postgres db to execute sql commands and query data +type dbConn interface { + Exec(ctx context.Context, sql string, arguments ...interface{}) (commandTag pgconn.CommandTag, err error) + Query(ctx context.Context, sql string, args ...interface{}) (pgx.Rows, error) + QueryRow(ctx context.Context, sql string, args ...interface{}) pgx.Row +} + +// dbConn determines which db connection to use, dbTx or the main pgxpool +func (p *PostgresStorage) dbConn(dbTx pgx.Tx) dbConn { + if dbTx != nil { + return dbTx + } + return p +} diff --git a/go.mod b/go.mod new file mode 100644 index 0000000..45fdd1a --- /dev/null +++ b/go.mod @@ -0,0 +1,123 @@ +module github.com/0xPolygonHermez/zkevm-ethtx-manager + +go 1.21 + +require ( + github.com/ethereum/go-ethereum v1.13.8 + github.com/gobuffalo/packr/v2 v2.8.3 + github.com/hermeznetwork/tracerr v0.3.2 + github.com/invopop/jsonschema v0.12.0 + github.com/jackc/pgconn v1.14.1 + github.com/jackc/pgx/v4 v4.18.1 + github.com/mitchellh/mapstructure v1.5.0 + github.com/prometheus/client_golang v1.17.0 + github.com/prometheus/client_model v0.5.0 + github.com/rubenv/sql-migrate v1.5.2 + github.com/spf13/viper v1.17.0 + github.com/stretchr/testify v1.8.4 + github.com/urfave/cli/v2 v2.25.7 + go.uber.org/zap v1.26.0 + golang.org/x/crypto v0.17.0 + google.golang.org/grpc v1.59.0 + google.golang.org/protobuf v1.31.0 +) + +require ( + github.com/DataDog/zstd v1.5.2 // indirect + github.com/Microsoft/go-winio v0.6.1 // indirect + github.com/StackExchange/wmi v1.2.1 // indirect + github.com/VictoriaMetrics/fastcache v1.12.1 // indirect + github.com/bahlo/generic-list-go v0.2.0 // indirect + github.com/beorn7/perks v1.0.1 // indirect + github.com/bits-and-blooms/bitset v1.10.0 // indirect + github.com/btcsuite/btcd/btcec/v2 v2.3.2 // indirect + github.com/buger/jsonparser v1.1.1 // indirect + github.com/cespare/xxhash/v2 v2.2.0 // indirect + github.com/cockroachdb/errors v1.9.1 // indirect + github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b // indirect + github.com/cockroachdb/pebble v0.0.0-20230928194634-aa077af62593 // indirect + github.com/cockroachdb/redact v1.1.3 // indirect + github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06 // indirect + github.com/consensys/bavard v0.1.13 // indirect + github.com/consensys/gnark-crypto v0.12.1 // indirect + github.com/cpuguy83/go-md2man/v2 v2.0.2 // indirect + github.com/crate-crypto/go-ipa v0.0.0-20231025140028-3c0104f4b233 // indirect + github.com/crate-crypto/go-kzg-4844 v0.7.0 // indirect + github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect + github.com/deckarep/golang-set/v2 v2.1.0 // indirect + github.com/decred/dcrd/dcrec/secp256k1/v4 v4.1.0 // indirect + github.com/ethereum/c-kzg-4844 v0.4.0 // indirect + github.com/fsnotify/fsnotify v1.6.0 // indirect + github.com/gballet/go-verkle v0.1.1-0.20231031103413-a67434b50f46 // indirect + github.com/getsentry/sentry-go v0.18.0 // indirect + github.com/go-gorp/gorp/v3 v3.1.0 // indirect + github.com/go-ole/go-ole v1.2.6 // indirect + github.com/gobuffalo/logger v1.0.7 // indirect + github.com/gobuffalo/packd v1.0.2 // indirect + github.com/gofrs/flock v0.8.1 // indirect + github.com/gogo/protobuf v1.3.2 // indirect + github.com/golang/protobuf v1.5.3 // indirect + github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb // indirect + github.com/google/uuid v1.4.0 // indirect + github.com/gorilla/websocket v1.5.1 // indirect + github.com/hashicorp/hcl v1.0.0 // indirect + github.com/holiman/bloomfilter/v2 v2.0.3 // indirect + github.com/holiman/uint256 v1.2.4 // indirect + github.com/jackc/chunkreader/v2 v2.0.1 // indirect + github.com/jackc/pgio v1.0.0 // indirect + github.com/jackc/pgpassfile v1.0.0 // indirect + github.com/jackc/pgproto3/v2 v2.3.2 // indirect + github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a // indirect + github.com/jackc/pgtype v1.14.0 // indirect + github.com/jackc/puddle v1.3.0 // indirect + github.com/karrick/godirwalk v1.17.0 // indirect + github.com/klauspost/compress v1.17.0 // indirect + github.com/kr/pretty v0.3.1 // indirect + github.com/kr/text v0.2.0 // indirect + github.com/logrusorgru/aurora v0.0.0-20181002194514-a7b3b318ed4e // indirect + github.com/magiconair/properties v1.8.7 // indirect + github.com/mailru/easyjson v0.7.7 // indirect + github.com/markbates/errx v1.1.0 // indirect + github.com/markbates/oncer v1.0.0 // indirect + github.com/markbates/safe v1.0.1 // indirect + github.com/mattn/go-runewidth v0.0.13 // indirect + github.com/matttproud/golang_protobuf_extensions/v2 v2.0.0 // indirect + github.com/mmcloughlin/addchain v0.4.0 // indirect + github.com/olekukonko/tablewriter v0.0.5 // indirect + github.com/pelletier/go-toml/v2 v2.1.0 // indirect + github.com/pkg/errors v0.9.1 // indirect + github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect + github.com/prometheus/common v0.45.0 // indirect + github.com/prometheus/procfs v0.11.1 // indirect + github.com/rivo/uniseg v0.2.0 // indirect + github.com/rogpeppe/go-internal v1.11.0 // indirect + github.com/russross/blackfriday/v2 v2.1.0 // indirect + github.com/sagikazarmark/locafero v0.3.0 // indirect + github.com/sagikazarmark/slog-shim v0.1.0 // indirect + github.com/shirou/gopsutil v3.21.4-0.20210419000835-c7a38de76ee5+incompatible // indirect + github.com/sirupsen/logrus v1.9.0 // indirect + github.com/sourcegraph/conc v0.3.0 // indirect + github.com/spf13/afero v1.10.0 // indirect + github.com/spf13/cast v1.5.1 // indirect + github.com/spf13/pflag v1.0.5 // indirect + github.com/subosito/gotenv v1.6.0 // indirect + github.com/supranational/blst v0.3.11 // indirect + github.com/syndtr/goleveldb v1.0.1-0.20220614013038-64ee5596c38a // indirect + github.com/tklauser/go-sysconf v0.3.12 // indirect + github.com/tklauser/numcpus v0.6.1 // indirect + github.com/wk8/go-ordered-map/v2 v2.1.8 // indirect + github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 // indirect + go.uber.org/multierr v1.10.0 // indirect + golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa // indirect + golang.org/x/mod v0.14.0 // indirect + golang.org/x/net v0.18.0 // indirect + golang.org/x/sync v0.5.0 // indirect + golang.org/x/sys v0.15.0 // indirect + golang.org/x/term v0.15.0 // indirect + golang.org/x/text v0.14.0 // indirect + golang.org/x/tools v0.15.0 // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20230920204549-e6e6cdab5c13 // indirect + gopkg.in/ini.v1 v1.67.0 // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect + rsc.io/tmplfunc v0.0.3 // indirect +) diff --git a/go.sum b/go.sum new file mode 100644 index 0000000..a647042 --- /dev/null +++ b/go.sum @@ -0,0 +1,1196 @@ +cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= +cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= +cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU= +cloud.google.com/go v0.44.1/go.mod h1:iSa0KzasP4Uvy3f1mN/7PiObzGgflwredwwASm/v6AU= +cloud.google.com/go v0.44.2/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY= +cloud.google.com/go v0.44.3/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY= +cloud.google.com/go v0.45.1/go.mod h1:RpBamKRgapWJb87xiFSdk4g1CME7QZg3uwTez+TSTjc= +cloud.google.com/go v0.46.3/go.mod h1:a6bKKbmY7er1mI7TEI4lsAkts/mkhTSZK8w33B4RAg0= +cloud.google.com/go v0.50.0/go.mod h1:r9sluTvynVuxRIOHXQEHMFffphuXHOMZMycpNR5e6To= +cloud.google.com/go v0.52.0/go.mod h1:pXajvRH/6o3+F9jDHZWQ5PbGhn+o8w9qiu/CffaVdO4= +cloud.google.com/go v0.53.0/go.mod h1:fp/UouUEsRkN6ryDKNW/Upv/JBKnv6WDthjR6+vze6M= +cloud.google.com/go v0.54.0/go.mod h1:1rq2OEkV3YMf6n/9ZvGWI3GWw0VoqH/1x2nd8Is/bPc= +cloud.google.com/go v0.56.0/go.mod h1:jr7tqZxxKOVYizybht9+26Z/gUq7tiRzu+ACVAMbKVk= +cloud.google.com/go v0.57.0/go.mod h1:oXiQ6Rzq3RAkkY7N6t3TcE6jE+CIBBbA36lwQ1JyzZs= +cloud.google.com/go v0.62.0/go.mod h1:jmCYTdRCQuc1PHIIJ/maLInMho30T/Y0M4hTdTShOYc= +cloud.google.com/go v0.65.0/go.mod h1:O5N8zS7uWy9vkA9vayVHs65eM1ubvY4h553ofrNHObY= +cloud.google.com/go v0.72.0/go.mod h1:M+5Vjvlc2wnp6tjzE102Dw08nGShTscUx2nZMufOKPI= +cloud.google.com/go v0.74.0/go.mod h1:VV1xSbzvo+9QJOxLDaJfTjx5e+MePCpCWwvftOeQmWk= +cloud.google.com/go v0.75.0/go.mod h1:VGuuCn7PG0dwsd5XPVm2Mm3wlh3EL55/79EKB6hlPTY= +cloud.google.com/go v0.78.0/go.mod h1:QjdrLG0uq+YwhjoVOLsS1t7TW8fs36kLs4XO5R5ECHg= +cloud.google.com/go v0.79.0/go.mod h1:3bzgcEeQlzbuEAYu4mrWhKqWjmpprinYgKJLgKHnbb8= +cloud.google.com/go v0.81.0/go.mod h1:mk/AM35KwGk/Nm2YSeZbxXdrNK3KZOYHmLkOqC2V6E0= +cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o= +cloud.google.com/go/bigquery v1.3.0/go.mod h1:PjpwJnslEMmckchkHFfq+HTD2DmtT67aNFKH1/VBDHE= +cloud.google.com/go/bigquery v1.4.0/go.mod h1:S8dzgnTigyfTmLBfrtrhyYhwRxG72rYxvftPBK2Dvzc= +cloud.google.com/go/bigquery v1.5.0/go.mod h1:snEHRnqQbz117VIFhE8bmtwIDY80NLUZUMb4Nv6dBIg= +cloud.google.com/go/bigquery v1.7.0/go.mod h1://okPTzCYNXSlb24MZs83e2Do+h+VXtc4gLoIoXIAPc= +cloud.google.com/go/bigquery v1.8.0/go.mod h1:J5hqkt3O0uAFnINi6JXValWIb1v0goeZM77hZzJN/fQ= +cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE= +cloud.google.com/go/datastore v1.1.0/go.mod h1:umbIZjpQpHh4hmRpGhH4tLFup+FVzqBi1b3c64qFpCk= +cloud.google.com/go/firestore v1.1.0/go.mod h1:ulACoGHTpvq5r8rxGJ4ddJZBZqakUQqClKRT5SZwBmk= +cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I= +cloud.google.com/go/pubsub v1.1.0/go.mod h1:EwwdRX2sKPjnvnqCa270oGRyludottCI76h+R3AArQw= +cloud.google.com/go/pubsub v1.2.0/go.mod h1:jhfEVHT8odbXTkndysNHCcx0awwzvfOlguIAii9o8iA= +cloud.google.com/go/pubsub v1.3.1/go.mod h1:i+ucay31+CNRpDW4Lu78I4xXG+O1r/MAHgjpRVR+TSU= +cloud.google.com/go/storage v1.0.0/go.mod h1:IhtSnM/ZTZV8YYJWCY8RULGVqBDmpoyjwiyrjsg+URw= +cloud.google.com/go/storage v1.5.0/go.mod h1:tpKbwo567HUNpVclU5sGELwQWBDZ8gh0ZeosJ0Rtdos= +cloud.google.com/go/storage v1.6.0/go.mod h1:N7U0C8pVQ/+NIKOBQyamJIeKQKkZ+mxpohlUTyfDhBk= +cloud.google.com/go/storage v1.8.0/go.mod h1:Wv1Oy7z6Yz3DshWRJFhqM/UCfaWIRTdp0RXyy7KQOVs= +cloud.google.com/go/storage v1.10.0/go.mod h1:FLPqc6j+Ki4BU591ie1oL6qBQGu2Bl/tZ9ullr3+Kg0= +cloud.google.com/go/storage v1.14.0/go.mod h1:GrKmX003DSIwi9o29oFT7YDnHYwZoctc3fOKtUw0Xmo= +dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU= +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/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo= +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/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/go.mod h1:8x5n+M1Hp5hC0g8okX3sR3vFQwynaX/UgSOM9MeBKzY= +github.com/Masterminds/semver/v3 v3.1.1/go.mod h1:VPu/7SZ7ePZ3QOrcuXROw5FAcLl4a0cBrbBpGY/8hQs= +github.com/Masterminds/semver/v3 v3.2.0 h1:3MEsd0SM6jqZojhjLWWeBY+Kcjy9i6MQAeY7YgDP83g= +github.com/Masterminds/semver/v3 v3.2.0/go.mod h1:qvl/7zhW3nngYb5+80sSMF+FG2BjYrf8m9wsX0PNOMQ= +github.com/Microsoft/go-winio v0.6.1 h1:9/kr64B9VUZrLm5YYwbGtUJnMgqWVOdUAXu6Migciow= +github.com/Microsoft/go-winio v0.6.1/go.mod h1:LRdKpFKfdobln8UmuiYcKPot9D2v6svN5+sAH+4kjUM= +github.com/Shopify/goreferrer v0.0.0-20181106222321-ec9c9a553398/go.mod h1:a1uqRtAwp2Xwc6WNPJEufxJ7fx3npB4UV/JOLmbu5I0= +github.com/StackExchange/wmi v1.2.1 h1:VIkavFPXSjcnS+O8yTq7NI32k0R5Aj+v39y29VYDOSA= +github.com/StackExchange/wmi v1.2.1/go.mod h1:rcmrprowKIVzvc+NUiLncP2uuArMWLCbu9SBzvHz7e8= +github.com/VictoriaMetrics/fastcache v1.12.1 h1:i0mICQuojGDL3KblA7wUNlY5lOK6a4bwt3uRKnkZU40= +github.com/VictoriaMetrics/fastcache v1.12.1/go.mod h1:tX04vaqcNoQeGLD+ra5pU5sWkuxnzWhEzLwhP9w653o= +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/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY= +github.com/armon/circbuf v0.0.0-20150827004946-bbbad097214e/go.mod h1:3U/XgcO3hCbHZ8TKRvWD2dDTCfh9M9ya+I9JpbB7O8o= +github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8= +github.com/armon/go-metrics v0.0.0-20180917152333-f0300d1749da/go.mod h1:Q73ZrmVTwzkszR9V5SSuryQ31EELlFMUz1kKyl939pY= +github.com/armon/go-radix v0.0.0-20180808171621-7fddfc383310/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8= +github.com/aymerick/raymond v2.0.3-0.20180322193309-b565731e1464+incompatible/go.mod h1:osfaiScAUVup+UC9Nfq76eWqDhXlp+4UYaA8uhTBO6g= +github.com/bahlo/generic-list-go v0.2.0 h1:5sz/EEAK+ls5wF+NeqDpk5+iNdMDXrh3z3nPnH1Wvgk= +github.com/bahlo/generic-list-go v0.2.0/go.mod h1:2KvAjgMlE5NNynlg/5iLrrCCZ2+5xWbdbCW3pNTGyYg= +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/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs= +github.com/bits-and-blooms/bitset v1.10.0 h1:ePXTeiPEazB5+opbv5fr8umg2R/1NlzgDsyepwsSr88= +github.com/bits-and-blooms/bitset v1.10.0/go.mod h1:7hO7Gc7Pp1vODcmWvKMRA9BNmbv6a/7QIWpPxHddWR8= +github.com/bketelsen/crypt v0.0.4/go.mod h1:aI6NrJ0pMGgvZKL1iVgXLnfIFJtfV+bKCoqOes/6LfM= +github.com/btcsuite/btcd/btcec/v2 v2.3.2 h1:5n0X6hX0Zk+6omWcihdYvdAlGf2DfasC0GMf7DClJ3U= +github.com/btcsuite/btcd/btcec/v2 v2.3.2/go.mod h1:zYzJ8etWJQIv1Ogk7OzpWjowwOdXY1W/17j2MW85J04= +github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1 h1:q0rUy8C/TYNBQS1+CGKw68tLOFYSNEs0TFnxxnS9+4U= +github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1/go.mod h1:7SFka0XMvUgj3hfZtydOrQY2mwhPclbT2snogU7SQQc= +github.com/buger/jsonparser v1.1.1 h1:2PnMjfWD7wBILjqQbt530v576A/cAbQvEW9gGIpYMUs= +github.com/buger/jsonparser v1.1.1/go.mod h1:6RYKKt7H4d4+iWqouImQ9R2FZql3VbhNgx27UK13J/0= +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/cp v0.1.0/go.mod h1:SOGHArjBr4JWaSDEVpWpo/hNg6RoKrls6Oh40hiwW+s= +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/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI= +github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI= +github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU= +github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw= +github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc= +github.com/cncf/udpa/go v0.0.0-20200629203442-efcf912fb354/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk= +github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk= +github.com/cockroachdb/apd v1.1.0 h1:3LFP3629v+1aKXU5Q37mxmRxX/pIu1nijXydLShEq5I= +github.com/cockroachdb/apd v1.1.0/go.mod h1:8Sl8LxpKi29FqWXR16WEFZRNSz3SoPzUzeMeY4+DwBQ= +github.com/cockroachdb/datadriven v1.0.2/go.mod h1:a9RdTaap04u637JoCzcUoIcDmvwSUtcUFtT/C3kJlTU= +github.com/cockroachdb/datadriven v1.0.3-0.20230413201302-be42291fc80f h1:otljaYPt5hWxV3MUfO5dFPFiOXg9CyG5/kCfayTqsJ4= +github.com/cockroachdb/datadriven v1.0.3-0.20230413201302-be42291fc80f/go.mod h1:a9RdTaap04u637JoCzcUoIcDmvwSUtcUFtT/C3kJlTU= +github.com/cockroachdb/errors v1.9.1 h1:yFVvsI0VxmRShfawbt/laCIDy/mtTqqnvoNgiy5bEV8= +github.com/cockroachdb/errors v1.9.1/go.mod h1:2sxOtL2WIc096WSZqZ5h8fa17rdDq9HZOZLBCor4mBk= +github.com/cockroachdb/logtags v0.0.0-20211118104740-dabe8e521a4f/go.mod h1:Vz9DsVWQQhf3vs21MhPMZpMGSht7O/2vFW2xusFUVOs= +github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b h1:r6VH0faHjZeQy818SGhaone5OnYfxFR/+AzdY3sf5aE= +github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b/go.mod h1:Vz9DsVWQQhf3vs21MhPMZpMGSht7O/2vFW2xusFUVOs= +github.com/cockroachdb/pebble v0.0.0-20230928194634-aa077af62593 h1:aPEJyR4rPBvDmeyi+l/FS/VtA00IWvjeFvjen1m1l1A= +github.com/cockroachdb/pebble v0.0.0-20230928194634-aa077af62593/go.mod h1:6hk1eMY/u5t+Cf18q5lFMUA1Rc+Sm5I6Ra1QuPyxXCo= +github.com/cockroachdb/redact v1.1.3 h1:AKZds10rFSIj7qADf0g46UixK8NNLwWTNdCIGS5wfSQ= +github.com/cockroachdb/redact v1.1.3/go.mod h1:BVNblN9mBWFyMyqK1k3AAiSxhvhfK2oOZZ2lK+dpvRg= +github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06 h1:zuQyyAKVxetITBuuhv3BI9cMrmStnpT18zmgmTxunpo= +github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06/go.mod h1:7nc4anLGjupUW/PeY5qiNYsdNXj7zopG+eqsS7To5IQ= +github.com/codegangsta/inject v0.0.0-20150114235600-33e0aa1cb7c0/go.mod h1:4Zcjuz89kmFXt9morQgcfYZAYZ5n8WHjt81YYWIwtTM= +github.com/consensys/bavard v0.1.13 h1:oLhMLOFGTLdlda/kma4VOJazblc7IM5y5QPd2A/YjhQ= +github.com/consensys/bavard v0.1.13/go.mod h1:9ItSMtA/dXMAiL7BG6bqW2m3NdSEObYWoH223nGHukI= +github.com/consensys/gnark-crypto v0.12.1 h1:lHH39WuuFgVHONRl3J0LRBtuYdQTumFSDtJF7HpyG8M= +github.com/consensys/gnark-crypto v0.12.1/go.mod h1:v2Gy7L/4ZRosZ7Ivs+9SfUDr0f5UlG+EM5t7MPHiLuY= +github.com/coreos/etcd v3.3.10+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE= +github.com/coreos/go-etcd v2.0.0+incompatible/go.mod h1:Jez6KQU2B/sWsbdaef3ED8NzMklzPG4d5KIOhIy30Tk= +github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk= +github.com/coreos/go-semver v0.3.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk= +github.com/coreos/go-systemd v0.0.0-20190321100706-95778dfbb74e/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4= +github.com/coreos/go-systemd v0.0.0-20190719114852-fd7a80b32e1f/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4= +github.com/coreos/go-systemd/v22 v22.3.2/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc= +github.com/cpuguy83/go-md2man v1.0.10/go.mod h1:SmD6nW6nTyfqj6ABTjUi3V3JVMnlJmwcJI5acqYI6dE= +github.com/cpuguy83/go-md2man/v2 v2.0.0/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU= +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-ipa v0.0.0-20231025140028-3c0104f4b233 h1:d28BXYi+wUpz1KBmiF9bWrjEMacUEREV6MBi2ODnrfQ= +github.com/crate-crypto/go-ipa v0.0.0-20231025140028-3c0104f4b233/go.mod h1:geZJZH3SzKCqnz5VT0q/DyIG/tvu/dZk+VIfXicupJs= +github.com/crate-crypto/go-kzg-4844 v0.7.0 h1:C0vgZRk4q4EZ/JgPfzuSoxdCq3C3mOZMBShovmncxvA= +github.com/crate-crypto/go-kzg-4844 v0.7.0/go.mod h1:1kMhvPgI0Ky3yIa+9lFySEBUBXkYxeOi8ZF1sYioxhc= +github.com/creack/pty v1.1.7/go.mod h1:lj5s0c3V2DBrqTV7llrYr5NG6My20zk30Fl46Y7DoTY= +github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= +github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/deckarep/golang-set/v2 v2.1.0 h1:g47V4Or+DUdzbs8FxCCmgb6VYd+ptPAngjM6dtGktsI= +github.com/deckarep/golang-set/v2 v2.1.0/go.mod h1:VAky9rY/yGXJOLEDv3OMci+7wtDpOF4IN+y82NBOac4= +github.com/decred/dcrd/crypto/blake256 v1.0.0 h1:/8DMNYp9SGi5f0w7uCm6d6M4OU2rGFK09Y2A4Xv7EE0= +github.com/decred/dcrd/crypto/blake256 v1.0.0/go.mod h1:sQl2p6Y26YV+ZOcSTP6thNdn47hh8kt6rqSlvmrXFAc= +github.com/decred/dcrd/dcrec/secp256k1/v4 v4.1.0 h1:HbphB4TFFXpv7MNrT52FGrrgVXF1owhMVTHFZIlnvd4= +github.com/decred/dcrd/dcrec/secp256k1/v4 v4.1.0/go.mod h1:DZGJHZMqrU4JJqFAWUS2UO1+lbSKsdiOoYi9Zzey7Fc= +github.com/dgraph-io/badger v1.6.0/go.mod h1:zwt7syl517jmP8s94KqSxTlM6IMsdhYy6psNgSztDR4= +github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw= +github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk= +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.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98= +github.com/envoyproxy/go-control-plane v0.9.7/go.mod h1:cwu0lG7PUMfa9snN8LXBig5ynNVH9qI8YYLbd1fK2po= +github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk= +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.4.0 h1:3MS1s4JtA868KpJxroZoepdV0ZKBp3u/O5HcZ7R3nlY= +github.com/ethereum/c-kzg-4844 v0.4.0/go.mod h1:VewdlzQmpT5QSrVhbBuGoCdFJkpaJlO1aQputP83wc0= +github.com/ethereum/go-ethereum v1.13.8 h1:1od+thJel3tM52ZUNQwvpYOeRHlbkVFZ5S8fhi0Lgsg= +github.com/ethereum/go-ethereum v1.13.8/go.mod h1:sc48XYQxCzH3fG9BcrXCOOgQk2JfZzNAmIKnceogzsA= +github.com/fasthttp-contrib/websocket v0.0.0-20160511215533-1f3b11f56072/go.mod h1:duJ4Jxv5lDcvg4QuQr0oowTf7dz4/CR8NtyCooz9HL8= +github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4= +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/frankban/quicktest v1.14.4 h1:g2rn0vABPOOXmZUj+vbmUp0lPoXEMuhTpIluN0XL9UY= +github.com/frankban/quicktest v1.14.4/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0= +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/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= +github.com/gballet/go-verkle v0.1.1-0.20231031103413-a67434b50f46 h1:BAIP2GihuqhwdILrV+7GJel5lyPV3u1+PgzrWLc0TkE= +github.com/gballet/go-verkle v0.1.1-0.20231031103413-a67434b50f46/go.mod h1:QNpY22eby74jVhqH4WhDLDwxc/vqsern6pW+u2kbkpc= +github.com/getsentry/sentry-go v0.12.0/go.mod h1:NSap0JBYWzHND8oMbyi0+XZhUalc1TBdRL1M71JZW2c= +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/sse v0.0.0-20190301062529-5545eab6dad3/go.mod h1:VJ0WA2NBN22VlZ2dKZQPAPnyWw5XTlK1KymzLKsr59s= +github.com/gin-gonic/gin v1.4.0/go.mod h1:OW2EZn3DO8Ln9oIKOvM++LBO+5UPHJJDH72/q/3rZdM= +github.com/go-check/check v0.0.0-20180628173108-788fd7840127/go.mod h1:9ES+weclKsC9YodN5RgxqK/VD9HM9JsCSh7rNhMZE98= +github.com/go-errors/errors v1.0.1/go.mod h1:f4zRHt4oKfwPJE5k8C9vpYG+aDHdBFUsgrm6/TyX73Q= +github.com/go-errors/errors v1.4.2 h1:J6MZopCL4uSllY1OfXM374weqZFFItUbrImctkmUxIA= +github.com/go-errors/errors v1.4.2/go.mod h1:sIVyrIiJhuEF+Pj9Ebtd6P/rEYROXFi3BopGUQ5a5Og= +github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU= +github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8= +github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8= +github.com/go-gorp/gorp/v3 v3.1.0 h1:ItKF/Vbuj31dmV4jxA1qblpSwkl9g1typ24xoe70IGs= +github.com/go-gorp/gorp/v3 v3.1.0/go.mod h1:dLEjIyyRNiXvNZ8PSmzpt1GsWAUK8kjVhEpjH8TixEw= +github.com/go-kit/log v0.1.0/go.mod h1:zbhenjAZHb184qTLMA9ZjW7ThYL0H2mk7Q6pNt4vbaY= +github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A= +github.com/go-martini/martini v0.0.0-20170121215854-22fa46961aab/go.mod h1:/P9AEU963A2AYjv4d1V5eVL1CQbEJq6aCNHDDjibzu8= +github.com/go-ole/go-ole v1.2.5/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0= +github.com/go-ole/go-ole v1.2.6 h1:/Fpf6oFPoeFik9ty7siob0G6Ke8QvQEuVcuChpwXzpY= +github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0= +github.com/go-sql-driver/mysql v1.6.0 h1:BCTh4TKNUYmOmMUcQ3IipzF5prigylS7XXjEkfCHuOE= +github.com/go-sql-driver/mysql v1.6.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg= +github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY= +github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0/go.mod h1:fyg7847qk6SyHyPtNmDHnmrv/HOrqktSC+C9fM+CJOE= +github.com/gobuffalo/logger v1.0.6/go.mod h1:J31TBEHR1QLV2683OXTAItYIg8pv2JMHnF/quuAbMjs= +github.com/gobuffalo/logger v1.0.7 h1:LTLwWelETXDYyqF/ASf0nxaIcdEOIJNxRokPcfI/xbU= +github.com/gobuffalo/logger v1.0.7/go.mod h1:u40u6Bq3VVvaMcy5sRBclD8SXhBYPS0Qk95ubt+1xJM= +github.com/gobuffalo/packd v1.0.1/go.mod h1:PP2POP3p3RXGz7Jh6eYEf93S7vA2za6xM7QT85L4+VY= +github.com/gobuffalo/packd v1.0.2 h1:Yg523YqnOxGIWCp69W12yYBKsoChwI7mtu6ceM9Bwfw= +github.com/gobuffalo/packd v1.0.2/go.mod h1:sUc61tDqGMXON80zpKGp92lDb86Km28jfvX7IAyxFT8= +github.com/gobuffalo/packr/v2 v2.8.3 h1:xE1yzvnO56cUC0sTpKR3DIbxZgB54AftTFMhB2XEWlY= +github.com/gobuffalo/packr/v2 v2.8.3/go.mod h1:0SahksCVcx4IMnigTjiFuyldmTrdTctXsOdiU5KwbKc= +github.com/gobwas/httphead v0.0.0-20180130184737-2c6c146eadee/go.mod h1:L0fX3K22YWvt/FAX9NnzrNzcI4wNYi9Yku4O0LKYflo= +github.com/gobwas/pool v0.2.0/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6WezmKEw= +github.com/gobwas/ws v1.0.2/go.mod h1:szmBTxLgaFppYjEmNtny/v3w89xOydFnnZMcgRRu/EM= +github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA= +github.com/gofrs/flock v0.8.1 h1:+gYjHKf32LDeiEEFhQaotPbLuUXjY5ZqxKgXy7n59aw= +github.com/gofrs/flock v0.8.1/go.mod h1:F1TvTiK9OcQqauNUHlbJvyl9Qa1QvF/gOUDKA14jxHU= +github.com/gofrs/uuid v4.0.0+incompatible h1:1SD/1F5pU8p29ybwgQSwpQk+mwdRrXCYuPhW6m+TnJw= +github.com/gofrs/uuid v4.0.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM= +github.com/gogo/googleapis v0.0.0-20180223154316-0cd9801be74a/go.mod h1:gf4bu3Q80BeJ6H1S1vYPm8/ELATdvryBaNFGgqEef3s= +github.com/gogo/googleapis v1.4.1/go.mod h1:2lpHqI5OcWCtVElxXnPt+s8oJvMpySlOyM6xDCrzib4= +github.com/gogo/protobuf v1.2.0/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ= +github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= +github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= +github.com/gogo/status v1.1.0/go.mod h1:BFv9nrluPLmrS0EmGVvLaPNmRosr9KapBYd5/hpY1WM= +github.com/golang-jwt/jwt v3.2.2+incompatible h1:IfV12K8xAKAnZqdXVzCZ+TOjboZ2keLg81eXfW3O+oY= +github.com/golang-jwt/jwt v3.2.2+incompatible/go.mod h1:8pz2t5EyA70fFQQSrl6XZXzqecmYZeUEB8OUGHkxJ+I= +github.com/golang-jwt/jwt/v4 v4.5.0 h1:7cYmW1XlMY7h7ii7UhUyChSgS5wUJEnm9uZVTGqOWzg= +github.com/golang-jwt/jwt/v4 v4.5.0/go.mod h1:m21LjoU+eqJr34lmDMbreY2eSTRJ1cv77w39/MY0Ch0= +github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= +github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= +github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= +github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= +github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= +github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= +github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y= +github.com/golang/mock v1.4.0/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= +github.com/golang/mock v1.4.1/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= +github.com/golang/mock v1.4.3/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= +github.com/golang/mock v1.4.4/go.mod h1:l3mdAwkq5BuhzHwde/uurv3sEJeZMXNpwsxVWU71h+4= +github.com/golang/mock v1.5.0/go.mod h1:CWnOUgYIOo4TcNZ0wHX3YZCqsaM1I1Jvs6v3mP3KVu8= +github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw= +github.com/golang/protobuf v1.3.4/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw= +github.com/golang/protobuf v1.3.5/go.mod h1:6O5/vntMXwX2lRkT1hjjk0nAC1IDOTvTlVgjlRvqsdk= +github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8= +github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA= +github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs= +github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w= +github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0= +github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8= +github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI= +github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI= +github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk= +github.com/golang/protobuf v1.5.1/go.mod h1:DopwsBzvsk0Fs44TXzsVbJyPhcCPeIwnvohx4u74HPM= +github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= +github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg= +github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= +github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= +github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb h1:PBC98N2aIaM3XXiurYmW7fx4GZkL8feAMVq7nEjURHk= +github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= +github.com/gomodule/redigo v1.7.1-0.20190724094224-574c33c3df38/go.mod h1:B4C85qUVwatsJoIUNIfCRsp7qO0iAmpGFZ4EELWSbC4= +github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= +github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= +github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M= +github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= +github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= +github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.4.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.3/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +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-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/go-querystring v1.0.0/go.mod h1:odCYkC5MyYFN7vkCjXpyrEuKhc/BUO6wN/zVPAxq5ck= +github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= +github.com/google/gofuzz v1.2.0 h1:xRy4A+RhZaiKjJ1bPfwQ8sedCA+YS2YcCHW6ec7JMi0= +github.com/google/gofuzz v1.2.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= +github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs= +github.com/google/martian/v3 v3.0.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0= +github.com/google/martian/v3 v3.1.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0= +github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc= +github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc= +github.com/google/pprof v0.0.0-20191218002539-d4f498aebedc/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= +github.com/google/pprof v0.0.0-20200212024743-f11f1df84d12/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= +github.com/google/pprof v0.0.0-20200229191704-1ebb73c60ed3/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= +github.com/google/pprof v0.0.0-20200430221834-fc25d7d30c6d/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= +github.com/google/pprof v0.0.0-20200708004538-1a94d8640e99/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= +github.com/google/pprof v0.0.0-20201023163331-3e6fc7fc9c4c/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20201203190320-1bf35d6f28c2/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20201218002935-b9804c9f04c2/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20210122040257-d980be63207e/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20210226084205-cbba55b83ad5/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/pprof v0.0.0-20210407192527-94a9f03dee38/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= +github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI= +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.4.0 h1:MtMxsa51/r9yyhkyLsVeVt0B+BGQZzpQiTQ4eHZ8bc4= +github.com/google/uuid v1.4.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg= +github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk= +github.com/googleapis/google-cloud-go-testing v0.0.0-20200911160855-bcd43fbb19e8/go.mod h1:dvDLG8qkwmyD9a/MJJN3XJcT3xFxOKAvTZGvuZmac9g= +github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY= +github.com/gorilla/websocket v1.4.1/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= +github.com/gorilla/websocket v1.5.1 h1:gmztn0JnHVt9JZquRuzLw3g4wouNVzKL15iLr/zn/QY= +github.com/gorilla/websocket v1.5.1/go.mod h1:x3kM2JMyaluk02fnUJpQuwD2dCS5NDG2ZHL0uE0tcaY= +github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw= +github.com/hashicorp/consul/api v1.1.0/go.mod h1:VmuI/Lkw1nC05EYQWNKwWGbkg+FbDBtguAZLlVdkD9Q= +github.com/hashicorp/consul/sdk v0.1.1/go.mod h1:VKf9jXwCTEY1QZP2MOLRhb5i/I/ssyNV1vwHyQBF0x8= +github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4= +github.com/hashicorp/go-bexpr v0.1.10 h1:9kuI5PFotCboP3dkDYFr/wi0gg0QVbSNz5oFRpxn4uE= +github.com/hashicorp/go-bexpr v0.1.10/go.mod h1:oxlubA2vC/gFVfX1A6JGp7ls7uCDlfJn732ehYYg+g0= +github.com/hashicorp/go-cleanhttp v0.5.1/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80= +github.com/hashicorp/go-immutable-radix v1.0.0/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60= +github.com/hashicorp/go-msgpack v0.5.3/go.mod h1:ahLV/dePpqEmjfWmKiqvPkv/twdG7iPBM1vqhUKIvfM= +github.com/hashicorp/go-multierror v1.0.0/go.mod h1:dHtQlpGsu+cZNNAkkCN/P3hoUDHhCYQXV3UM06sGGrk= +github.com/hashicorp/go-rootcerts v1.0.0/go.mod h1:K6zTfqpRlCUIjkwsN4Z+hiSfzSTQa6eBIzfwKfwNnHU= +github.com/hashicorp/go-sockaddr v1.0.0/go.mod h1:7Xibr9yA9JjQq1JpNB2Vw7kxv8xerXegt+ozgdvDeDU= +github.com/hashicorp/go-syslog v1.0.0/go.mod h1:qPfqrKkXGihmCqbJM2mZgkZGvKG1dFdvsLplgctolz4= +github.com/hashicorp/go-uuid v1.0.0/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro= +github.com/hashicorp/go-uuid v1.0.1/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro= +github.com/hashicorp/go-version v1.2.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA= +github.com/hashicorp/go.net v0.0.1/go.mod h1:hjKkEWcCURg++eb33jQU7oqQcI9XDCnUzHA0oac0k90= +github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= +github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= +github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4= +github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ= +github.com/hashicorp/logutils v1.0.0/go.mod h1:QIAnNjmIWmVIIkWDTG1z5v++HQmx9WQRO+LraFDTW64= +github.com/hashicorp/mdns v1.0.0/go.mod h1:tL+uN++7HEJ6SQLQ2/p+z2pH24WQKWjBPkE0mNTz8vQ= +github.com/hashicorp/memberlist v0.1.3/go.mod h1:ajVTdAv/9Im8oMAAj5G31PhhMCZJV2pPBoIllUwCN7I= +github.com/hashicorp/serf v0.8.2/go.mod h1:6hOLApaqBFA1NXqRQAsxw9QxuDEvNxSQRwA/JwenrHc= +github.com/hermeznetwork/tracerr v0.3.2 h1:QB3TlQxO/4XHyixsg+nRZPuoel/FFQlQ7oAoHDD5l1c= +github.com/hermeznetwork/tracerr v0.3.2/go.mod h1:nsWC1+tc4qUEbUGRv4DcPJJTjLsedlPajlFmpJoohK4= +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.4 h1:jUc4Nk8fm9jZabQuqr2JzednajVmBpC+oiTiXZJEApU= +github.com/holiman/uint256 v1.2.4/go.mod h1:EOMSn4q6Nyt9P6efbI3bueV4e1b3dGlUCXeiRV4ng7E= +github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU= +github.com/huin/goupnp v1.3.0 h1:UvLUlWDNpoUdYzb2TCn+MuTWtcjXKSza2n6CBdQ0xXc= +github.com/huin/goupnp v1.3.0/go.mod h1:gnGPsThkYa7bFi/KWmEysQRf48l2dvR5bxr2OFckNX8= +github.com/hydrogen18/memlistener v0.0.0-20200120041712-dcc25e7acd91/go.mod h1:qEIFzExnS6016fRpRfxrExeVn2gbClQA99gQhnIcdhE= +github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= +github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= +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/invopop/jsonschema v0.12.0 h1:6ovsNSuvn9wEQVOyc72aycBMVQFKz7cPdMJn10CvzRI= +github.com/invopop/jsonschema v0.12.0/go.mod h1:ffZ5Km5SWWRAIN6wbDXItl95euhFz2uON45H2qjYt+0= +github.com/iris-contrib/blackfriday v2.0.0+incompatible/go.mod h1:UzZ2bDEoaSGPbkg6SAB4att1aAwTmVIx/5gCVqeyUdI= +github.com/iris-contrib/go.uuid v2.0.0+incompatible/go.mod h1:iz2lgM/1UnEf1kP0L/+fafWORmlnuysV2EMP8MW+qe0= +github.com/iris-contrib/jade v1.1.3/go.mod h1:H/geBymxJhShH5kecoiOCSssPX7QWYH7UaeZTSWddIk= +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/jackc/chunkreader v1.0.0/go.mod h1:RT6O25fNZIuasFJRyZ4R/Y2BbhasbmZXF9QQ7T3kePo= +github.com/jackc/chunkreader/v2 v2.0.0/go.mod h1:odVSm741yZoC3dpHEUXIqA9tQRhFrgOHwnPIn9lDKlk= +github.com/jackc/chunkreader/v2 v2.0.1 h1:i+RDz65UE+mmpjTfyz0MoVTnzeYxroil2G82ki7MGG8= +github.com/jackc/chunkreader/v2 v2.0.1/go.mod h1:odVSm741yZoC3dpHEUXIqA9tQRhFrgOHwnPIn9lDKlk= +github.com/jackc/pgconn v0.0.0-20190420214824-7e0022ef6ba3/go.mod h1:jkELnwuX+w9qN5YIfX0fl88Ehu4XC3keFuOJJk9pcnA= +github.com/jackc/pgconn v0.0.0-20190824142844-760dd75542eb/go.mod h1:lLjNuW/+OfW9/pnVKPazfWOgNfH2aPem8YQ7ilXGvJE= +github.com/jackc/pgconn v0.0.0-20190831204454-2fabfa3c18b7/go.mod h1:ZJKsE/KZfsUgOEh9hBm+xYTstcNHg7UPMVJqRfQxq4s= +github.com/jackc/pgconn v1.8.0/go.mod h1:1C2Pb36bGIP9QHGBYCjnyhqu7Rv3sGshaQUvmfGIB/o= +github.com/jackc/pgconn v1.9.0/go.mod h1:YctiPyvzfU11JFxoXokUOOKQXQmDMoJL9vJzHH8/2JY= +github.com/jackc/pgconn v1.9.1-0.20210724152538-d89c8390a530/go.mod h1:4z2w8XhRbP1hYxkpTuBjTS3ne3J48K83+u0zoyvg2pI= +github.com/jackc/pgconn v1.14.0/go.mod h1:9mBNlny0UvkgJdCDvdVHYSjI+8tD2rnKK69Wz8ti++E= +github.com/jackc/pgconn v1.14.1 h1:smbxIaZA08n6YuxEX1sDyjV/qkbtUtkH20qLkR9MUR4= +github.com/jackc/pgconn v1.14.1/go.mod h1:9mBNlny0UvkgJdCDvdVHYSjI+8tD2rnKK69Wz8ti++E= +github.com/jackc/pgio v1.0.0 h1:g12B9UwVnzGhueNavwioyEEpAmqMe1E/BN9ES+8ovkE= +github.com/jackc/pgio v1.0.0/go.mod h1:oP+2QK2wFfUWgr+gxjoBH9KGBb31Eio69xUb0w5bYf8= +github.com/jackc/pgmock v0.0.0-20190831213851-13a1b77aafa2/go.mod h1:fGZlG77KXmcq05nJLRkk0+p82V8B8Dw8KN2/V9c/OAE= +github.com/jackc/pgmock v0.0.0-20201204152224-4fe30f7445fd/go.mod h1:hrBW0Enj2AZTNpt/7Y5rr2xe/9Mn757Wtb2xeBzPv2c= +github.com/jackc/pgmock v0.0.0-20210724152146-4ad1a8207f65 h1:DadwsjnMwFjfWc9y5Wi/+Zz7xoE5ALHsRQlOctkOiHc= +github.com/jackc/pgmock v0.0.0-20210724152146-4ad1a8207f65/go.mod h1:5R2h2EEX+qri8jOWMbJCtaPWkrrNc7OHwsp2TCqp7ak= +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/pgproto3 v1.1.0/go.mod h1:eR5FA3leWg7p9aeAqi37XOTgTIbkABlvcPB3E5rlc78= +github.com/jackc/pgproto3/v2 v2.0.0-alpha1.0.20190420180111-c116219b62db/go.mod h1:bhq50y+xrl9n5mRYyCBFKkpRVTLYJVWeCc+mEAI3yXA= +github.com/jackc/pgproto3/v2 v2.0.0-alpha1.0.20190609003834-432c2951c711/go.mod h1:uH0AWtUmuShn0bcesswc4aBTWGvw0cAxIJp+6OB//Wg= +github.com/jackc/pgproto3/v2 v2.0.0-rc3/go.mod h1:ryONWYqW6dqSg1Lw6vXNMXoBJhpzvWKnT95C46ckYeM= +github.com/jackc/pgproto3/v2 v2.0.0-rc3.0.20190831210041-4c03ce451f29/go.mod h1:ryONWYqW6dqSg1Lw6vXNMXoBJhpzvWKnT95C46ckYeM= +github.com/jackc/pgproto3/v2 v2.0.6/go.mod h1:WfJCnwN3HIg9Ish/j3sgWXnAfK8A9Y0bwXYU5xKaEdA= +github.com/jackc/pgproto3/v2 v2.1.1/go.mod h1:WfJCnwN3HIg9Ish/j3sgWXnAfK8A9Y0bwXYU5xKaEdA= +github.com/jackc/pgproto3/v2 v2.3.2 h1:7eY55bdBeCz1F2fTzSz69QC+pG46jYq9/jtSPiJ5nn0= +github.com/jackc/pgproto3/v2 v2.3.2/go.mod h1:WfJCnwN3HIg9Ish/j3sgWXnAfK8A9Y0bwXYU5xKaEdA= +github.com/jackc/pgservicefile v0.0.0-20200714003250-2b9c44734f2b/go.mod h1:vsD4gTJCa9TptPL8sPkXrLZ+hDuNrZCnj29CQpr4X1E= +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/pgtype v0.0.0-20190421001408-4ed0de4755e0/go.mod h1:hdSHsc1V01CGwFsrv11mJRHWJ6aifDLfdV3aVjFF0zg= +github.com/jackc/pgtype v0.0.0-20190824184912-ab885b375b90/go.mod h1:KcahbBH1nCMSo2DXpzsoWOAfFkdEtEJpPbVLq8eE+mc= +github.com/jackc/pgtype v0.0.0-20190828014616-a8802b16cc59/go.mod h1:MWlu30kVJrUS8lot6TQqcg7mtthZ9T0EoIBFiJcmcyw= +github.com/jackc/pgtype v1.8.1-0.20210724151600-32e20a603178/go.mod h1:C516IlIV9NKqfsMCXTdChteoXmwgUceqaLfjg2e3NlM= +github.com/jackc/pgtype v1.14.0 h1:y+xUdabmyMkJLyApYuPj38mW+aAIqCe5uuBB51rH3Vw= +github.com/jackc/pgtype v1.14.0/go.mod h1:LUMuVrfsFfdKGLw+AFFVv6KtHOFMwRgDDzBt76IqCA4= +github.com/jackc/pgx/v4 v4.0.0-20190420224344-cc3461e65d96/go.mod h1:mdxmSJJuR08CZQyj1PVQBHy9XOp5p8/SHH6a0psbY9Y= +github.com/jackc/pgx/v4 v4.0.0-20190421002000-1b8f0016e912/go.mod h1:no/Y67Jkk/9WuGR0JG/JseM9irFbnEPbuWV2EELPNuM= +github.com/jackc/pgx/v4 v4.0.0-pre1.0.20190824185557-6972a5742186/go.mod h1:X+GQnOEnf1dqHGpw7JmHqHc1NxDoalibchSk9/RWuDc= +github.com/jackc/pgx/v4 v4.12.1-0.20210724153913-640aa07df17c/go.mod h1:1QD0+tgSXP7iUjYm9C1NxKhny7lq6ee99u/z+IHFcgs= +github.com/jackc/pgx/v4 v4.18.1 h1:YP7G1KABtKpB5IHrO9vYwSrCOhs7p3uqhvhhQBptya0= +github.com/jackc/pgx/v4 v4.18.1/go.mod h1:FydWkUyadDmdNH/mHnGob881GawxeEm7TcMCzkb+qQE= +github.com/jackc/puddle v0.0.0-20190413234325-e4ced69a3a2b/go.mod h1:m4B5Dj62Y0fbyuIc15OsIqK0+JU8nkqQjsgx7dvjSWk= +github.com/jackc/puddle v0.0.0-20190608224051-11cab39313c9/go.mod h1:m4B5Dj62Y0fbyuIc15OsIqK0+JU8nkqQjsgx7dvjSWk= +github.com/jackc/puddle v1.1.3/go.mod h1:m4B5Dj62Y0fbyuIc15OsIqK0+JU8nkqQjsgx7dvjSWk= +github.com/jackc/puddle v1.3.0 h1:eHK/5clGOatcjX3oWGBO/MpxpbHzSwud5EWTSCI+MX0= +github.com/jackc/puddle v1.3.0/go.mod h1:m4B5Dj62Y0fbyuIc15OsIqK0+JU8nkqQjsgx7dvjSWk= +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/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y= +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.11/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= +github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU= +github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk= +github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU= +github.com/k0kubun/colorstring v0.0.0-20150214042306-9440f1994b88/go.mod h1:3w7q1U84EfirKl04SVQ/s7nPm1ZPhiXd34z40TNz36k= +github.com/karrick/godirwalk v1.16.1/go.mod h1:j4mkqPuvaLI8mp1DroR3P6ad7cyYd4c1qeJ3RV7ULlk= +github.com/karrick/godirwalk v1.17.0 h1:b4kY7nqDdioR/6qnbHQyDvmA17u5G1cZ6J+CZXwSWoI= +github.com/karrick/godirwalk v1.17.0/go.mod h1:j4mkqPuvaLI8mp1DroR3P6ad7cyYd4c1qeJ3RV7ULlk= +github.com/kataras/golog v0.0.10/go.mod h1:yJ8YKCmyL+nWjERB90Qwn+bdyBZsaQwU3bTVFgkFIp8= +github.com/kataras/iris/v12 v12.1.8/go.mod h1:LMYy4VlP67TQ3Zgriz8RE2h2kMZV2SgMYbq3UhfoFmE= +github.com/kataras/neffos v0.0.14/go.mod h1:8lqADm8PnbeFfL7CLXh1WHw53dG27MC3pgi2R1rmoTE= +github.com/kataras/pio v0.0.2/go.mod h1:hAoW0t9UmXi4R5Oyq5Z4irTbaTsOemSrDGUtaTl7Dro= +github.com/kataras/sitemap v0.0.5/go.mod h1:KY2eugMKiPwsJgx7+U103YZehfvNGOXURubcGyk0Bz8= +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= +github.com/klauspost/compress v1.8.2/go.mod h1:RyIbtBH6LamlWaDj8nUwkbUhJ87Yi3uG0guNDohfE1A= +github.com/klauspost/compress v1.9.7/go.mod h1:RyIbtBH6LamlWaDj8nUwkbUhJ87Yi3uG0guNDohfE1A= +github.com/klauspost/compress v1.17.0 h1:Rnbp4K9EjcDuVuHtd0dgA4qNuv9yKDYKK1ulpJwgrqM= +github.com/klauspost/compress v1.17.0/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE= +github.com/klauspost/cpuid v1.2.1/go.mod h1:Pj4uuM528wm8OyEC2QMXAi2YiTZ96dNQPGgoMS4s3ek= +github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= +github.com/konsorten/go-windows-terminal-sequences v1.0.2/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= +github.com/kr/fs v0.1.0/go.mod h1:FFnZGqtBN9Gxj7eW1uZ42v5BccTP0vu6NEaFoC2HwRg= +github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= +github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk= +github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= +github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= +github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= +github.com/kr/pty v1.1.8/go.mod h1:O1sed60cT9XZ5uDucP5qwvh+TE3NnUj51EiZO/lmSfw= +github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= +github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= +github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= +github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc= +github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= +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/leanovate/gopter v0.2.9/go.mod h1:U2L/78B+KVFIx2VmW6onHJQzXtFb+p5y3y2Sh+Jxxv8= +github.com/lib/pq v1.0.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo= +github.com/lib/pq v1.1.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo= +github.com/lib/pq v1.2.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo= +github.com/lib/pq v1.10.2/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o= +github.com/lib/pq v1.10.7 h1:p7ZhMD+KsSRozJr34udlUrhboJwWAgCg34+/ZZNvZZw= +github.com/lib/pq v1.10.7/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o= +github.com/logrusorgru/aurora v0.0.0-20181002194514-a7b3b318ed4e h1:9MlwzLdW7QSDrhDjFlsEYmxpFyIoXmYRon3dt0io31k= +github.com/logrusorgru/aurora v0.0.0-20181002194514-a7b3b318ed4e/go.mod h1:7rIyQOR62GCctdiQpZ/zOJlFyk6y+94wXzv6RNZgaR4= +github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ= +github.com/magiconair/properties v1.8.5/go.mod h1:y3VJvCyxH9uVvJTWEGAELF3aiYNyPKd5NZ3oSwXrF60= +github.com/magiconair/properties v1.8.7 h1:IeQXZAiQcpL9mgcAe1Nu6cX9LLw6ExEHKjN0VQdvPDY= +github.com/magiconair/properties v1.8.7/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0= +github.com/mailru/easyjson v0.7.7 h1:UGYAvKxe3sBsEDzO8ZeWOSlIQfWFlxbzLZe7hwFURr0= +github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc= +github.com/markbates/errx v1.1.0 h1:QDFeR+UP95dO12JgW+tgi2UVfo0V8YBHiUIOaeBPiEI= +github.com/markbates/errx v1.1.0/go.mod h1:PLa46Oex9KNbVDZhKel8v1OT7hD5JZ2eI7AHhA0wswc= +github.com/markbates/oncer v1.0.0 h1:E83IaVAHygyndzPimgUYJjbshhDTALZyXxvk9FOlQRY= +github.com/markbates/oncer v1.0.0/go.mod h1:Z59JA581E9GP6w96jai+TGqafHPW+cPfRxz2aSZ0mcI= +github.com/markbates/safe v1.0.1 h1:yjZkbvRM6IzKj9tlu/zMJLS0n/V351OZWRnF3QfaUxI= +github.com/markbates/safe v1.0.1/go.mod h1:nAqgmRi7cY2nqMc92/bSEeQA+R4OheNU2T1kNSCBdG0= +github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU= +github.com/mattn/go-colorable v0.1.1/go.mod h1:FuOcm+DKB9mbwrcAfNl7/TZVBZ6rcnceauSikq3lYCQ= +github.com/mattn/go-colorable v0.1.2/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE= +github.com/mattn/go-colorable v0.1.6/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc= +github.com/mattn/go-colorable v0.1.8/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc= +github.com/mattn/go-colorable v0.1.11/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4= +github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA= +github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg= +github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4= +github.com/mattn/go-isatty v0.0.5/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s= +github.com/mattn/go-isatty v0.0.7/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s= +github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s= +github.com/mattn/go-isatty v0.0.9/go.mod h1:YNRxwqDuOph6SZLI9vUUz6OYw3QyUt7WiY2yME+cCiQ= +github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU= +github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94= +github.com/mattn/go-isatty v0.0.17 h1:BTarxUcIeDqL27Mc+vyvdWYSL28zpIhv3RoTdsLMPng= +github.com/mattn/go-isatty v0.0.17/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= +github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI= +github.com/mattn/go-runewidth v0.0.13 h1:lTGmDsbAYt5DmK6OnoV7EuIF1wEIFAcxld6ypU4OSgU= +github.com/mattn/go-runewidth v0.0.13/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w= +github.com/mattn/go-sqlite3 v1.14.15 h1:vfoHhTN1af61xCRSWzFIWzx2YskyMTwHLrExkBOjvxI= +github.com/mattn/go-sqlite3 v1.14.15/go.mod h1:2eHXhiwb8IkHr+BDWZGa96P6+rkvnG63S2DGjv9HUNg= +github.com/mattn/goveralls v0.0.2/go.mod h1:8d1ZMHsd7fW6IRPKQh46F2WRpyib5/X4FOpevwGNQEw= +github.com/matttproud/golang_protobuf_extensions/v2 v2.0.0 h1:jWpvCLoY8Z/e3VKvlsiIGKtc+UG6U5vzxaoagmhXfyg= +github.com/matttproud/golang_protobuf_extensions/v2 v2.0.0/go.mod h1:QUyp042oQthUoa9bqDv0ER0wrtXnBruoNd7aNjkbP+k= +github.com/mediocregopher/radix/v3 v3.4.2/go.mod h1:8FL3F6UQRXHXIBSPUs5h0RybMF8i4n7wVopoX3x7Bv8= +github.com/microcosm-cc/bluemonday v1.0.2/go.mod h1:iVP4YcDBq+n/5fb23BhYFvIMq/leAFZyRl6bYmGDlGc= +github.com/miekg/dns v1.0.14/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg= +github.com/mitchellh/cli v1.0.0/go.mod h1:hNIlj7HEI86fIcpObd7a0FcrxTWetlwJDGcceTlRvqc= +github.com/mitchellh/go-homedir v1.0.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0= +github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0= +github.com/mitchellh/go-testing-interface v1.0.0/go.mod h1:kRemZodwjscx+RGhAo8eIhFbs2+BFgRtFPeD/KE+zxI= +github.com/mitchellh/gox v0.4.0/go.mod h1:Sd9lOJ0+aimLBi73mGofS1ycjY8lL3uZM3JPS42BGNg= +github.com/mitchellh/iochan v1.0.0/go.mod h1:JwYml1nuB7xOzsp52dPpHFffvOCDupsG0QubkSMEySY= +github.com/mitchellh/mapstructure v0.0.0-20160808181253-ca63d7c062ee/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y= +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= +github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= +github.com/mitchellh/pointerstructure v1.2.0 h1:O+i9nHnXS3l/9Wu7r4NrEdwA2VFTicjUEN1uBnDo34A= +github.com/mitchellh/pointerstructure v1.2.0/go.mod h1:BRAsLI5zgXmw97Lf6s25bs8ohIXc3tViBH44KcwB2g4= +github.com/mmcloughlin/addchain v0.4.0 h1:SobOdjm2xLj1KkXN5/n0xTIWyZA2+s99UCY1iPfkHRY= +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/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/moul/http2curl v1.0.0/go.mod h1:8UbvGypXm98wA/IqH45anm5Y2Z6ep6O31QGOAZ3H0fQ= +github.com/nats-io/jwt v0.3.0/go.mod h1:fRYCDE99xlTsqUzISS1Bi75UBJ6ljOJQOAAu5VglpSg= +github.com/nats-io/nats.go v1.9.1/go.mod h1:ZjDU1L/7fJ09jvUSRVBR2e7+RnLiiIQyqyzEE/Zbp4w= +github.com/nats-io/nkeys v0.1.0/go.mod h1:xpnFELMwJABBLVhffcfd1MZx6VsNRFpEugbxziKVo7w= +github.com/nats-io/nuid v1.0.1/go.mod h1:19wcPz3Ph3q0Jbyiqsd0kePYG7A95tJPxeL+1OSON2c= +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= +github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec= +github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY= +github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= +github.com/onsi/ginkgo v1.10.3/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= +github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk= +github.com/onsi/ginkgo v1.16.4/go.mod h1:dX+/inL/fNMqNlz0e9LfyB9TswhZpCVdJM/Z6Vvnwo0= +github.com/onsi/ginkgo v1.16.5 h1:8xi0RTUf59SOSfEtZMvwTvXYMzG4gV23XVHOZiXNtnE= +github.com/onsi/ginkgo v1.16.5/go.mod h1:+E8gABHa3K6zRBolWtd+ROzc/U5bkGt0FwiG042wbpU= +github.com/onsi/ginkgo/v2 v2.1.3/go.mod h1:vw5CSIxN1JObi/U8gcbwft7ZxR2dgaR70JSE3/PpL4c= +github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY= +github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo= +github.com/onsi/gomega v1.17.0/go.mod h1:HnhC7FXeEQY45zxNK3PPoIUhzk/80Xly9PcubAlGdZY= +github.com/onsi/gomega v1.19.0 h1:4ieX6qQjPP/BfC3mpsAtIGGlxTWPeA3Inl/7DtXw1tw= +github.com/onsi/gomega v1.19.0/go.mod h1:LY+I3pBVzYsTBU1AnDwOSxaYi9WoWiqgwooUqq9yPro= +github.com/pascaldekloe/goe v0.0.0-20180627143212-57f6aae5913c/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc= +github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic= +github.com/pelletier/go-toml v1.9.3/go.mod h1:u1nR/EPcESfeI/szUZKdtJ0xRNbUoANCkoOuaOx1Y+c= +github.com/pelletier/go-toml/v2 v2.1.0 h1:FnwAJ4oYMvbT/34k9zzHuZNrhlz48GB3/s6at6/MHO4= +github.com/pelletier/go-toml/v2 v2.1.0/go.mod h1:tJU2Z3ZkXwnxa4DPO899bsyIoywizdUvyaeZurnPPDc= +github.com/pingcap/errors v0.11.4 h1:lFuQV/oaUMGcD2tqt+01ROSmJs75VG1ToEOkZIZ4nE4= +github.com/pingcap/errors v0.11.4/go.mod h1:Oi8TUi2kEtXXLMJk9l1cGmz20kV3TaQ0usTwv5KuLY8= +github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA= +github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= +github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pkg/sftp v1.10.1/go.mod h1:lYOWFsE0bwd1+KfKJaKeuokY15vzFx25BLbzYYoAxZI= +github.com/pkg/sftp v1.13.1/go.mod h1:3HaPG6Dq1ILlpPZRO0HVMrsydcdLt6HRDccSgb87qRg= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= +github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/posener/complete v1.1.1/go.mod h1:em0nMJCgc9GFtwrmVmEMR/ZL6WyhyjMBndrE9hABlRI= +github.com/poy/onpar v1.1.2 h1:QaNrNiZx0+Nar5dLgTVp5mXkyoVFIbepjyEoGSnhbAY= +github.com/poy/onpar v1.1.2/go.mod h1:6X8FLNoxyr9kkmnlqpK6LSoiOtrO6MICtWwEuWkLjzg= +github.com/prometheus/client_golang v1.17.0 h1:rl2sfwZMtSthVU752MqfjQozy7blglC+1SOtjMAMh+Q= +github.com/prometheus/client_golang v1.17.0/go.mod h1:VeL+gMmOAxkS2IqfCq0ZmHSL+LjWfWDUmp1mBz9JgUY= +github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= +github.com/prometheus/client_model v0.5.0 h1:VQw1hfvPvk3Uv6Qf29VrPF32JB6rtbgI6cYPYQjL0Qw= +github.com/prometheus/client_model v0.5.0/go.mod h1:dTiFglRmd66nLR9Pv9f0mZi7B7fk5Pm3gvsjB5tr+kI= +github.com/prometheus/common v0.45.0 h1:2BGz0eBc2hdMDLnO/8n0jeB3oPrt2D08CekT0lneoxM= +github.com/prometheus/common v0.45.0/go.mod h1:YJmSTw9BoKxJplESWWxlbyttQR4uaEcGyv9MZjVOJsY= +github.com/prometheus/procfs v0.11.1 h1:xRC8Iq1yyca5ypa9n1EZnWZkt7dwcoRPQwX/5gwaUuI= +github.com/prometheus/procfs v0.11.1/go.mod h1:eesXgaPo1q7lBpVMoMy0ZOFTth9hBn4W/y0/p/ScXhY= +github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY= +github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= +github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ= +github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4= +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.11.0 h1:cWPaGQEPrBb5/AsnsZesgZZ9yb1OQ+GOISoDNXVBh4M= +github.com/rogpeppe/go-internal v1.11.0/go.mod h1:ddIwULY96R17DhadqLgMfk9H9tvdUzkipdSkR5nkCZA= +github.com/rs/cors v1.7.0 h1:+88SsELBHx5r+hZ8TCkggzSstaWNbDvThkVK8H6f9ik= +github.com/rs/cors v1.7.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU= +github.com/rs/xid v1.2.1/go.mod h1:+uKXf+4Djp6Md1KODXJxgGQPKngRmWyn10oCKFzNHOQ= +github.com/rs/zerolog v1.13.0/go.mod h1:YbFCdg8HfsridGWAh22vktObvhZbQsZXe4/zB0OKkWU= +github.com/rs/zerolog v1.15.0/go.mod h1:xYTKnLHcpfU2225ny5qZjxnj9NvkumZYjJHlAThCjNc= +github.com/rubenv/sql-migrate v1.5.2 h1:bMDqOnrJVV/6JQgQ/MxOpU+AdO8uzYYA/TxFUBzFtS0= +github.com/rubenv/sql-migrate v1.5.2/go.mod h1:H38GW8Vqf8F0Su5XignRyaRcbXbJunSWxs+kmzlg0Is= +github.com/russross/blackfriday v1.5.2/go.mod h1:JO/DiYxRf+HjHt06OyowR9PTA263kcR/rfWxYHBV53g= +github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= +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 v0.0.0-20160712163229-9b3edd62028f/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts= +github.com/ryanuber/columnize v2.1.0+incompatible/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts= +github.com/sagikazarmark/locafero v0.3.0 h1:zT7VEGWC2DTflmccN/5T1etyKvxSxpHsjb9cJvm4SvQ= +github.com/sagikazarmark/locafero v0.3.0/go.mod h1:w+v7UsPNFwzF1cHuOajOOzoq4U7v/ig1mpRjqV+Bu1U= +github.com/sagikazarmark/slog-shim v0.1.0 h1:diDBnUNK9N/354PgrxMywXnAwEr1QZcOr6gto+ugjYE= +github.com/sagikazarmark/slog-shim v0.1.0/go.mod h1:SrcSrq8aKtyuqEI1uvTDTK1arOWRIczQRv+GVI1AkeQ= +github.com/satori/go.uuid v1.2.0/go.mod h1:dA0hQrYB0VpLJoorglMZABFdXlWrHn1NEOzdhQKdks0= +github.com/schollz/closestmatch v2.1.0+incompatible/go.mod h1:RtP1ddjLong6gTkbtmuhtR2uUrrJOpYzYRvbcPAid+g= +github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529/go.mod h1:DxrIzT+xaE7yg65j358z/aeFdxmN0P9QXhEzd20vsDc= +github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo= +github.com/shirou/gopsutil v3.21.4-0.20210419000835-c7a38de76ee5+incompatible h1:Bn1aCHHRnjv4Bl16T8rcaFjYSrGrIZvpiGO6P3Q4GpU= +github.com/shirou/gopsutil v3.21.4-0.20210419000835-c7a38de76ee5+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA= +github.com/shopspring/decimal v0.0.0-20180709203117-cd690d0c9e24/go.mod h1:M+9NzErvs504Cn4c5DxATwIqPbtswREoFCre64PpcG4= +github.com/shopspring/decimal v1.2.0/go.mod h1:DKyhrW/HYNuLGql+MJL6WCR6knT2jwCFRcu2hWCYk4o= +github.com/shopspring/decimal v1.3.1 h1:2Usl1nmF/WZucqkFZhnfFYxxxu8LG21F6nPQBE5gKV8= +github.com/shopspring/decimal v1.3.1/go.mod h1:DKyhrW/HYNuLGql+MJL6WCR6knT2jwCFRcu2hWCYk4o= +github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc= +github.com/sirupsen/logrus v1.4.1/go.mod h1:ni0Sbl8bgC9z8RoU9G6nDWqqs/fq4eDPysMBDgk/93Q= +github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE= +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/sourcegraph/conc v0.3.0 h1:OQTbbt6P72L20UqAkXXuLOj79LfEanQ+YQFNpLA9ySo= +github.com/sourcegraph/conc v0.3.0/go.mod h1:Sdozi7LEKbFPqYX2/J+iBAM6HpqSLTASQIKqDmF7Mt0= +github.com/spf13/afero v1.1.2/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ= +github.com/spf13/afero v1.6.0/go.mod h1:Ai8FlHk4v/PARR026UzYexafAt9roJ7LcLMAmO6Z93I= +github.com/spf13/afero v1.10.0 h1:EaGW2JJh15aKOejeuJ+wpFSHnbd7GE6Wvp3TsNhb6LY= +github.com/spf13/afero v1.10.0/go.mod h1:UBogFpq8E9Hx+xc5CNTTEpTnuHVmXDwZcZcE1eb/UhQ= +github.com/spf13/cast v1.3.0/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE= +github.com/spf13/cast v1.3.1/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE= +github.com/spf13/cast v1.5.1 h1:R+kOtfhWQE6TVQzY+4D7wJLBgkdVasCEFxSUBYBYIlA= +github.com/spf13/cast v1.5.1/go.mod h1:b9PdjNptOpzXr7Rq1q9gJML/2cdGQAo69NKzQ10KN48= +github.com/spf13/cobra v0.0.5/go.mod h1:3K3wKZymM7VvHMDS9+Akkh4K60UwM26emMESw8tLCHU= +github.com/spf13/cobra v1.2.1/go.mod h1:ExllRjgxM/piMAM+3tAZvg8fsklGAf3tPfi+i8t68Nk= +github.com/spf13/jwalterweatherman v1.0.0/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo= +github.com/spf13/jwalterweatherman v1.1.0/go.mod h1:aNWZUN0dPAAO/Ljvb5BEdw96iTZ0EXowPYD95IqWIGo= +github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4= +github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA= +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/spf13/viper v1.8.1/go.mod h1:o0Pch8wJ9BVSWGQMbra6iw0oQ5oktSIBaujf1rJH9Ns= +github.com/spf13/viper v1.17.0 h1:I5txKw7MJasPL/BrfkbA0Jyo/oELqVmux4pR/UxOMfI= +github.com/spf13/viper v1.17.0/go.mod h1:BmMMMLQXSbcHK6KAOiFLz0l5JHrU89OdIRHvsk0+yVI= +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.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/objx v0.2.0/go.mod h1:qt09Ya8vawLte6SNmTgCsAVtYtaKzEcn8ATUoHMkEqE= +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.7.2/go.mod h1:R6va5+xMeoiuVRoj+gSkQ7d3FALtqAAGI1FQKckRals= +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.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= +github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= +github.com/subosito/gotenv v1.2.0/go.mod h1:N0PQaV/YGNqwC0u51sEeR/aUtSLEXKX9iv69rRypqCw= +github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8= +github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU= +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.20220614013038-64ee5596c38a h1:1ur3QoCqvE5fl+nylMaIr9PVV1w343YRDtsy+Rwu7XI= +github.com/syndtr/goleveldb v1.0.1-0.20220614013038-64ee5596c38a/go.mod h1:RRCYJbIwD5jmqPI9XoAFR0OcDxqUctll6zUj/+B4S48= +github.com/tklauser/go-sysconf v0.3.12 h1:0QaGUFOdQaIVdPgfITYzaTegZvdCjmYO52cSFAEVmqU= +github.com/tklauser/go-sysconf v0.3.12/go.mod h1:Ho14jnntGE1fpdOqQEEaiKRpvIavV0hSfmBq8nJbHYI= +github.com/tklauser/numcpus v0.6.1 h1:ng9scYS7az0Bk4OZLvrNXNSAO2Pxr1XXRAPyjhIx+Fk= +github.com/tklauser/numcpus v0.6.1/go.mod h1:1XfjsgE2zo8GVw7POkMbHENHzVg3GzmoZ9fESEdAacY= +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/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/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/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/wk8/go-ordered-map/v2 v2.1.8 h1:5h/BUHu93oj4gIdvHHHGsScSTMijfx5PeYkE/fJgbpc= +github.com/wk8/go-ordered-map/v2 v2.1.8/go.mod h1:5nJHM5DyteebpVlHnWMV0rPz6Zp7+xBAnxjb1X5vnTw= +github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f/go.mod h1:N2zxlSyiKSe5eX1tZViRH5QA0qijqEDrYZiPEAiq3wU= +github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415/go.mod h1:GwrjFmJcFw6At/Gs6z4yjiIwzuJ1/+UwLxMQDVQXShQ= +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/go.mod h1:/LWChgwKmvncFJFHJ7Gvn9wZArjbV5/FppcK2fKk/tI= +github.com/yudai/gojsondiff v1.0.0/go.mod h1:AY32+k2cwILAkW1fbgxQ5mUmMiZFgLIV+FBNExI05xg= +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.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/yuin/goldmark v1.1.32/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.0/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= +github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= +github.com/zenazn/goji v0.9.0/go.mod h1:7S9M489iMyHBNxwZnk9/EHS098H4/F6TATF2mIxtB1Q= +go.etcd.io/etcd/api/v3 v3.5.0/go.mod h1:cbVKeC6lCfl7j/8jBhAK6aIYO9XOjdptoxU/nLQcPvs= +go.etcd.io/etcd/client/pkg/v3 v3.5.0/go.mod h1:IJHfcCEKxYu1Os13ZdwCwIUTUVGYTSAM3YSwc9/Ac1g= +go.etcd.io/etcd/client/v2 v2.305.0/go.mod h1:h9puh54ZTgAKtEbut2oe9P4L/oqKCVB6xsXlzd7alYQ= +go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU= +go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8= +go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= +go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= +go.opencensus.io v0.22.4/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= +go.opencensus.io v0.22.5/go.mod h1:5pWMHQbX5EPX2/62yrJeAkowc+lfs/XD7Uxpq3pI6kk= +go.opencensus.io v0.23.0/go.mod h1:XItmlyltB5F7CS4xOC1DcqMoFqwtC6OG2xF7mCv7P7E= +go.uber.org/atomic v1.3.2/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE= +go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE= +go.uber.org/atomic v1.5.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ= +go.uber.org/atomic v1.6.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ= +go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= +go.uber.org/goleak v1.2.0 h1:xqgm/S+aQvhWFTtR0XK3Jvg7z8kGV8P4X14IzwN3Eqk= +go.uber.org/goleak v1.2.0/go.mod h1:XJYK+MuIchqpmGmUSAzotztawfKvYLUIgg7guXrwVUo= +go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0= +go.uber.org/multierr v1.3.0/go.mod h1:VgVr7evmIr6uPjLBxg28wmKNXyqE9akIJ5XnfpiKl+4= +go.uber.org/multierr v1.5.0/go.mod h1:FeouvMocqHpRaaGuG9EjoKcStLC43Zu/fmqdUMPcKYU= +go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU= +go.uber.org/multierr v1.10.0 h1:S0h4aNzvfcFsC3dRF1jLoaov7oRaKqRGC/pUEJ2yvPQ= +go.uber.org/multierr v1.10.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y= +go.uber.org/tools v0.0.0-20190618225709-2cfd321de3ee/go.mod h1:vJERXedbb3MVM5f9Ejo0C68/HhF8uaILCdgjnY+goOA= +go.uber.org/zap v1.9.1/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q= +go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q= +go.uber.org/zap v1.13.0/go.mod h1:zwrFLgMcdUuIBviXEYEH1YKNaOBnKXsx2IPda5bBwHM= +go.uber.org/zap v1.17.0/go.mod h1:MXVU+bhUf/A7Xi2HNOnopQOrmycQ5Ih87HtOu4q5SSo= +go.uber.org/zap v1.26.0 h1:sI7k6L95XOKS281NhVKOFCUNIvv9e0w4BF8N3u+tCRo= +go.uber.org/zap v1.26.0/go.mod h1:dtElttAiwGvoJ/vj4IwHBS/gXsEu/pZ50mUIRWuG0so= +golang.org/x/crypto v0.0.0-20181029021203-45a5f77698d3/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= +golang.org/x/crypto v0.0.0-20190411191339-88737f569e3a/go.mod h1:WFFai1msRO1wXaEeE5yQxYXgSfI8pQAWXbQop6sCtWE= +golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20190701094942-4def268fd1a4/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20190820162420-60c769a6c586/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20191227163750-53104e6ec876/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/crypto v0.0.0-20201203163018-be400aefbc4c/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I= +golang.org/x/crypto v0.0.0-20210322153248-0c34fe9e7dc2/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4= +golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4= +golang.org/x/crypto v0.0.0-20210616213533-5ff15b29337e/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= +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.0.0-20220722155217-630584e8d5aa/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= +golang.org/x/crypto v0.6.0/go.mod h1:OFC/31mSvZgRz0V1QTNCzfAI1aIRzbiufJtkMIlEp58= +golang.org/x/crypto v0.17.0 h1:r8bRNjWL3GshPW3gkd+RpvzWrZAwPS49OmTGZ/uhM4k= +golang.org/x/crypto v0.17.0/go.mod h1:gCAAfMLgwOJRpTjQ2zCCt2OcSfYMTeZVSRtQlPC7Nq4= +golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= +golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= +golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8= +golang.org/x/exp v0.0.0-20190829153037-c13cbed26979/go.mod h1:86+5VVa7VpoJ4kLfm080zCjGlMRFzhUhsZKEZO7MGek= +golang.org/x/exp v0.0.0-20191030013958-a1ab85dbe136/go.mod h1:JXzH8nQsPlswgeRAPE3MuO9GYsAcnJvJ4vnMwN/5qkY= +golang.org/x/exp v0.0.0-20191129062945-2f5052295587/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= +golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= +golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= +golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM= +golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU= +golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa h1:FRnLl4eNAQl8hwxVVC17teOw8kdjVDVAiFMtgUdTSRQ= +golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa/go.mod h1:zk2irFbV9DP96SEBUUAy67IdHUaZuSnrz1n472HUCLE= +golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js= +golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= +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-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= +golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/lint v0.0.0-20190409202823-959b441ac422/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/lint v0.0.0-20190909230951-414d861bb4ac/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f/go.mod h1:5qLYkcX4OjUUV8bRuDixDT3tpyyb+LUpUlRWLxfhWrs= +golang.org/x/lint v0.0.0-20200130185559-910be7a94367/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= +golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= +golang.org/x/lint v0.0.0-20201208152925-83fdc39ff7b5/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= +golang.org/x/lint v0.0.0-20210508222113-6edffad5e616/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= +golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE= +golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o= +golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc= +golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY= +golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= +golang.org/x/mod v0.1.1-0.20191107180719-034126e5016b/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= +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.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= +golang.org/x/mod v0.14.0 h1:dGoOF9QVLYng8IHTm7BAyWqCqSheQ5pYWGhzW00YJr0= +golang.org/x/mod v0.14.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= +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= +golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20181023162649-9b4f9f5ad519/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20181201002055-351d144fa1fc/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20181220203305-927f97764cc3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190327091125-710a502c58a2/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks= +golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20190628185345-da137c7871d7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20190813141303-74dc4d7220e7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20190827160401-ba9fcec4b297/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200114155413-6afb5195e5aa/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200222125558-5a598a2470a0/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200301022130-244492dfa37a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200501053045-e0ff5e5a1de5/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200506145744-7e3656a0809f/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200513185701-a91f0712d120/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200520182314-0ba52f642ac2/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= +golang.org/x/net v0.0.0-20201031054903-ff519b6c9102/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= +golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= +golang.org/x/net v0.0.0-20201209123823-ac852fbbde11/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20201224014010-6772e930b67b/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20210119194325-5f4716e94777/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20210316092652-d523dce5a7f4/go.mod h1:RBQZq4jEuRlivfhVLdyRGr576XBO4/greRjx4P4O3yc= +golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= +golang.org/x/net v0.0.0-20210428140749-89ef3d95e781/go.mod h1:OJAsFXCWl8Ukc7SiCT/9KSuxbyM7479/AVlXFRxuMCk= +golang.org/x/net v0.0.0-20210805182204-aaa1db679c0d/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20211008194852-3b03d305991f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20220225172249-27dd8689420f/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= +golang.org/x/net v0.0.0-20220607020251-c690dde0001d/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= +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.18.0 h1:mIYleuAkSbHh0tCv7RvjL3F6ZVbLjq4+R7zbOn3Kokg= +golang.org/x/net v0.18.0/go.mod h1:/czyP5RqHAH4odGYxBJ1qz0+CE5WZ+2j1YgoEo8F2jQ= +golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= +golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= +golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= +golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= +golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= +golang.org/x/oauth2 v0.0.0-20200902213428-5d25da1a8d43/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20201109201403-9fd604954f58/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20201208152858-08078c50e5b5/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210218202405-ba52d332ba99/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210220000619-9bb904979d93/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210313182246-cd4f82c27b84/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +golang.org/x/oauth2 v0.0.0-20210402161424-2e8d93401602/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= +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= +golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/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-20201207232520-09787c993a3a/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.5.0 h1:60k92dhOjHxJkrqnwsfl8KuaHbn/5dl0lUPUklKo3qE= +golang.org/x/sync v0.5.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= +golang.org/x/sys v0.0.0-20180823144017-11551d06cbcc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20181026203630-95b1ffbd15a5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20181205085412-a5c9d58dba9a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190403152447-81d4e9dc473e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190626221950-04f50cda93cb/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190813064441-fde4db37ae7a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191001151750-bb3f8db39f24/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200113162924-86b910548bc1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200122134326-e047566fdf82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200331124033-c3d80250170d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200501052902-10377860bb8e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200511232937-7e40ca221e25/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200515095857-1151b9dac4a9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200523222454-059865788121/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200803210538-64077c9b5642/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200905004654-be1d3432aa8f/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-20201201145000-ef89a241ccb3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210104204734-6f8348627aad/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210112080510-489259a85091/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210220050731-9a76102bfb43/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210225134936-a50acf3fe073/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210305230114-8fe3ee5dd75b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210315160823-c6e025ad8005/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210320140829-1e4c9ba3b0c4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210423185535-09eb48e85fd7/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +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-20210809222454-d867a43fc93e/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-20211216021012-1d35b9e2eb4e/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-20220520151302-bc2c85ada10a/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-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220908164124-27713097b956/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.15.0 h1:h48lPFYpsTvQJZF4EKyI4aLHaev3CxivZmv7yZig9pc= +golang.org/x/sys v0.15.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +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.0.0-20220722155259-a9ba230a4035/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= +golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k= +golang.org/x/term v0.15.0 h1:y/Oo/a/q3IXu26lQgl04j/gjuBDOBlx7X6Om1j2CPW4= +golang.org/x/term v0.15.0/go.mod h1:BDl952bC7+uMoWR75FIrCDx79TPU9oHkTZ9yRbYOrX0= +golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/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.4/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.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= +golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ= +golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= +golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/time v0.0.0-20201208040808-7e3f01d25324/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/time v0.3.0 h1:rg5rLMjNzMS1RkNLzCG38eapWhnYLFYXDXj2gOlr8j4= +golang.org/x/time v0.3.0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20181221001348-537d06c36207/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY= +golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190327201419-c70d86f8b7cf/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190328211700-ab21143f2384/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= +golang.org/x/tools v0.0.0-20190425163242-31fd60d6bfdc/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= +golang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= +golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= +golang.org/x/tools v0.0.0-20190606124116-d0a3d012864b/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= +golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= +golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= +golang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20190823170909-c4a336ef6a2f/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191029041327-9cc4af7d6b2c/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191029190741-b9c20aec41a5/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191112195655-aa38f8e97acc/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191113191852-77e3bb0ad9e7/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191115202509-3a792d9c32b2/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191125144606-a911d9008d1f/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191130070609-6e064ea0cf2d/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191216173652-a0e659d51361/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20191227053925-7b8e75db28f4/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200103221440-774c71fcf114/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200117161641-43d50277825c/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200122220014-bf1340f18c4a/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200204074204-1cc6d1ef6c74/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200207183749-b753a1ba74fa/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200212150539-ea181f53ac56/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200224181240-023911ca70b2/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200227222343-706bc42d1f0d/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200304193943-95d2e580d8eb/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw= +golang.org/x/tools v0.0.0-20200312045724-11d5b4c81c7d/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw= +golang.org/x/tools v0.0.0-20200331025713-a30bf2db82d4/go.mod h1:Sl4aGygMT6LrqrWclx+PTx3U+LnKx/seiNR+3G19Ar8= +golang.org/x/tools v0.0.0-20200501065659-ab2804fb9c9d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20200512131952-2bc93b1c0c88/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20200515010526-7d3b6ebf133d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20200618134242-20370b0cb4b2/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20200729194436-6467de6f59a7/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= +golang.org/x/tools v0.0.0-20200804011535-6c149bb5ef0d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= +golang.org/x/tools v0.0.0-20200825202427-b303f430e36d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= +golang.org/x/tools v0.0.0-20200904185747-39188db58858/go.mod h1:Cj7w3i3Rnn0Xh82ur9kSqwfTHTeVxaDqrfMjpcNT6bE= +golang.org/x/tools v0.0.0-20201110124207-079ba7bd75cd/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.0.0-20201201161351-ac6f37ff4c2a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.0.0-20201208233053-a543418bbed2/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.0.0-20201224043029-2b0845dc783e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.0.0-20210105154028-b0ab187a4818/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.0.0-20210108195828-e2f9c7f1fc8e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0= +golang.org/x/tools v0.1.2/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/tools v0.1.3/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/tools v0.1.7/go.mod h1:LGqMHiF4EqQNHR1JncWGqT5BVaXmza+X+BDGol+dOxo= +golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= +golang.org/x/tools v0.15.0 h1:zdAyfUGbYmuVokhzVmghFl2ZJh5QhcfebBgmVPFYA+8= +golang.org/x/tools v0.15.0/go.mod h1:hpksKq4dtpQWS1uQ61JkdqWM3LscIS6Slf+VVkm+wQk= +golang.org/x/xerrors v0.0.0-20190410155217-1f06c39b4373/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20190513163551-3ee3066db522/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +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/go.mod h1:K8+ghG5WaK9qNqU5K3HdILfMLy1f3aNYFI/wnl100a8= +google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE= +google.golang.org/api v0.7.0/go.mod h1:WtwebWUNSVBH/HAw79HIFXZNqEvBhG+Ra+ax0hx3E3M= +google.golang.org/api v0.8.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg= +google.golang.org/api v0.9.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg= +google.golang.org/api v0.13.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI= +google.golang.org/api v0.14.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI= +google.golang.org/api v0.15.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI= +google.golang.org/api v0.17.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= +google.golang.org/api v0.18.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= +google.golang.org/api v0.19.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= +google.golang.org/api v0.20.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= +google.golang.org/api v0.22.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= +google.golang.org/api v0.24.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE= +google.golang.org/api v0.28.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE= +google.golang.org/api v0.29.0/go.mod h1:Lcubydp8VUV7KeIHD9z2Bys/sm/vGKnG1UHuDBSrHWM= +google.golang.org/api v0.30.0/go.mod h1:QGmEvQ87FHZNiUVJkT14jQNYJ4ZJjdRF23ZXz5138Fc= +google.golang.org/api v0.35.0/go.mod h1:/XrVsuzM0rZmrsbjJutiuftIzeuTQcEeaYcSk/mQ1dg= +google.golang.org/api v0.36.0/go.mod h1:+z5ficQTmoYpPn8LCUNVpK5I7hwkpjbcgqA7I34qYtE= +google.golang.org/api v0.40.0/go.mod h1:fYKFpnQN0DsDSKRVRcQSDQNtqWPfM9i+zNPxepjRCQ8= +google.golang.org/api v0.41.0/go.mod h1:RkxM5lITDfTzmyKFPt+wGrCJbVfniCr2ool8kTBzRTU= +google.golang.org/api v0.43.0/go.mod h1:nQsDGjRXMo4lvh5hP0TKqF244gqhGcr/YSIykhUk/94= +google.golang.org/api v0.44.0/go.mod h1:EBOGZqzyhtvMDoxwS97ctnh0zUmYY6CxqXsc1AvkYD8= +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/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= +google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0= +google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= +google.golang.org/appengine v1.6.6/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= +google.golang.org/appengine v1.6.7/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= +google.golang.org/genproto v0.0.0-20180518175338-11a468237815/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= +google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= +google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= +google.golang.org/genproto v0.0.0-20190418145605-e7d98fc518a7/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= +google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= +google.golang.org/genproto v0.0.0-20190502173448-54afdca5d873/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= +google.golang.org/genproto v0.0.0-20190801165951-fa694d86fc64/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc= +google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc= +google.golang.org/genproto v0.0.0-20190911173649-1774047e7e51/go.mod h1:IbNlFCBrqXvoKpeg0TB2l7cyZUmoaFKYIwrEpbDKLA8= +google.golang.org/genproto v0.0.0-20191108220845-16a3f7862a1a/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20191115194625-c23dd37a84c9/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20191216164720-4f79533eabd1/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20191230161307-f3c370f40bfb/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20200115191322-ca5a22157cba/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20200122232147-0452cf42e150/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20200204135345-fa8e72b47b90/go.mod h1:GmwEX6Z4W5gMy59cAlVYjN9JhxgbQH6Gn+gFDQe2lzA= +google.golang.org/genproto v0.0.0-20200212174721-66ed5ce911ce/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200224152610-e50cd9704f63/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200228133532-8c2c7df3a383/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200305110556-506484158171/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200312145019-da6875a35672/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200331122359-1ee6d9798940/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200430143042-b979b6f78d84/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200511104702-f5ebc3bea380/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200513103714-09dca8ec2884/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= +google.golang.org/genproto v0.0.0-20200515170657-fc4c6c6a6587/go.mod h1:YsZOwe1myG/8QRHRsmBRE1LrgQY60beZKjly0O1fX9U= +google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo= +google.golang.org/genproto v0.0.0-20200618031413-b414f8b61790/go.mod h1:jDfRM7FcilCzHH/e9qn6dsT145K34l5v+OpcnNgKAAA= +google.golang.org/genproto v0.0.0-20200729003335-053ba62fc06f/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20200804131852-c06518451d9c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20200825200019-8632dd797987/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20200904004341-0bd0a958aa1d/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20201109203340-2640f1f9cdfb/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20201201144952-b05cb90ed32e/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20201210142538-e3217bee35cc/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20201214200347-8c77b98c765d/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210108203827-ffc7fda8c3d7/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210222152913-aa3ee6e6a81c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210226172003-ab064af71705/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210303154014-9728d6b83eeb/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210310155132-4ce2db91004e/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210319143718-93e7006c17a6/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= +google.golang.org/genproto v0.0.0-20210402141018-6c239bbf2bb1/go.mod h1:9lPAdzaEmUacj36I+k7YKbEc5CXzPIeORRgDAUOu28A= +google.golang.org/genproto v0.0.0-20210602131652-f16073e35f0c/go.mod h1:UODoCrxHCcBojKKwX1terBiRUaqAsFqJiF615XL43r0= +google.golang.org/genproto v0.0.0-20210624195500-8bfb893ecb84/go.mod h1:SzzZ/N+nwJDaO1kznhnlzqS8ocJICar6hYhVyhi++24= +google.golang.org/genproto/googleapis/rpc v0.0.0-20230920204549-e6e6cdab5c13 h1:N3bU/SQDCDyD6R528GJ/PwW9KjYcJA3dgyH+MovAkIM= +google.golang.org/genproto/googleapis/rpc v0.0.0-20230920204549-e6e6cdab5c13/go.mod h1:KSqppvjFjtoCI+KGd4PELB0qLNxdJHRGqRI09mB6pQA= +google.golang.org/grpc v1.12.0/go.mod h1:yo6s7OP7yaDglbqo1J04qKzAhqBH6lvTonzMVmEdcZw= +google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= +google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38= +google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM= +google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg= +google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY= +google.golang.org/grpc v1.26.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= +google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= +google.golang.org/grpc v1.27.1/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= +google.golang.org/grpc v1.28.0/go.mod h1:rpkK4SK4GF4Ach/+MFLZUBavHOvF2JJB5uozKKal+60= +google.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk= +google.golang.org/grpc v1.30.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= +google.golang.org/grpc v1.31.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= +google.golang.org/grpc v1.31.1/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= +google.golang.org/grpc v1.33.1/go.mod h1:fr5YgcSWrqhRRxogOsw7RzIpsmvOZ6IcH4kBYTpR3n0= +google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc= +google.golang.org/grpc v1.34.0/go.mod h1:WotjhfgOW/POjDeRt8vscBtXq+2VjORFy659qA51WJ8= +google.golang.org/grpc v1.35.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU= +google.golang.org/grpc v1.36.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU= +google.golang.org/grpc v1.36.1/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU= +google.golang.org/grpc v1.38.0/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM= +google.golang.org/grpc v1.59.0 h1:Z5Iec2pjwb+LEOqzpB2MR12/eKFhDPhuqW91O+4bwUk= +google.golang.org/grpc v1.59.0/go.mod h1:aUPDwccQo6OTjy7Hct4AfBPD1GptF4fyUjIkQ9YtF98= +google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= +google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= +google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= +google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE= +google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo= +google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= +google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= +google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= +google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGjtUeSXeh4= +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.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-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/inconshreveable/log15.v2 v2.0.0-20180818164646-67afb5ed74ec/go.mod h1:aPpfJ7XW+gOuirDoZ8gHhLh3kZ1B08FtV2bbmy7Jv3s= +gopkg.in/ini.v1 v1.51.1/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= +gopkg.in/ini.v1 v1.62.0/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= +gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ= +gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw= +gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.3/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= +gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= +gopkg.in/yaml.v3 v3.0.0-20191120175047-4206685974f2/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +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= +honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= +honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= +honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= +honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= +honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg= +honnef.co/go/tools v0.0.1-2020.1.3/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k= +honnef.co/go/tools v0.0.1-2020.1.4/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k= +rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8= +rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0= +rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA= +rsc.io/tmplfunc v0.0.3 h1:53XFQh69AfOa8Tw0Jm7t+GV7KZhOi6jzsCzTtKbMvzU= +rsc.io/tmplfunc v0.0.3/go.mod h1:AG3sTPzElb1Io3Yg4voV9AGZJuleGAwaVRxL9M49PhA= diff --git a/hex/hex.go b/hex/hex.go new file mode 100644 index 0000000..4699eb2 --- /dev/null +++ b/hex/hex.go @@ -0,0 +1,121 @@ +package hex + +import ( + "encoding/hex" + "fmt" + "math/big" + "strconv" + "strings" +) + +const ( + // Base represents the hexadecimal base, which is 16 + Base = 16 + + // BitSize64 64 bits + BitSize64 = 64 +) + +// DecError represents an error when decoding a hex value +type DecError struct{ msg string } + +func (err DecError) Error() string { return err.msg } + +// EncodeToHex generates a hex string based on the byte representation, with the '0x' prefix +func EncodeToHex(str []byte) string { + return "0x" + hex.EncodeToString(str) +} + +// EncodeToString is a wrapper method for hex.EncodeToString +func EncodeToString(str []byte) string { + return hex.EncodeToString(str) +} + +// DecodeString returns the byte representation of the hexadecimal string +func DecodeString(str string) ([]byte, error) { + return hex.DecodeString(str) +} + +// DecodeHex converts a hex string to a byte array +func DecodeHex(str string) ([]byte, error) { + str = strings.TrimPrefix(str, "0x") + + // Check if the string has an odd length + if len(str)%2 != 0 { + // Prepend a '0' to make it even-length + str = "0" + str + } + + return hex.DecodeString(str) +} + +// MustDecodeHex type-checks and converts a hex string to a byte array +func MustDecodeHex(str string) []byte { + buf, err := DecodeHex(str) + if err != nil { + panic(fmt.Errorf("could not decode hex: %v", err)) + } + + return buf +} + +// DecodeUint64 type-checks and converts a hex string to a uint64 +func DecodeUint64(str string) uint64 { + i := DecodeBig(str) + return i.Uint64() +} + +// EncodeUint64 encodes a number as a hex string with 0x prefix. +func EncodeUint64(i uint64) string { + enc := make([]byte, 2, 10) //nolint:gomnd + copy(enc, "0x") + return string(strconv.AppendUint(enc, i, Base)) +} + +// BadNibble is a nibble that is bad +const BadNibble = ^uint64(0) + +// DecodeNibble decodes a byte into a uint64 +func DecodeNibble(in byte) uint64 { + switch { + case in >= '0' && in <= '9': + return uint64(in - '0') + case in >= 'A' && in <= 'F': + return uint64(in - 'A' + 10) //nolint:gomnd + case in >= 'a' && in <= 'f': + return uint64(in - 'a' + 10) //nolint:gomnd + default: + return BadNibble + } +} + +// EncodeBig encodes bigint as a hex string with 0x prefix. +// The sign of the integer is ignored. +func EncodeBig(bigint *big.Int) string { + numBits := bigint.BitLen() + if numBits == 0 { + return "0x0" + } + + return fmt.Sprintf("%#x", bigint) +} + +// DecodeBig converts a hex number to a big.Int value +func DecodeBig(hexNum string) *big.Int { + str := strings.TrimPrefix(hexNum, "0x") + createdNum := new(big.Int) + createdNum.SetString(str, Base) + + return createdNum +} + +// IsValid checks if the provided string is a valid hexadecimal value +func IsValid(s string) bool { + str := strings.TrimPrefix(s, "0x") + for _, b := range []byte(str) { + if !(b >= '0' && b <= '9' || b >= 'a' && b <= 'f' || b >= 'A' && b <= 'F') { + return false + } + } + return true +} diff --git a/hex/hex_test.go b/hex/hex_test.go new file mode 100644 index 0000000..da86da3 --- /dev/null +++ b/hex/hex_test.go @@ -0,0 +1,52 @@ +package hex + +import ( + "encoding/hex" + "math" + "math/big" + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func TestEncodeDecodeBig(t *testing.T) { + b := big.NewInt(math.MaxInt64) + e := EncodeBig(b) + d := DecodeBig(e) + assert.Equal(t, b.Uint64(), d.Uint64()) +} + +// Define a struct for test cases +type TestCase struct { + input string + output []byte + err error +} + +// Unit test function +func TestDecodeHex(t *testing.T) { + testCases := []TestCase{ + {"0", []byte{0}, nil}, + {"00", []byte{0}, nil}, + {"0x0", []byte{0}, nil}, + {"0x00", []byte{0}, nil}, + {"1", []byte{1}, nil}, + {"01", []byte{1}, nil}, + {"", []byte{}, hex.ErrLength}, + {"0x", []byte{}, hex.ErrLength}, + {"zz", []byte{}, hex.InvalidByteError('z')}, + } + + for _, tc := range testCases { + t.Run(tc.input, func(t *testing.T) { + output, err := DecodeHex(tc.input) + if tc.err != nil { + require.Error(t, tc.err, err) + } else { + require.NoError(t, err) + } + require.Equal(t, output, tc.output) + }) + } +} diff --git a/log/config.go b/log/config.go new file mode 100644 index 0000000..2f166ee --- /dev/null +++ b/log/config.go @@ -0,0 +1,13 @@ +package log + +// Config for log +type Config struct { + // Environment defining the log format ("production" or "development"). + // In development mode enables development mode (which makes DPanicLevel logs panic), uses a console encoder, writes to standard error, and disables sampling. Stacktraces are automatically included on logs of WarnLevel and above. + // Check [here](https://pkg.go.dev/go.uber.org/zap@v1.24.0#NewDevelopmentConfig) + Environment LogEnvironment `mapstructure:"Environment" jsonschema:"enum=production,enum=development"` + // Level of log. As lower value more logs are going to be generated + Level string `mapstructure:"Level" jsonschema:"enum=debug,enum=info,enum=warn,enum=error,enum=dpanic,enum=panic,enum=fatal"` + // Outputs + Outputs []string `mapstructure:"Outputs"` +} diff --git a/log/log.go b/log/log.go new file mode 100644 index 0000000..93d719f --- /dev/null +++ b/log/log.go @@ -0,0 +1,320 @@ +package log + +import ( + "fmt" + "os" + "strings" + "sync/atomic" + + "github.com/0xPolygonHermez/zkevm-ethtx-manager" + "github.com/hermeznetwork/tracerr" + "go.uber.org/zap" + "go.uber.org/zap/zapcore" +) + +// LogEnvironment represents the possible log environments. +type LogEnvironment string + +const ( + // EnvironmentProduction production log environment. + EnvironmentProduction = LogEnvironment("production") + // EnvironmentDevelopment development log environment. + EnvironmentDevelopment = LogEnvironment("development") +) + +// Logger is a wrapper providing logging facilities. +type Logger struct { + x *zap.SugaredLogger +} + +// root logger +var log atomic.Pointer[Logger] + +func getDefaultLog() *Logger { + l := log.Load() + if l != nil { + return l + } + // default level: debug + zapLogger, _, err := NewLogger(Config{ + Environment: EnvironmentDevelopment, + Level: "debug", + Outputs: []string{"stderr"}, + }) + if err != nil { + panic(err) + } + log.Store(&Logger{x: zapLogger}) + return log.Load() +} + +// Init the logger with defined level. outputs defines the outputs where the +// logs will be sent. By default outputs contains "stdout", which prints the +// logs at the output of the process. To add a log file as output, the path +// should be added at the outputs array. To avoid printing the logs but storing +// them on a file, can use []string{"pathtofile.log"} +func Init(cfg Config) { + zapLogger, _, err := NewLogger(cfg) + if err != nil { + panic(err) + } + log.Store(&Logger{x: zapLogger}) +} + +// NewLogger creates the logger with defined level. outputs defines the outputs where the +// logs will be sent. By default, outputs contains "stdout", which prints the +// logs at the output of the process. To add a log file as output, the path +// should be added at the outputs array. To avoid printing the logs but storing +// them on a file, can use []string{"pathtofile.log"} +func NewLogger(cfg Config) (*zap.SugaredLogger, *zap.AtomicLevel, error) { + var level zap.AtomicLevel + err := level.UnmarshalText([]byte(cfg.Level)) + if err != nil { + return nil, nil, fmt.Errorf("error on setting log level: %s", err) + } + + var zapCfg zap.Config + + switch cfg.Environment { + case EnvironmentProduction: + zapCfg = zap.NewProductionConfig() + default: + zapCfg = zap.NewDevelopmentConfig() + zapCfg.EncoderConfig.EncodeLevel = zapcore.CapitalColorLevelEncoder + } + zapCfg.Level = level + zapCfg.OutputPaths = cfg.Outputs + zapCfg.InitialFields = map[string]interface{}{ + "version": zkevm.Version, + "pid": os.Getpid(), + } + + logger, err := zapCfg.Build() + if err != nil { + return nil, nil, err + } + defer logger.Sync() //nolint:gosec,errcheck + + // skip 2 callers: one for our wrapper methods and one for the package functions + withOptions := logger.WithOptions(zap.AddCallerSkip(2)) //nolint:gomnd + return withOptions.Sugar(), &level, nil +} + +// WithFields returns a new Logger (derived from the root one) with additional +// fields as per keyValuePairs. The root Logger instance is not affected. +func WithFields(keyValuePairs ...interface{}) *Logger { + l := getDefaultLog().WithFields(keyValuePairs...) + + // since we are returning a new instance, remove one caller from the + // stack, because we'll be calling the retruned Logger methods + // directly, not the package functions. + x := l.x.WithOptions(zap.AddCallerSkip(-1)) + l.x = x + return l +} + +// WithFields returns a new Logger with additional fields as per keyValuePairs. +// The original Logger instance is not affected. +func (l *Logger) WithFields(keyValuePairs ...interface{}) *Logger { + return &Logger{ + x: l.x.With(keyValuePairs...), + } +} + +func sprintStackTrace(st []tracerr.Frame) string { + builder := strings.Builder{} + // Skip deepest frame because it belongs to the go runtime and we don't + // care about it. + if len(st) > 0 { + st = st[:len(st)-1] + } + for _, f := range st { + builder.WriteString(fmt.Sprintf("\n%s:%d %s()", f.Path, f.Line, f.Func)) + } + builder.WriteString("\n") + return builder.String() +} + +// appendStackTraceMaybeArgs will append the stacktrace to the args +func appendStackTraceMaybeArgs(args []interface{}) []interface{} { + for i := range args { + if err, ok := args[i].(error); ok { + err = tracerr.Wrap(err) + st := tracerr.StackTrace(err) + return append(args, sprintStackTrace(st)) + } + } + return args +} + +// Debug calls log.Debug +func (l *Logger) Debug(args ...interface{}) { + l.x.Debug(args...) +} + +// Info calls log.Info +func (l *Logger) Info(args ...interface{}) { + l.x.Info(args...) +} + +// Warn calls log.Warn +func (l *Logger) Warn(args ...interface{}) { + l.x.Warn(args...) +} + +// Error calls log.Error +func (l *Logger) Error(args ...interface{}) { + l.x.Error(args...) +} + +// Fatal calls log.Fatal +func (l *Logger) Fatal(args ...interface{}) { + l.x.Fatal(args...) +} + +// Debugf calls log.Debugf +func (l *Logger) Debugf(template string, args ...interface{}) { + l.x.Debugf(template, args...) +} + +// Infof calls log.Infof +func (l *Logger) Infof(template string, args ...interface{}) { + l.x.Infof(template, args...) +} + +// Warnf calls log.Warnf +func (l *Logger) Warnf(template string, args ...interface{}) { + l.x.Warnf(template, args...) +} + +// Fatalf calls log.Fatalf +func (l *Logger) Fatalf(template string, args ...interface{}) { + l.x.Fatalf(template, args...) +} + +// Errorf calls log.Errorf and stores the error message into the ErrorFile +func (l *Logger) Errorf(template string, args ...interface{}) { + l.x.Errorf(template, args...) +} + +// Debug calls log.Debug on the root Logger. +func Debug(args ...interface{}) { + getDefaultLog().Debug(args...) +} + +// Info calls log.Info on the root Logger. +func Info(args ...interface{}) { + getDefaultLog().Info(args...) +} + +// Warn calls log.Warn on the root Logger. +func Warn(args ...interface{}) { + getDefaultLog().Warn(args...) +} + +// Error calls log.Error on the root Logger. +func Error(args ...interface{}) { + args = appendStackTraceMaybeArgs(args) + getDefaultLog().Error(args...) +} + +// Fatal calls log.Fatal on the root Logger. +func Fatal(args ...interface{}) { + args = appendStackTraceMaybeArgs(args) + getDefaultLog().Fatal(args...) +} + +// Debugf calls log.Debugf on the root Logger. +func Debugf(template string, args ...interface{}) { + getDefaultLog().Debugf(template, args...) +} + +// Infof calls log.Infof on the root Logger. +func Infof(template string, args ...interface{}) { + getDefaultLog().Infof(template, args...) +} + +// Warnf calls log.Warnf on the root Logger. +func Warnf(template string, args ...interface{}) { + getDefaultLog().Warnf(template, args...) +} + +// Fatalf calls log.Fatalf on the root Logger. +func Fatalf(template string, args ...interface{}) { + args = appendStackTraceMaybeArgs(args) + getDefaultLog().Fatalf(template, args...) +} + +// Errorf calls log.Errorf on the root logger and stores the error message into +// the ErrorFile. +func Errorf(template string, args ...interface{}) { + args = appendStackTraceMaybeArgs(args) + getDefaultLog().Errorf(template, args...) +} + +// appendStackTraceMaybeKV will append the stacktrace to the KV +func appendStackTraceMaybeKV(msg string, kv []interface{}) string { + for i := range kv { + if i%2 == 0 { + continue + } + if err, ok := kv[i].(error); ok { + err = tracerr.Wrap(err) + st := tracerr.StackTrace(err) + return fmt.Sprintf("%v: %v%v\n", msg, err, sprintStackTrace(st)) + } + } + return msg +} + +// Debugw calls log.Debugw +func (l *Logger) Debugw(msg string, kv ...interface{}) { + l.x.Debugw(msg, kv...) +} + +// Infow calls log.Infow +func (l *Logger) Infow(msg string, kv ...interface{}) { + l.x.Infow(msg, kv...) +} + +// Warnw calls log.Warnw +func (l *Logger) Warnw(msg string, kv ...interface{}) { + l.x.Warnw(msg, kv...) +} + +// Errorw calls log.Errorw +func (l *Logger) Errorw(msg string, kv ...interface{}) { + l.x.Errorw(msg, kv...) +} + +// Fatalw calls log.Fatalw +func (l *Logger) Fatalw(msg string, kv ...interface{}) { + l.x.Fatalw(msg, kv...) +} + +// Debugw calls log.Debugw on the root Logger. +func Debugw(msg string, kv ...interface{}) { + getDefaultLog().Debugw(msg, kv...) +} + +// Infow calls log.Infow on the root Logger. +func Infow(msg string, kv ...interface{}) { + getDefaultLog().Infow(msg, kv...) +} + +// Warnw calls log.Warnw on the root Logger. +func Warnw(msg string, kv ...interface{}) { + getDefaultLog().Warnw(msg, kv...) +} + +// Errorw calls log.Errorw on the root Logger. +func Errorw(msg string, kv ...interface{}) { + msg = appendStackTraceMaybeKV(msg, kv) + getDefaultLog().Errorw(msg, kv...) +} + +// Fatalw calls log.Fatalw on the root Logger. +func Fatalw(msg string, kv ...interface{}) { + msg = appendStackTraceMaybeKV(msg, kv) + getDefaultLog().Fatalw(msg, kv...) +} diff --git a/log/log_test.go b/log/log_test.go new file mode 100644 index 0000000..9d33bcd --- /dev/null +++ b/log/log_test.go @@ -0,0 +1,37 @@ +package log + +import ( + "testing" +) + +func TestLogNotInitialized(t *testing.T) { + Info("Test log.Info", " value is ", 10) + Infof("Test log.Infof %d", 10) + Infow("Test log.Infow", "value", 10) + Debugf("Test log.Debugf %d", 10) + Error("Test log.Error", " value is ", 10) + Errorf("Test log.Errorf %d", 10) + Errorw("Test log.Errorw", "value", 10) + Warnf("Test log.Warnf %d", 10) + Warnw("Test log.Warnw", "value", 10) +} + +func TestLog(t *testing.T) { + cfg := Config{ + Environment: EnvironmentDevelopment, + Level: "debug", + Outputs: []string{"stderr"}, //[]string{"stdout", "test.log"} + } + + Init(cfg) + + Info("Test log.Info", " value is ", 10) + Infof("Test log.Infof %d", 10) + Infow("Test log.Infow", "value", 10) + Debugf("Test log.Debugf %d", 10) + Error("Test log.Error", " value is ", 10) + Errorf("Test log.Errorf %d", 10) + Errorw("Test log.Errorw", "value", 10) + Warnf("Test log.Warnf %d", 10) + Warnw("Test log.Warnw", "value", 10) +} diff --git a/metrics/api.go b/metrics/api.go new file mode 100644 index 0000000..c21e2cc --- /dev/null +++ b/metrics/api.go @@ -0,0 +1,16 @@ +package metrics + +const ( + //Endpoint the endpoint for exposing the metrics + Endpoint = "/metrics" + // ProfilingIndexEndpoint the endpoint for exposing the profiling metrics + ProfilingIndexEndpoint = "/debug/pprof/" + // ProfileEndpoint the endpoint for exposing the profile of the profiling metrics + ProfileEndpoint = "/debug/pprof/profile" + // ProfilingCmdEndpoint the endpoint for exposing the command-line of profiling metrics + ProfilingCmdEndpoint = "/debug/pprof/cmdline" + // ProfilingSymbolEndpoint the endpoint for exposing the symbol of profiling metrics + ProfilingSymbolEndpoint = "/debug/pprof/symbol" + // ProfilingTraceEndpoint the endpoint for exposing the trace of profiling metrics + ProfilingTraceEndpoint = "/debug/pprof/trace" +) diff --git a/metrics/config.go b/metrics/config.go new file mode 100644 index 0000000..9fe7ef6 --- /dev/null +++ b/metrics/config.go @@ -0,0 +1,17 @@ +package metrics + +// Config represents the configuration of the metrics +type Config struct { + // Host is the address to bind the metrics server + Host string `mapstructure:"Host"` + // Port is the port to bind the metrics server + Port int `mapstructure:"Port"` + // Enabled is the flag to enable/disable the metrics server + Enabled bool `mapstructure:"Enabled"` + // ProfilingHost is the address to bind the profiling server + ProfilingHost string `mapstructure:"ProfilingHost"` + // ProfilingPort is the port to bind the profiling server + ProfilingPort int `mapstructure:"ProfilingPort"` + // ProfilingEnabled is the flag to enable/disable the profiling server + ProfilingEnabled bool `mapstructure:"ProfilingEnabled"` +} diff --git a/metrics/prometheus.go b/metrics/prometheus.go new file mode 100644 index 0000000..eb63eb9 --- /dev/null +++ b/metrics/prometheus.go @@ -0,0 +1,677 @@ +package metrics + +import ( + "net/http" + "sync" + + "github.com/0xPolygonHermez/zkevm-ethtx-manager/log" + "github.com/prometheus/client_golang/prometheus" + "github.com/prometheus/client_golang/prometheus/promhttp" +) + +var ( + storageMutex sync.RWMutex + registerer prometheus.Registerer + gauges map[string]prometheus.Gauge + counters map[string]prometheus.Counter + counterVecs map[string]*prometheus.CounterVec + histograms map[string]prometheus.Histogram + histogramVecs map[string]*prometheus.HistogramVec + summaries map[string]prometheus.Summary + initialized bool + initOnce sync.Once +) + +// CounterVecOpts holds options for the CounterVec type. +type CounterVecOpts struct { + prometheus.CounterOpts + Labels []string +} + +// HistogramVecOpts holds options for the HistogramVec type. +type HistogramVecOpts struct { + prometheus.HistogramOpts + Labels []string +} + +// Init initializes the package variables. +func Init() { + initOnce.Do(func() { + storageMutex = sync.RWMutex{} + registerer = prometheus.DefaultRegisterer + gauges = make(map[string]prometheus.Gauge) + counters = make(map[string]prometheus.Counter) + counterVecs = make(map[string]*prometheus.CounterVec) + histograms = make(map[string]prometheus.Histogram) + histogramVecs = make(map[string]*prometheus.HistogramVec) + summaries = make(map[string]prometheus.Summary) + initialized = true + }) +} + +// Handler returns the Prometheus http handler. +func Handler() http.Handler { + return promhttp.Handler() +} + +// RegisterGauges registers the provided gauge metrics to the Prometheus +// registerer. +func RegisterGauges(opts ...prometheus.GaugeOpts) { + if !initialized { + return + } + + storageMutex.Lock() + defer storageMutex.Unlock() + + for _, options := range opts { + registerGaugeIfNotExists(options) + } +} + +// UnregisterGauges unregisters the provided gauge metrics from the Prometheus +// registerer. +func UnregisterGauges(names ...string) { + if !initialized { + return + } + + storageMutex.Lock() + defer storageMutex.Unlock() + + for _, name := range names { + unregisterGaugeIfExists(name) + } +} + +// Gauge retrieves gauge metric by name +func Gauge(name string) (gauge prometheus.Gauge, exist bool) { + if !initialized { + return + } + + storageMutex.RLock() + defer storageMutex.RUnlock() + + if gauge, exist = gauges[name]; !exist { + return nil, exist + } + + return gauge, exist +} + +// GaugeSet sets the value for gauge with the given name. +func GaugeSet(name string, value float64) { + if !initialized { + return + } + + if c, ok := Gauge(name); ok { + c.Set(value) + } +} + +// GaugeInc increments the gauge with the given name. +func GaugeInc(name string) { + if !initialized { + return + } + + if g, ok := Gauge(name); ok { + g.Inc() + } +} + +// GaugeDec decrements the gauge with the given name. +func GaugeDec(name string) { + if !initialized { + return + } + + if g, ok := Gauge(name); ok { + g.Dec() + } +} + +// RegisterCounters registers the provided counter metrics to the Prometheus +// registerer. +func RegisterCounters(opts ...prometheus.CounterOpts) { + if !initialized { + return + } + + storageMutex.Lock() + defer storageMutex.Unlock() + + for _, options := range opts { + registerCounterIfNotExists(options) + } +} + +// Counter retrieves counter metric by name +func Counter(name string) (counter prometheus.Counter, exist bool) { + if !initialized { + return + } + + storageMutex.RLock() + defer storageMutex.RUnlock() + + if counter, exist = counters[name]; !exist { + return nil, exist + } + + return counter, exist +} + +// CounterInc increments the counter with the given name. +func CounterInc(name string) { + if !initialized { + return + } + + if c, ok := Counter(name); ok { + c.Inc() + } +} + +// CounterAdd increments the counter with the given name. +func CounterAdd(name string, value float64) { + if !initialized { + return + } + + if c, ok := Counter(name); ok { + c.Add(value) + } +} + +// UnregisterCounters unregisters the provided counter metrics from the +// Prometheus registerer. +func UnregisterCounters(names ...string) { + if !initialized { + return + } + + storageMutex.Lock() + defer storageMutex.Unlock() + + for _, name := range names { + unregisterCounterIfExists(name) + } +} + +// RegisterCounterVecs registers the provided counter vec metrics to the +// Prometheus registerer. +func RegisterCounterVecs(opts ...CounterVecOpts) { + if !initialized { + return + } + + storageMutex.Lock() + defer storageMutex.Unlock() + + for _, options := range opts { + registerCounterVecIfNotExists(options) + } +} + +// CounterVec retrieves counter ver metric by name +func CounterVec(name string) (counterVec *prometheus.CounterVec, exist bool) { + if !initialized { + return + } + + storageMutex.RLock() + defer storageMutex.RUnlock() + + counterVec, exist = counterVecs[name] + + return counterVec, exist +} + +// CounterVecInc increments the counter vec with the given name and label. +func CounterVecInc(name string, label string) { + if !initialized { + return + } + + if cv, ok := CounterVec(name); ok { + cv.WithLabelValues(label).Inc() + } +} + +// CounterVecAdd increments the counter vec by the given value, with the given +// name and label. +func CounterVecAdd(name string, label string, value float64) { + if !initialized { + return + } + + if cv, ok := CounterVec(name); ok { + cv.WithLabelValues(label).Add(value) + } +} + +// UnregisterCounterVecs unregisters the provided counter vec metrics from the +// Prometheus registerer. +func UnregisterCounterVecs(names ...string) { + if !initialized { + return + } + + storageMutex.Lock() + defer storageMutex.Unlock() + + for _, name := range names { + unregisterCounterVecIfExists(name) + } +} + +// RegisterHistograms registers the provided histogram metrics to the +// Prometheus registerer. +func RegisterHistograms(opts ...prometheus.HistogramOpts) { + if !initialized { + return + } + + storageMutex.Lock() + defer storageMutex.Unlock() + + for _, options := range opts { + registerHistogramIfNotExists(options) + } +} + +// Histogram retrieves histogram metric by name +func Histogram(name string) (histogram prometheus.Histogram, exist bool) { + if !initialized { + return + } + + storageMutex.RLock() + defer storageMutex.RUnlock() + + if histogram, exist = histograms[name]; !exist { + return nil, exist + } + + return histogram, exist +} + +// HistogramObserve observes the histogram from the given start time. +func HistogramObserve(name string, value float64) { + if !initialized { + return + } + + if histo, ok := Histogram(name); ok { + histo.Observe(value) + } +} + +// UnregisterHistogram unregisters the provided histogram metrics from the +// Prometheus registerer. +func UnregisterHistogram(names ...string) { + if !initialized { + return + } + + storageMutex.Lock() + defer storageMutex.Unlock() + + for _, name := range names { + unregisterHistogramIfExists(name) + } +} + +// RegisterHistogramVecs registers the provided histogram vec metrics to the +// Prometheus registerer. +func RegisterHistogramVecs(opts ...HistogramVecOpts) { + if !initialized { + return + } + + storageMutex.Lock() + defer storageMutex.Unlock() + + for _, options := range opts { + registerHistogramVecIfNotExists(options) + } +} + +// HistogramVec retrieves histogram ver metric by name +func HistogramVec(name string) (histgramVec *prometheus.HistogramVec, exist bool) { + if !initialized { + return + } + + storageMutex.RLock() + defer storageMutex.RUnlock() + + histgramVec, exist = histogramVecs[name] + + return histgramVec, exist +} + +// HistogramVecObserve observes the histogram vec with the given name, label and value. +func HistogramVecObserve(name string, label string, value float64) { + if !initialized { + return + } + + if cv, ok := HistogramVec(name); ok { + cv.WithLabelValues(label).Observe(value) + } +} + +// UnregisterHistogramVecs unregisters the provided histogram vec metrics from the +// Prometheus registerer. +func UnregisterHistogramVecs(names ...string) { + if !initialized { + return + } + + storageMutex.Lock() + defer storageMutex.Unlock() + + for _, name := range names { + unregisterHistogramVecIfExists(name) + } +} + +// RegisterSummaries registers the provided summary metrics to the Prometheus +// registerer. +func RegisterSummaries(opts ...prometheus.SummaryOpts) { + if !initialized { + return + } + + storageMutex.Lock() + defer storageMutex.Unlock() + + for _, options := range opts { + registerSummaryIfNotExists(options) + } +} + +// Summary retrieves summary metric by name +func Summary(name string) (summary prometheus.Summary, exist bool) { + if !initialized { + return + } + + storageMutex.RLock() + defer storageMutex.RUnlock() + + if summary, exist = summaries[name]; !exist { + return nil, exist + } + + return summary, exist +} + +// UnregisterSummaries unregisters the provided summary metrics from the +// Prometheus registerer. +func UnregisterSummaries(names ...string) { + if !initialized { + return + } + + storageMutex.Lock() + defer storageMutex.Unlock() + + for _, name := range names { + unregisterSummaryIfExists(name) + } +} + +// registerGaugeIfNotExists registers single gauge metric if not exists +func registerGaugeIfNotExists(opts prometheus.GaugeOpts) { + log := log.WithFields("metricName", opts.Name) + if _, exist := gauges[opts.Name]; exist { + log.Warn("Gauge metric already exists.") + return + } + + log.Debug("Creating Gauge Metric...") + gauge := prometheus.NewGauge(opts) + log.Debugf("Gauge Metric successfully created! Labels: %p", opts.ConstLabels) + + log.Debug("Registering Gauge Metric...") + registerer.MustRegister(gauge) + log.Debug("Gauge Metric successfully registered!") + + gauges[opts.Name] = gauge +} + +// unregisterGaugeIfExists unregisters single gauge metric if exists +func unregisterGaugeIfExists(name string) { + var ( + gauge prometheus.Gauge + ok bool + ) + + log := log.WithFields("metricName", name) + if gauge, ok = gauges[name]; !ok { + log.Warn("Trying to delete non-existing Gauge metrics.") + return + } + + log.Debug("Unregistering Gauge Metric...") + ok = registerer.Unregister(gauge) + if !ok { + log.Error("Failed to unregister Gauge Metric.") + return + } + delete(gauges, name) + log.Debug("Gauge Metric successfully unregistered!") +} + +// registerCounterIfNotExists registers single counter metric if not exists +func registerCounterIfNotExists(opts prometheus.CounterOpts) { + log := log.WithFields("metricName", opts.Name) + if _, exist := counters[opts.Name]; exist { + log.Infof("Counter metric already exists. %s", opts.Name) + return + } + + log.Debug("Creating Counter Metric...") + counter := prometheus.NewCounter(opts) + log.Debugf("Counter Metric successfully created! Labels: %p", opts.ConstLabels) + + log.Debug("Registering Counter Metric...") + registerer.MustRegister(counter) + log.Debug("Counter Metric successfully registered!") + + counters[opts.Name] = counter +} + +// unregisterCounterIfExists unregisters single counter metric if exists +func unregisterCounterIfExists(name string) { + var ( + counter prometheus.Counter + ok bool + ) + + log := log.WithFields("metricName", name) + if counter, ok = counters[name]; !ok { + log.Warn("Trying to delete non-existing Counter counter.") + return + } + + log.Debug("Unregistering Counter Metric...") + ok = registerer.Unregister(counter) + if !ok { + log.Error("Failed to unregister Counter Metric.") + return + } + delete(counters, name) + log.Debugf("Counter Metric '%v' successfully unregistered!", name) +} + +// registerCounterVecIfNotExists registers single counter vec metric if not exists +func registerCounterVecIfNotExists(opts CounterVecOpts) { + log := log.WithFields("metricName", opts.Name) + if _, exist := counterVecs[opts.Name]; exist { + log.Warn("Counter vec metric already exists.") + return + } + + log.Debug("Creating Counter Vec Metric...") + counterVec := prometheus.NewCounterVec(opts.CounterOpts, opts.Labels) + log.Debugf("Counter Vec Metric successfully created! Labels: %p", opts.ConstLabels) + + log.Debug("Registering Counter Vec Metric...") + registerer.MustRegister(counterVec) + log.Debug("Counter Vec Metric successfully registered!") + + counterVecs[opts.Name] = counterVec +} + +// unregisterCounterVecIfExists unregisters single counter metric if exists +func unregisterCounterVecIfExists(name string) { + var ( + counterVec *prometheus.CounterVec + ok bool + ) + + log := log.WithFields("metricName", name) + if counterVec, ok = counterVecs[name]; !ok { + log.Warn("Trying to delete non-existing Counter Vec counter.") + return + } + + log.Debug("Unregistering Counter Vec Metric...") + ok = registerer.Unregister(counterVec) + if !ok { + log.Error("Failed to unregister Counter Vec Metric.") + return + } + delete(counterVecs, name) + log.Debug("Counter Vec Metric successfully unregistered!") +} + +// registerHistogramIfNotExists registers single histogram metric if not exists +func registerHistogramIfNotExists(opts prometheus.HistogramOpts) { + log := log.WithFields("metricName", opts.Name) + if _, exist := histograms[opts.Name]; exist { + log.Infof("Histogram metric already exists. %s", opts.Name) + return + } + + log.Debug("Creating Histogram Metric...") + histogram := prometheus.NewHistogram(opts) + log.Debugf("Histogram Metric successfully created! Labels: %p", opts.ConstLabels) + + log.Debug("Registering Histogram Metric...") + registerer.MustRegister(histogram) + log.Debug("Histogram Metric successfully registered!") + + histograms[opts.Name] = histogram +} + +// unregisterHistogramIfExists unregisters single histogram metric if exists +func unregisterHistogramIfExists(name string) { + var ( + histogram prometheus.Histogram + ok bool + ) + + log := log.WithFields("metricName", name) + if histogram, ok = histograms[name]; !ok { + log.Warn("Trying to delete non-existing Histogram histogram.") + return + } + + log.Debug("Unregistering Histogram Metric...") + ok = registerer.Unregister(histogram) + if !ok { + log.Error("Failed to unregister Histogram Metric.") + return + } + delete(histograms, name) + log.Debug("Histogram Metric successfully unregistered!") +} + +// registerHistogramVecIfNotExists unregisters single counter metric if exists +func registerHistogramVecIfNotExists(opts HistogramVecOpts) { + if _, exist := histogramVecs[opts.Name]; exist { + log.Warnf("Histogram vec metric '%v' already exists.", opts.Name) + return + } + + log.Infof("Creating Histogram Vec Metric '%v' ...", opts.Name) + histogramVec := prometheus.NewHistogramVec(opts.HistogramOpts, opts.Labels) + log.Infof("Histogram Vec Metric '%v' successfully created! Labels: %p", opts.Name, opts.ConstLabels) + + log.Infof("Registering Histogram Vec Metric '%v' ...", opts.Name) + registerer.MustRegister(histogramVec) + log.Infof("Histogram Vec Metric '%v' successfully registered!", opts.Name) + + histogramVecs[opts.Name] = histogramVec +} + +// unregisterHistogramVecIfExists unregisters single histogram metric if exists +func unregisterHistogramVecIfExists(name string) { + var ( + histogramVec *prometheus.HistogramVec + ok bool + ) + + if histogramVec, ok = histogramVecs[name]; !ok { + log.Warnf("Trying to delete non-existing Histogram Vec '%v'.", name) + return + } + + log.Infof("Unregistering Histogram Vec Metric '%v' ...", name) + ok = registerer.Unregister(histogramVec) + if !ok { + log.Errorf("Failed to unregister Histogram Vec Metric '%v'.", name) + return + } + delete(histogramVecs, name) + log.Infof("Histogram Vec Metric '%v' successfully unregistered!", name) +} + +// registerSummaryIfNotExists registers single summary metric if not exists +func registerSummaryIfNotExists(opts prometheus.SummaryOpts) { + log := log.WithFields("metricName", opts.Name) + if _, exist := summaries[opts.Name]; exist { + log.Warn("Summary metric already exists.") + return + } + + log.Debug("Creating Summary Metric...") + summary := prometheus.NewSummary(opts) + log.Debugf("Summary Metric successfully created! Labels: %p", opts.ConstLabels) + + log.Debug("Registering Summary Metric...") + registerer.MustRegister(summary) + log.Debug("Summary Metric successfully registered!") + + summaries[opts.Name] = summary +} + +// unregisterSummaryIfExists unregisters single summary metric if exists +func unregisterSummaryIfExists(name string) { + var ( + summary prometheus.Summary + ok bool + ) + + log := log.WithFields("metricName", name) + if summary, ok = summaries[name]; !ok { + log.Warn("Trying to delete non-existing Summary summary.") + return + } + + log.Debug("Unregistering Summary Metric...") + ok = registerer.Unregister(summary) + if !ok { + log.Error("Failed to unregister Summary Metric.") + return + } + delete(summaries, name) + log.Debug("Summary Metric successfully unregistered!") +} diff --git a/metrics/prometheus_test.go b/metrics/prometheus_test.go new file mode 100644 index 0000000..3cf5683 --- /dev/null +++ b/metrics/prometheus_test.go @@ -0,0 +1,371 @@ +package metrics + +import ( + "sync" + "testing" + + "github.com/prometheus/client_golang/prometheus" + "github.com/prometheus/client_golang/prometheus/testutil" + dto "github.com/prometheus/client_model/go" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +var ( + gaugeName = "gaugeName" + gaugeOpts = prometheus.GaugeOpts{Name: gaugeName} + gauge prometheus.Gauge + counterName = "counterName" + counterOpts = prometheus.CounterOpts{Name: counterName} + counter prometheus.Counter + counterVecName = "counterVecName" + counterVecLabelName = "counterVecLabelName" + counterVecLabelVal = "counterVecLabelVal" + counterVecOpts = CounterVecOpts{prometheus.CounterOpts{Name: counterVecName}, []string{counterVecLabelName}} + counterVec *prometheus.CounterVec + histogramName = "histogramName" + histogramOpts = prometheus.HistogramOpts{Name: histogramName, Buckets: []float64{0.5, 10, 20}} + histogram prometheus.Histogram + histogramVecName = "histogramVecName" + histogramVecLabelName = "histogramVecLabelName" + histogramVecLabelVal = "histogramVecLabelVal" + histogramVecOpts = HistogramVecOpts{prometheus.HistogramOpts{Name: histogramVecName}, []string{histogramVecLabelName}} + histogramVec *prometheus.HistogramVec + summaryName = "summaryName" + summaryOpts = prometheus.SummaryOpts{Name: summaryName} + summary = prometheus.NewSummary(summaryOpts) +) + +func setup() { + Init() + gauge = prometheus.NewGauge(gaugeOpts) + counter = prometheus.NewCounter(counterOpts) + counterVec = prometheus.NewCounterVec(counterVecOpts.CounterOpts, counterVecOpts.Labels) + histogram = prometheus.NewHistogram(histogramOpts) + histogramVec = prometheus.NewHistogramVec(histogramVecOpts.HistogramOpts, histogramVecOpts.Labels) + summary = prometheus.NewSummary(summaryOpts) + + // Overriding registerer to be able to do the unit tests independently + registerer = prometheus.NewRegistry() +} + +func cleanup() { + initialized = false + initOnce = sync.Once{} +} + +func TestHandler(t *testing.T) { + setup() + defer cleanup() + + actual := Handler() + + assert.NotNil(t, actual) +} + +func TestRegisterGauges(t *testing.T) { + setup() + defer cleanup() + gaugesOpts := []prometheus.GaugeOpts{gaugeOpts} + + RegisterGauges(gaugesOpts...) + + assert.Len(t, gauges, 1) +} + +func TestGauge(t *testing.T) { + setup() + defer cleanup() + gauges[gaugeName] = gauge + + actual, exist := Gauge(gaugeName) + + assert.True(t, exist) + assert.Equal(t, gauge, actual) +} + +func TestGaugeSet(t *testing.T) { + setup() + defer cleanup() + gauges[gaugeName] = gauge + expected := float64(2) + + GaugeSet(gaugeName, expected) + actual := testutil.ToFloat64(gauge) + + assert.Equal(t, expected, actual) +} + +func TestGaugeInc(t *testing.T) { + setup() + defer cleanup() + gauges[gaugeName] = gauge + expected := float64(1) + + GaugeInc(gaugeName) + actual := testutil.ToFloat64(gauge) + + assert.Equal(t, expected, actual) +} + +func TestGaugeDec(t *testing.T) { + setup() + defer cleanup() + gauges[gaugeName] = gauge + gauge.Set(2) + expected := float64(1) + + GaugeDec(gaugeName) + actual := testutil.ToFloat64(gauge) + + assert.Equal(t, expected, actual) +} + +func TestUnregisterGauges(t *testing.T) { + setup() + defer cleanup() + RegisterGauges(gaugeOpts) + + UnregisterGauges(gaugeName) + + assert.Len(t, gauges, 0) +} + +func TestRegisterCounters(t *testing.T) { + setup() + defer cleanup() + countersOpts := []prometheus.CounterOpts{counterOpts} + + RegisterCounters(countersOpts...) + + assert.Len(t, counters, 1) +} + +func TestCounter(t *testing.T) { + setup() + defer cleanup() + counters[counterName] = counter + + actual, exist := Counter(counterName) + + assert.True(t, exist) + assert.Equal(t, counter, actual) +} + +func TestCounterInc(t *testing.T) { + setup() + defer cleanup() + counters[counterName] = counter + expected := float64(1) + + CounterInc(counterName) + actual := testutil.ToFloat64(counter) + + assert.Equal(t, expected, actual) +} + +func TestCounterAdd(t *testing.T) { + setup() + defer cleanup() + counters[counterName] = counter + expected := float64(2) + + CounterAdd(counterName, expected) + actual := testutil.ToFloat64(counter) + + assert.Equal(t, expected, actual) +} + +func TestUnregisterCounters(t *testing.T) { + setup() + defer cleanup() + RegisterCounters(counterOpts) + + UnregisterCounters(counterName) + + assert.Len(t, counters, 0) +} + +func TestRegisterCounterVecs(t *testing.T) { + setup() + defer cleanup() + counterVecsOpts := []CounterVecOpts{counterVecOpts} + + RegisterCounterVecs(counterVecsOpts...) + + assert.Len(t, counterVecs, 1) +} + +func TestCounterVec(t *testing.T) { + setup() + defer cleanup() + counterVecs[counterVecName] = counterVec + + actual, exist := CounterVec(counterVecName) + + assert.True(t, exist) + assert.Equal(t, counterVec, actual) +} + +func TestCounterVecInc(t *testing.T) { + setup() + defer cleanup() + counterVecs[counterVecName] = counterVec + expected := float64(1) + + CounterVecInc(counterVecName, counterVecLabelVal) + currCounterVec, err := counterVec.GetMetricWithLabelValues(counterVecLabelVal) + require.NoError(t, err) + actual := testutil.ToFloat64(currCounterVec) + + assert.Equal(t, expected, actual) +} + +func TestCounterVecAdd(t *testing.T) { + setup() + defer cleanup() + counterVecs[counterVecName] = counterVec + expected := float64(2) + + CounterVecAdd(counterVecName, counterVecLabelVal, expected) + currCounterVec, err := counterVec.GetMetricWithLabelValues(counterVecLabelVal) + require.NoError(t, err) + actual := testutil.ToFloat64(currCounterVec) + + assert.Equal(t, expected, actual) +} + +func TestUnregisterCounterVecs(t *testing.T) { + setup() + defer cleanup() + RegisterCounterVecs(counterVecOpts) + + UnregisterCounterVecs(counterVecName) + + assert.Len(t, counterVecs, 0) +} + +func TestRegisterHistograms(t *testing.T) { + setup() + defer cleanup() + histogramsOpts := []prometheus.HistogramOpts{histogramOpts} + + RegisterHistograms(histogramsOpts...) + + assert.Len(t, histograms, 1) +} + +func TestHistogram(t *testing.T) { + setup() + defer cleanup() + histograms[histogramName] = histogram + + actual, exist := Histogram(histogramName) + + assert.True(t, exist) + assert.Equal(t, histogram, actual) +} + +func TestHistogramObserve(t *testing.T) { + setup() + defer cleanup() + histograms[histogramName] = histogram + + expected := 42.0 + + HistogramObserve(histogramName, expected) + + m := &dto.Metric{} + require.NoError(t, histogram.Write(m)) + h := m.GetHistogram() + actual := h.GetSampleSum() + assert.Equal(t, expected, actual) +} + +func TestUnregisterHistograms(t *testing.T) { + setup() + defer cleanup() + RegisterHistograms(histogramOpts) + + UnregisterHistogram(histogramName) + + assert.Len(t, histograms, 0) +} + +func TestRegisterHistogramVecs(t *testing.T) { + setup() + defer cleanup() + histogramVecsOpts := []HistogramVecOpts{histogramVecOpts} + + RegisterHistogramVecs(histogramVecsOpts...) + + assert.Len(t, histogramVecs, 1) +} + +func TestHistogramVec(t *testing.T) { + setup() + defer cleanup() + histogramVecs[histogramVecName] = histogramVec + + actual, exist := HistogramVec(histogramVecName) + + assert.True(t, exist) + assert.Equal(t, histogramVec, actual) +} + +func TestHistogramVecObserve(t *testing.T) { + setup() + defer cleanup() + histogramVecs[histogramVecName] = histogramVec + expected := float64(2) + + HistogramVecObserve(histogramVecName, histogramVecLabelVal, expected) + + currHistogramVec := histogramVec.WithLabelValues(histogramVecLabelVal) + m := &dto.Metric{} + require.NoError(t, currHistogramVec.(prometheus.Histogram).Write(m)) + h := m.GetHistogram() + actual := h.GetSampleSum() + assert.Equal(t, expected, actual) +} + +func TestUnregisterHistogramVecs(t *testing.T) { + setup() + defer cleanup() + RegisterHistogramVecs(histogramVecOpts) + + UnregisterHistogramVecs(histogramVecName) + + assert.Len(t, histogramVecs, 0) +} + +func TestRegisterSummaries(t *testing.T) { + setup() + defer cleanup() + summariesOpts := []prometheus.SummaryOpts{summaryOpts} + + RegisterSummaries(summariesOpts...) + + assert.Len(t, summaries, 1) +} + +func TestSummary(t *testing.T) { + setup() + defer cleanup() + summaries[summaryName] = summary + + actual, exist := Summary(summaryName) + + assert.True(t, exist) + assert.Equal(t, summary, actual) +} + +func TestUnregisterSummaries(t *testing.T) { + setup() + defer cleanup() + RegisterSummaries(summaryOpts) + + UnregisterSummaries(summaryName) + + assert.Len(t, summaries, 0) +} diff --git a/test/Makefile b/test/Makefile new file mode 100644 index 0000000..6be185b --- /dev/null +++ b/test/Makefile @@ -0,0 +1,92 @@ +DOCKERCOMPOSE := docker-compose -f docker-compose.yml +DOCKERCOMPOSEAPPETHTXMANAGER := zkevm-ethtx-manager +DOCKERCOMPOSEETHTXMANAGERDB := zkevm-ethtx-manager-db +DOCKERCOMPOSENETWORK := zkevm-mock-l1-network + +RUNETHTXMANAGERDB := $(DOCKERCOMPOSE) up -d $(DOCKERCOMPOSEETHTXMANAGERDB) +RUNETHTXMANAGER := $(DOCKERCOMPOSE) up -d $(DOCKERCOMPOSEAPPETHTXMANAGER) +RUNL1NETWORK := $(DOCKERCOMPOSE) up -d $(DOCKERCOMPOSENETWORK) +RUNMETRICS := $(DOCKERCOMPOSE) up -d $(DOCKERCOMPOSEMETRICS) + +RUN := $(DOCKERCOMPOSE) up -d + +STOPETHTXMANAGERDB := $(DOCKERCOMPOSE) stop $(DOCKERCOMPOSEETHTXMANAGERDB) && $(DOCKERCOMPOSE) rm -f $(DOCKERCOMPOSEETHTXMANAGERDB) +STOPETHTXMANAGER := $(DOCKERCOMPOSE) stop $(DOCKERCOMPOSEAPPETHTXMANAGER) && $(DOCKERCOMPOSE) rm -f $(DOCKERCOMPOSEAPPETHTXMANAGER) +STOPNETWORK := $(DOCKERCOMPOSE) stop $(DOCKERCOMPOSENETWORK) && $(DOCKERCOMPOSE) rm -f $(DOCKERCOMPOSENETWORK) +STOPMETRICS := $(DOCKERCOMPOSE) stop $(DOCKERCOMPOSEMETRICS) && $(DOCKERCOMPOSE) rm -f $(DOCKERCOMPOSEMETRICS) + +STOP := $(DOCKERCOMPOSE) down --remove-orphans + +.PHONY: test # Runs all tests +test: stop + $(RUNETHTXMANAGERDB) + sleep 2 + $(RUNL1NETWORK) + sleep 15 + docker ps -a + trap '$(STOP)' EXIT; MallocNanoZone=0 go test -count=1 -short -race -p 1 -covermode=atomic -coverprofile=../coverage.out -timeout 70s ../... + +.PHONY: run-db +run-db: ## Runs the database + $(RUNETHTXMANAGERDB) + +.PHONY: stop-db +stop-db: ## Stops the database + $(STOPETHTXMANAGERDB) + +.PHONY: run-ethtx-manager +run-node: ## Runs the ethtxmanager + $(RUNETHTXMANAGER) + +.PHONY: stop-ethtx-manager +stop-node: ## Stops the ethtxmanager + $(STOPETHTXMANAGER) + +.PHONY: run-network +run-network: ## Runs the l1 network + $(RUNL1NETWORK) + +.PHONY: stop-network +stop-network: ## Stops the l1 network + $(STOPNETWORK) + +.PHONY: run +run: ## Runs a full node + $(RUNETHTXMANAGERDB) + $(RUNL1NETWORK) + sleep 4 + $(RUNETHTXMANAGER) + +.PHONY: stop +stop: ## Stops all services + $(STOP) + +.PHONY: restart +restart: stop run ## Executes `make stop` and `make run` commands + +.PHONY: run-metrics +run-metrics: ## Runs the metrics container + $(RUNMETRICS) + +.PHONY: stop-metrics +stop-metrics: ## Stops the metrics container + $(STOPMETRICS) + +.PHONY: init-network +init-network: ## Initializes the network + go run ./scripts/init_network/main.go . + +.PHONY: show-logs +show-logs: ## Show logs for running docker + $(DOCKERCOMPOSE) logs + +## Help display. +## Pulls comments from beside commands and prints a nicely formatted +## display with the commands and their usage information. +.DEFAULT_GOAL := help + +.PHONY: help +help: ## Prints this help + @grep -h -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) \ + | sort \ + | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}' diff --git a/test/aggregator.keystore b/test/aggregator.keystore new file mode 100644 index 0000000..36adf8b --- /dev/null +++ b/test/aggregator.keystore @@ -0,0 +1 @@ +{"version":3,"id":"71b028b6-9b1d-4f4c-9e66-31c94a6eb679","address":"70997970c51812dc3a010c7d01b50e0d17dc79c8","crypto":{"ciphertext":"985d5dc5f7750fc4ad0ad0d370486870016bb97e00ef1f7b146d6ad95d456861","cipherparams":{"iv":"f51b18b9f45872f71c3578513fca6cb0"},"cipher":"aes-128-ctr","kdf":"scrypt","kdfparams":{"dklen":32,"salt":"6253e2d8a71e4808dd11143329cfea467cabb37ac1e1e55dbc0dd90ff22524a7","n":8192,"r":8,"p":1},"mac":"922f741e84201fc7c17bbf9fae5dba6c04a2a99a7268998b5a0268aa690004be"}} \ No newline at end of file diff --git a/test/config/test.ethtxmanager.config.toml b/test/config/test.ethtxmanager.config.toml new file mode 100644 index 0000000..6159f0d --- /dev/null +++ b/test/config/test.ethtxmanager.config.toml @@ -0,0 +1,35 @@ +[Log] +Environment = "development" # "production" or "development" +Level = "debug" +Outputs = ["stderr"] + +[Etherman] +URL = "http://zkevm-mock-l1-network:8545" +ForkIDChunkSize = 20000 +MultiGasProvider = false + [Etherscan] + ApiKey = "" + + +[EthTxManager] +ForcedGas = 0 +PrivateKeys = [ + {Path = "/pk/sequencer.keystore", Password = "testonly"}, + {Path = "/pk/aggregator.keystore", Password = "testonly"} +] + [EthTxManager.DB] + User = "ethtxmanager_user" + Password = "ethtxmanager_password" + Name = "ethtxmanager_db" + Host = "zkevm-ethtx-manager-db" + Port = "5432" + EnableLog = false + MaxConns = 200 + +[Metrics] +Host = "0.0.0.0" +Port = 9091 +Enabled = true +ProfilingHost = "0.0.0.0" +ProfilingPort = 6060 +ProfilingEnabled = true diff --git a/test/config/test.genesis.config.json b/test/config/test.genesis.config.json new file mode 100644 index 0000000..042bd75 --- /dev/null +++ b/test/config/test.genesis.config.json @@ -0,0 +1,100 @@ +{ + "l1Config": { + "chainId": 1337, + "polygonZkEVMAddress": "0x8dAF17A20c9DBA35f005b6324F493785D239719d", + "polygonRollupManagerAddress": "0xB7f8BC63BbcaD18155201308C8f3540b07f84F5e", + "polTokenAddress": "0x5FbDB2315678afecb367f032d93F642f64180aa3", + "polygonZkEVMGlobalExitRootAddress": "0x8A791620dd6260079BF849Dc5567aDC3F2FdC318" + }, + "genesisBlockNumber": 138, + "root": "0xa64456534f3bbe93f991c0139342a0ef52df95c6999eaa5ec8a69741da407f9a", + "genesis": [ + { + "contractName": "PolygonZkEVMDeployer", + "balance": "0", + "nonce": "4", + "address": "0x51dbd54FCCb6b3A07738fd3E156D588e71f79973", + "bytecode": "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", + "storage": { + "0x0000000000000000000000000000000000000000000000000000000000000000": "0x000000000000000000000000f39fd6e51aad88f6f4ce6ab8827279cfffb92266" + } + }, + { + "contractName": "ProxyAdmin", + "balance": "0", + "nonce": "1", + "address": "0xe34Fe58DDa5b8c6D547E4857E987633aa86a5e90", + "bytecode": "0x60806040526004361061007b5760003560e01c80639623609d1161004e5780639623609d1461012b57806399a88ec41461013e578063f2fde38b1461015e578063f3b7dead1461017e57600080fd5b8063204e1c7a14610080578063715018a6146100c95780637eff275e146100e05780638da5cb5b14610100575b600080fd5b34801561008c57600080fd5b506100a061009b366004610608565b61019e565b60405173ffffffffffffffffffffffffffffffffffffffff909116815260200160405180910390f35b3480156100d557600080fd5b506100de610255565b005b3480156100ec57600080fd5b506100de6100fb36600461062c565b610269565b34801561010c57600080fd5b5060005473ffffffffffffffffffffffffffffffffffffffff166100a0565b6100de610139366004610694565b6102f7565b34801561014a57600080fd5b506100de61015936600461062c565b61038c565b34801561016a57600080fd5b506100de610179366004610608565b6103e8565b34801561018a57600080fd5b506100a0610199366004610608565b6104a4565b60008060008373ffffffffffffffffffffffffffffffffffffffff166040516101ea907f5c60da1b00000000000000000000000000000000000000000000000000000000815260040190565b600060405180830381855afa9150503d8060008114610225576040519150601f19603f3d011682016040523d82523d6000602084013e61022a565b606091505b50915091508161023957600080fd5b8080602001905181019061024d9190610788565b949350505050565b61025d6104f0565b6102676000610571565b565b6102716104f0565b6040517f8f28397000000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff8281166004830152831690638f283970906024015b600060405180830381600087803b1580156102db57600080fd5b505af11580156102ef573d6000803e3d6000fd5b505050505050565b6102ff6104f0565b6040517f4f1ef28600000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff841690634f1ef28690349061035590869086906004016107a5565b6000604051808303818588803b15801561036e57600080fd5b505af1158015610382573d6000803e3d6000fd5b5050505050505050565b6103946104f0565b6040517f3659cfe600000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff8281166004830152831690633659cfe6906024016102c1565b6103f06104f0565b73ffffffffffffffffffffffffffffffffffffffff8116610498576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201527f646472657373000000000000000000000000000000000000000000000000000060648201526084015b60405180910390fd5b6104a181610571565b50565b60008060008373ffffffffffffffffffffffffffffffffffffffff166040516101ea907ff851a44000000000000000000000000000000000000000000000000000000000815260040190565b60005473ffffffffffffffffffffffffffffffffffffffff163314610267576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015260640161048f565b6000805473ffffffffffffffffffffffffffffffffffffffff8381167fffffffffffffffffffffffff0000000000000000000000000000000000000000831681178455604051919092169283917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09190a35050565b73ffffffffffffffffffffffffffffffffffffffff811681146104a157600080fd5b60006020828403121561061a57600080fd5b8135610625816105e6565b9392505050565b6000806040838503121561063f57600080fd5b823561064a816105e6565b9150602083013561065a816105e6565b809150509250929050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b6000806000606084860312156106a957600080fd5b83356106b4816105e6565b925060208401356106c4816105e6565b9150604084013567ffffffffffffffff808211156106e157600080fd5b818601915086601f8301126106f557600080fd5b81358181111561070757610707610665565b604051601f82017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0908116603f0116810190838211818310171561074d5761074d610665565b8160405282815289602084870101111561076657600080fd5b8260208601602083013760006020848301015280955050505050509250925092565b60006020828403121561079a57600080fd5b8151610625816105e6565b73ffffffffffffffffffffffffffffffffffffffff8316815260006020604081840152835180604085015260005b818110156107ef578581018301518582016060015282016107d3565b5060006060828601015260607fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0601f83011685010192505050939250505056fea2646970667358221220c9867ffac53151bdb1305d8f5e3e883cd83e5270c7ec09cdc24e837b2e65239064736f6c63430008140033", + "storage": { + "0x0000000000000000000000000000000000000000000000000000000000000000": "0x0000000000000000000000000165878a594ca255338adfa4d48449f69242eb8f" + } + }, + { + "contractName": "PolygonZkEVMBridge implementation", + "balance": "0", + "nonce": "1", + "address": "0x12864938EADb26501034339667CabFB3d7045CD2", + "bytecode": "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" + }, + { + "contractName": "PolygonZkEVMBridge proxy", + "balance": "340282366920938463463374607431768211455", + "nonce": "1", + "address": "0xCca6ECD73932e49633B9307e1aa0fC174525F424", + "bytecode": "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", + "storage": { + "0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103": "0x000000000000000000000000e34fe58dda5b8c6d547e4857e987633aa86a5e90", + "0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc": "0x00000000000000000000000012864938eadb26501034339667cabfb3d7045cd2" + } + }, + { + "contractName": "PolygonZkEVMGlobalExitRootL2 implementation", + "balance": "0", + "nonce": "1", + "address": "0xDc64a140Aa3E981100a9becA4E685f962f0cF6C9", + "bytecode": "0x608060405234801561001057600080fd5b506004361061004c5760003560e01c806301fd904414610051578063257b36321461006d57806333d6247d1461008d578063a3c573eb146100a2575b600080fd5b61005a60015481565b6040519081526020015b60405180910390f35b61005a61007b366004610162565b60006020819052908152604090205481565b6100a061009b366004610162565b6100ee565b005b6100c97f000000000000000000000000cca6ecd73932e49633b9307e1aa0fc174525f42481565b60405173ffffffffffffffffffffffffffffffffffffffff9091168152602001610064565b3373ffffffffffffffffffffffffffffffffffffffff7f000000000000000000000000cca6ecd73932e49633b9307e1aa0fc174525f424161461015d576040517fb49365dd00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600155565b60006020828403121561017457600080fd5b503591905056fea2646970667358221220ea2171e2c85c8bff947affc409ef6fc6a8fe82fb8c174ddeda988651e595d66564736f6c63430008140033" + }, + { + "contractName": "PolygonZkEVMGlobalExitRootL2 proxy", + "balance": "0", + "nonce": "1", + "address": "0xa40d5f56745a118d0906a34e69aec8c0db1cb8fa", + "bytecode": "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", + "storage": { + "0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103": "0x000000000000000000000000e34fe58dda5b8c6d547e4857e987633aa86a5e90", + "0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc": "0x000000000000000000000000dc64a140aa3e981100a9beca4e685f962f0cf6c9" + } + }, + { + "contractName": "PolygonZkEVMTimelock", + "balance": "0", + "nonce": "1", + "address": "0x0165878A594ca255338adfa4d48449f69242Eb8F", + "bytecode": "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", + "storage": { + "0x0000000000000000000000000000000000000000000000000000000000000002": "0x0000000000000000000000000000000000000000000000000000000000000e10", + "0xaedcc9e7897c0d335bdc5d92fe3a8b4f23727fe558cd1c19f332b28716a30559": "0x0000000000000000000000000000000000000000000000000000000000000001", + "0xf5e61edb9c9cc6bfbae4463e9a2b1dd6ac3b44ddef38f18016e56ba0363910d9": "0x0000000000000000000000000000000000000000000000000000000000000001", + "0x64494413541ff93b31aa309254e3fed72a7456e9845988b915b4c7a7ceba8814": "0x5f58e3a2316349923ce3780f8d587db2d72378aed66a8261c916544fa6846ca5", + "0x60b9d94c75b7b3f721925089391e4644cd890cb5e6466f9596dfbd2c54e0b280": "0x0000000000000000000000000000000000000000000000000000000000000001", + "0x3412d5605ac6cd444957cedb533e5dacad6378b4bc819ebe3652188a665066d6": "0x5f58e3a2316349923ce3780f8d587db2d72378aed66a8261c916544fa6846ca5", + "0x4b63b79f1e338a49559dcd3193ac9eecc50d0f275d24e97cc8c319e5a31a8bd0": "0x0000000000000000000000000000000000000000000000000000000000000001", + "0xdae2aa361dfd1ca020a396615627d436107c35eff9fe7738a3512819782d706a": "0x5f58e3a2316349923ce3780f8d587db2d72378aed66a8261c916544fa6846ca5", + "0x800d5dfe4bba53eedee06cd4546a27da8de00f12db83f56062976d4493fda899": "0x0000000000000000000000000000000000000000000000000000000000000001", + "0xc3ad33e20b0c56a223ad5104fff154aa010f8715b9c981fd38fdc60a4d1a52fc": "0x5f58e3a2316349923ce3780f8d587db2d72378aed66a8261c916544fa6846ca5" + } + }, + { + "accountName": "keyless Deployer", + "balance": "0", + "nonce": "1", + "address": "0x28BB4e66addE1f042B77E04cf7D3784C1dcDBbA3" + }, + { + "accountName": "deployer", + "balance": "100000000000000000000000", + "nonce": "8", + "address": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266" + } + ] +} \ No newline at end of file diff --git a/test/docker-compose.yml b/test/docker-compose.yml new file mode 100644 index 0000000..370f76e --- /dev/null +++ b/test/docker-compose.yml @@ -0,0 +1,82 @@ +version: "3.5" +networks: + default: + name: zkevm + +services: + zkevm-ethtx-manager: + container_name: zkevm-ethtx-manager + image: zkevm-ethtx-manager + ports: + - 9094:9091 # needed if metrics enabled + environment: + - ZKEVM_ETHTXMANAGER_DB_HOST=zkevm-ethtxmanager-db + volumes: + - ./sequencer.keystore:/pk/sequencer.keystore + - ./aggregator.keystore:/pk/aggregator.keystore + - ./config/test.ethtxmanager.config.toml:/app/config.toml + - ./config/test.genesis.config.json:/app/genesis.json + command: + - "/bin/sh" + - "-c" + - "/app/zkevm-ethtx-manager run --network custom --custom-network-file /app/genesis.json --cfg /app/config.toml --components ethtx-manager" + zkevm-ethtx-manager-db: + container_name: zkevm-ethtx-mananager-db + image: postgres:15 + deploy: + resources: + limits: + memory: 2G + reservations: + memory: 1G + ports: + - 5432:5432 + environment: + - POSTGRES_USER=ethtxmanager_user + - POSTGRES_PASSWORD=ethtxmanager_password + - POSTGRES_DB=ethtxmanager_db + command: + - "postgres" + - "-N" + - "500" + zkevm-mock-l1-network: + container_name: zkevm-mock-l1-network + image: hermeznetwork/geth-zkevm-contracts:v2.1.1-fork.7-geth1.12.0 + ports: + - 8545:8545 + - 8546:8546 + command: + - "--http" + - "--http.api" + - "admin,eth,debug,miner,net,txpool,personal,web3" + - "--http.addr" + - "0.0.0.0" + - "--http.corsdomain" + - "*" + - "--http.vhosts" + - "*" + - "--ws" + - "--ws.origins" + - "*" + - "--ws.addr" + - "0.0.0.0" + - "--dev" + - "--dev.period" + - "1" + - "--datadir" + - "/geth_data" + - "--syncmode" + - "full" + - "--rpc.allow-unprotected-txs" + + zkevm-metrics: + image: prom/prometheus:v2.39.1 + container_name: zkevm-metrics + restart: unless-stopped + ports: + - 9090:9090 + command: + - --config.file=/etc/prometheus/prometheus.yml + - --web.enable-lifecycle + volumes: + - ../config/metrics/prometheus:/etc/prometheus diff --git a/test/sequencer.keystore b/test/sequencer.keystore new file mode 100644 index 0000000..96b662b --- /dev/null +++ b/test/sequencer.keystore @@ -0,0 +1 @@ +{"address":"f39fd6e51aad88f6f4ce6ab8827279cfffb92266","crypto":{"cipher":"aes-128-ctr","ciphertext":"d005030a7684f3adad2447cbb27f63039eec2224c451eaa445de0d90502b9f3d","cipherparams":{"iv":"dc07a54bc7e388efa89c34d42f2ebdb4"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":262144,"p":1,"r":8,"salt":"cf2ec55ecae11171de575112cfb16963570533a9c46fb774473ceb11519eb24a"},"mac":"3eb180d405a5da6e462b2adc00091c14856c91d574bf27348714506357d6e177"},"id":"035454db-6b6d-477f-8a79-ce24c10b185f","version":3} \ No newline at end of file diff --git a/version.go b/version.go new file mode 100644 index 0000000..2dbd8a0 --- /dev/null +++ b/version.go @@ -0,0 +1,25 @@ +package zkevm + +import ( + "fmt" + "io" + "runtime" +) + +// Populated during build, don't touch! +var ( + Version = "v0.1.0" + GitRev = "undefined" + GitBranch = "undefined" + BuildDate = "Fri, 17 Jun 1988 01:58:00 +0200" +) + +// PrintVersion prints version info into the provided io.Writer. +func PrintVersion(w io.Writer) { + fmt.Fprintf(w, "Version: %s\n", Version) + fmt.Fprintf(w, "Git revision: %s\n", GitRev) + fmt.Fprintf(w, "Git branch: %s\n", GitBranch) + fmt.Fprintf(w, "Go version: %s\n", runtime.Version()) + fmt.Fprintf(w, "Built: %s\n", BuildDate) + fmt.Fprintf(w, "OS/Arch: %s/%s\n", runtime.GOOS, runtime.GOARCH) +} diff --git a/version.mk b/version.mk new file mode 100644 index 0000000..73db3b0 --- /dev/null +++ b/version.mk @@ -0,0 +1,4 @@ +VERSION := $(shell git describe --tags --always) +GITREV := $(shell git rev-parse --short HEAD) +GITBRANCH := $(shell git rev-parse --abbrev-ref HEAD) +DATE := $(shell LANG=US date +"%a, %d %b %Y %X %z")