From 21199b98ce5a0499ddd86983f23d853f13808fe1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Toni=20Ram=C3=ADrez?= Date: Tue, 25 Jun 2024 18:29:56 +0200 Subject: [PATCH] feat: sequence sender and aggregator --- .gitignore | 5 + .golangci.yml | 22 +- Dockerfile | 19 + Makefile | 116 + aggregator/agglayer_client.go | 81 + aggregator/agglayer_tx.go | 63 + aggregator/aggregator.go | 1725 ++++++ aggregator/config.go | 167 + aggregator/interfaces.go | 62 + aggregator/metrics/metrics.go | 51 + aggregator/profitabilitychecker.go | 91 + aggregator/prover/aggregator.pb.go | 2819 +++++++++ aggregator/prover/aggregator_grpc.pb.go | 150 + aggregator/prover/prover.go | 336 ++ cmd/cdk/main.go | 1 - cmd/main.go | 90 + cmd/run.go | 257 + cmd/version.go | 13 + config/config.go | 136 + config/default.go | 118 + config/mainnetgenesis.go | 107 + config/network.go | 178 + config/testnetgenesis.go | 108 + config/types/duration.go | 40 + config/types/duration_test.go | 54 + config/types/keystore.go | 10 + dataavailability/config.go | 9 + dataavailability/dataavailability.go | 34 + .../datacommittee/datacommittee.go | 318 + .../datacommittee/datacommittee_test.go | 131 + dataavailability/interfaces.go | 40 + db/config.go | 25 + db/db.go | 123 + db/logger.go | 27 + db/migrations/aggregator/0001.sql | 32 + encoding/encoding.go | 110 + etherman/aggregator.go | 113 + etherman/config.go | 17 + etherman/errors.go | 52 + etherman/errors_test.go | 37 + etherman/etherman.go | 1686 ++++++ etherman/etherscan/etherscan.go | 77 + etherman/etherscan/etherscan_test.go | 39 + etherman/ethgasstation/ethgasstation.go | 64 + etherman/ethgasstation/ethgasstation_test.go | 37 + etherman/mock_etherscan.go | 59 + etherman/mock_ethgasstation.go | 59 + etherman/simulated.go | 208 + .../abi/dataavailabilityprotocol.abi | 33 + .../smartcontracts/abi/etrogpolygonzkevm.abi | 1210 ++++ .../abi/mockpolygonrollupmanager.abi | 1963 ++++++ 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/polygondatacommittee.abi | 239 + .../abi/polygonrollupmanager.abi | 1963 ++++++ etherman/smartcontracts/abi/polygonzkevm.abi | 1302 ++++ .../smartcontracts/abi/polygonzkevmbridge.abi | 1004 ++++ .../abi/polygonzkevmglobalexitroot.abi | 262 + etherman/smartcontracts/abi/proxy.abi | 146 + .../smartcontracts/bin/etrogpolygonzkevm.bin | 1 + .../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/polygondatacommittee.bin | 1 + .../bin/polygonrollupmanager.bin | 1 + etherman/smartcontracts/bin/polygonzkevm.bin | 1 + .../smartcontracts/bin/polygonzkevmbridge.bin | 1 + .../bin/polygonzkevmglobalexitroot.bin | 1 + etherman/smartcontracts/bin/proxy.bin | 1 + .../dataavailabilityprotocol.go | 241 + .../etrogpolygonzkevm/etrogpolygonzkevm.go | 3258 ++++++++++ .../mockpolygonrollupmanager.go | 5058 ++++++++++++++++ .../mockverifier/mockverifier.go | 234 + .../oldpolygonzkevm/oldpolygonzkevm.go | 5308 +++++++++++++++++ .../oldpolygonzkevmbridge.go | 1666 ++++++ .../oldpolygonzkevmglobalexitroot.go | 563 ++ etherman/smartcontracts/pol/pol.go | 1504 +++++ .../polygondatacommittee.go | 937 +++ .../polygonrollupmanager.go | 5058 ++++++++++++++++ .../polygonzkevm/polygonzkevm.go | 3500 +++++++++++ .../polygonzkevmbridge/polygonzkevmbridge.go | 1935 ++++++ .../polygonzkevmglobalexitroot.go | 718 +++ etherman/smartcontracts/proxy/proxy.go | 773 +++ etherman/smartcontracts/script.sh | 30 + etherman/types.go | 84 + etherman/types/finalproofinputs.go | 10 + etherman/types/sequence.go | 26 + go.mod | 145 +- go.sum | 1062 ++++ hex/hex.go | 121 + hex/hex_test.go | 52 + l1infotree/hash.go | 41 + l1infotree/hash_test.go | 20 + l1infotree/tree.go | 198 + log/config.go | 13 + log/log.go | 320 + log/log_test.go | 37 + merkletree/key.go | 201 + merkletree/leaf.go | 17 + merkletree/split.go | 98 + metrics/api.go | 16 + metrics/config.go | 17 + metrics/prometheus.go | 677 +++ metrics/prometheus_test.go | 371 ++ proto/include/google/protobuf/empty.proto | 51 + .../src/proto/aggregator/v1/aggregator.proto | 330 + .../src/proto/datastream/v1/datastream.proto | 90 + sequencesender/config.go | 77 + sequencesender/sequencesender.go | 1184 ++++ sequencesender/sequencesender_test.go | 65 + state/batch.go | 33 + state/config.go | 13 + state/datastream.go | 12 + state/datastream/datastream.pb.go | 1069 ++++ state/encoding_batch_v2.go | 373 ++ state/encoding_batch_v2_test.go | 245 + state/errors.go | 68 + state/forkid.go | 12 + state/genesis.go | 26 + state/helper.go | 188 + state/interfaces.go | 30 + state/pgstatestorage/batch.go | 46 + state/pgstatestorage/interfaces.go | 14 + state/pgstatestorage/pgstatestorage.go | 29 + state/pgstatestorage/proof.go | 227 + state/pgstatestorage/sequence.go | 17 + state/state.go | 40 + state/transaction.go | 88 + state/types.go | 49 + test/aggregator.keystore | 1 + test/config/test.config.toml | 110 + test/config/test.genesis.json | 100 + test/config/test.prover.config.json | 93 + test/docker-compose.yml | 91 + test/sequencer.keystore | 1 + version.go | 25 + version.mk | 4 + 143 files changed, 60404 insertions(+), 13 deletions(-) create mode 100644 .gitignore create mode 100644 Dockerfile create mode 100644 Makefile create mode 100644 aggregator/agglayer_client.go create mode 100644 aggregator/agglayer_tx.go create mode 100644 aggregator/aggregator.go create mode 100644 aggregator/config.go create mode 100644 aggregator/interfaces.go create mode 100644 aggregator/metrics/metrics.go create mode 100644 aggregator/profitabilitychecker.go create mode 100644 aggregator/prover/aggregator.pb.go create mode 100644 aggregator/prover/aggregator_grpc.pb.go create mode 100644 aggregator/prover/prover.go delete mode 100644 cmd/cdk/main.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/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 dataavailability/config.go create mode 100644 dataavailability/dataavailability.go create mode 100644 dataavailability/datacommittee/datacommittee.go create mode 100644 dataavailability/datacommittee/datacommittee_test.go create mode 100644 dataavailability/interfaces.go create mode 100644 db/config.go create mode 100644 db/db.go create mode 100644 db/logger.go create mode 100644 db/migrations/aggregator/0001.sql create mode 100644 encoding/encoding.go create mode 100644 etherman/aggregator.go create mode 100644 etherman/config.go create mode 100644 etherman/errors.go create mode 100644 etherman/errors_test.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/mock_etherscan.go create mode 100644 etherman/mock_ethgasstation.go create mode 100644 etherman/simulated.go create mode 100644 etherman/smartcontracts/abi/dataavailabilityprotocol.abi create mode 100644 etherman/smartcontracts/abi/etrogpolygonzkevm.abi 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/polygondatacommittee.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/abi/proxy.abi create mode 100644 etherman/smartcontracts/bin/etrogpolygonzkevm.bin 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/polygondatacommittee.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/bin/proxy.bin create mode 100644 etherman/smartcontracts/dataavailabilityprotocol/dataavailabilityprotocol.go create mode 100644 etherman/smartcontracts/etrogpolygonzkevm/etrogpolygonzkevm.go 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/polygondatacommittee/polygondatacommittee.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 100644 etherman/smartcontracts/proxy/proxy.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 hex/hex.go create mode 100644 hex/hex_test.go create mode 100644 l1infotree/hash.go create mode 100644 l1infotree/hash_test.go create mode 100644 l1infotree/tree.go create mode 100644 log/config.go create mode 100644 log/log.go create mode 100644 log/log_test.go create mode 100644 merkletree/key.go create mode 100644 merkletree/leaf.go create mode 100644 merkletree/split.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 proto/include/google/protobuf/empty.proto create mode 100644 proto/src/proto/aggregator/v1/aggregator.proto create mode 100644 proto/src/proto/datastream/v1/datastream.proto create mode 100644 sequencesender/config.go create mode 100644 sequencesender/sequencesender.go create mode 100644 sequencesender/sequencesender_test.go create mode 100644 state/batch.go create mode 100644 state/config.go create mode 100644 state/datastream.go create mode 100644 state/datastream/datastream.pb.go create mode 100644 state/encoding_batch_v2.go create mode 100644 state/encoding_batch_v2_test.go create mode 100644 state/errors.go create mode 100644 state/forkid.go create mode 100644 state/genesis.go create mode 100644 state/helper.go create mode 100644 state/interfaces.go create mode 100644 state/pgstatestorage/batch.go create mode 100644 state/pgstatestorage/interfaces.go create mode 100644 state/pgstatestorage/pgstatestorage.go create mode 100644 state/pgstatestorage/proof.go create mode 100644 state/pgstatestorage/sequence.go create mode 100644 state/state.go create mode 100644 state/transaction.go create mode 100644 state/types.go create mode 100644 test/aggregator.keystore create mode 100644 test/config/test.config.toml create mode 100644 test/config/test.genesis.json create mode 100644 test/config/test.prover.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/.gitignore b/.gitignore new file mode 100644 index 00000000..d344a441 --- /dev/null +++ b/.gitignore @@ -0,0 +1,5 @@ +**/.DS_Store +.vscode +.env +/dist/ +cmd/__debug_bin diff --git a/.golangci.yml b/.golangci.yml index 77bc1aa8..a0a1caef 100644 --- a/.golangci.yml +++ b/.golangci.yml @@ -16,32 +16,32 @@ linters: disable-all: true enable: - whitespace # Tool for detection of leading and trailing whitespace - - wsl # Forces you to use empty lines + # - wsl # Forces you to use empty lines - wastedassign # Finds wasted assignment statements - unconvert # Unnecessary type conversions - tparallel # Detects inappropriate usage of t.Parallel() method in your Go test codes - thelper # Detects golang test helpers without t.Helper() call and checks the consistency of test helpers - - stylecheck # Stylecheck is a replacement for golint - - prealloc # Finds slice declarations that could potentially be pre-allocated + # - stylecheck # Stylecheck is a replacement for golint + # - prealloc # Finds slice declarations that could potentially be pre-allocated - predeclared # Finds code that shadows one of Go's predeclared identifiers - - nolintlint # Ill-formed or insufficient nolint directives - - nlreturn # Checks for a new line before return and branch statements to increase code clarity + # - nolintlint # Ill-formed or insufficient nolint directives + # - nlreturn # Checks for a new line before return and branch statements to increase code clarity - misspell # Misspelled English words in comments - makezero # Finds slice declarations with non-zero initial length - - lll # Long lines + # - lll # Long lines - importas # Enforces consistent import aliases - gosec # Security problems - gofmt # Whether the code was gofmt-ed - goimports # Unused imports - goconst # Repeated strings that could be replaced by a constant - - forcetypeassert # Finds forced type assertions + # - forcetypeassert # Finds forced type assertions - dogsled # Checks assignments with too many blank identifiers (e.g. x, , , _, := f()) - - dupl # Code clone detection + # - dupl # Code clone detection - errname # Checks that sentinel errors are prefixed with the Err and error types are suffixed with the Error - - errorlint # errorlint is a linter for that can be used to find code that will cause problems with the error wrapping scheme introduced in Go 1.13 - - gocritic + # - errorlint # errorlint is a linter for that can be used to find code that will cause problems with the error wrapping scheme introduced in Go 1.13 + # - gocritic - errcheck # Errcheck is a go lint rule for checking for unchecked errors in go programs. These unchecked errors can be critical bugs in some cases - - godox # Godox is a linter for TODOs and FIXMEs left in the code + # - godox # Godox is a linter for TODOs and FIXMEs left in the code linters-settings: gofmt: diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..e610c12a --- /dev/null +++ b/Dockerfile @@ -0,0 +1,19 @@ +# CONTAINER FOR BUILDING BINARY +FROM golang:1.22.4 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/cdk /app/cdk +RUN apk update && apk add postgresql15-client +EXPOSE 8123 +CMD ["/bin/sh", "-c", "/app/cdk run"] diff --git a/Makefile b/Makefile new file mode 100644 index 00000000..89d32b1c --- /dev/null +++ b/Makefile @@ -0,0 +1,116 @@ +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 := cdk +GOCMD := $(GOBASE)/cmd + +LDFLAGS += -X 'github.com/0xPolygon/cdk.Version=$(VERSION)' +LDFLAGS += -X 'github.com/0xPolygon/cdk.GitRev=$(GITREV)' +LDFLAGS += -X 'github.com/0xPolygon/cdk.GitBranch=$(GITBRANCH)' +LDFLAGS += -X 'github.com/0xPolygon/cdk.BuildDate=$(DATE)' + +# Variables +VENV = .venv +VENV_PYTHON = $(VENV)/bin/python +SYSTEM_PYTHON = $(or $(shell which python3), $(shell which python)) +PYTHON = $(or $(wildcard $(VENV_PYTHON)), "install_first_venv") +GENERATE_SCHEMA_DOC = $(VENV)/bin/generate-schema-doc +GENERATE_DOC_PATH = "docs/config-file/" +GENERATE_DOC_TEMPLATES_PATH = "docs/config-file/templates/" + +# 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 Protoc +.PHONY: check-protoc +check-protoc: + @which protoc > /dev/null || (echo "Error: Protoc 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 +stop: check-docker check-docker-compose +install-linter: check-go check-curl +generate-code-from-proto: check-protoc + +.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 cdk binary + docker build -t cdk -f ./Dockerfile . + +.PHONY: build-docker-nc +build-docker-nc: ## Builds a docker image with the cdk binary - but without build cache + docker build --no-cache=true -t cdk -f ./Dockerfile . + +.PHONY: stop +stop: ## Stops all services + docker-compose down + +.PHONY: test +test: + go test -count=1 -short -race -p 1 -timeout 60s ./... + +.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 + +$(VENV_PYTHON): + rm -rf $(VENV) + $(SYSTEM_PYTHON) -m venv $(VENV) + +venv: $(VENV_PYTHON) + +.PHONY: generate-code-from-proto +generate-code-from-proto: ## Generates code from proto files + cd proto/src/proto/aggregator/v1 && protoc --proto_path=. --proto_path=../../../../include --go_out=../../../../../aggregator/prover --go-grpc_out=../../../../../aggregator/prover --go-grpc_opt=paths=source_relative --go_opt=paths=source_relative aggregator.proto + cd proto/src/proto/datastream/v1 && protoc --proto_path=. --proto_path=../../../../include --go_out=../../../../../state/datastream --go-grpc_out=../../../../../state/datastream --go-grpc_opt=paths=source_relative --go_opt=paths=source_relative datastream.proto + + +## 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/agglayer_client.go b/aggregator/agglayer_client.go new file mode 100644 index 00000000..4726ccc1 --- /dev/null +++ b/aggregator/agglayer_client.go @@ -0,0 +1,81 @@ +package aggregator + +import ( + "context" + "encoding/json" + "errors" + "fmt" + "strings" + "time" + + "github.com/0xPolygon/cdk-rpc/rpc" + "github.com/0xPolygon/cdk-rpc/types" + "github.com/ethereum/go-ethereum/common" +) + +// AgglayerClientInterface is the interface that defines the methods that the AggLayerClient will implement +type AgglayerClientInterface interface { + SendTx(signedTx SignedTx) (common.Hash, error) + WaitTxToBeMined(hash common.Hash, ctx context.Context) error +} + +// AggLayerClient is the client that will be used to interact with the AggLayer +type AggLayerClient struct { + url string +} + +// NewAggLayerClient returns a client ready to be used +func NewAggLayerClient(url string) *AggLayerClient { + return &AggLayerClient{ + url: url, + } +} + +// SendTx sends a signed transaction to the AggLayer +func (c *AggLayerClient) SendTx(signedTx SignedTx) (common.Hash, error) { + response, err := rpc.JSONRPCCall(c.url, "interop_sendTx", signedTx) + if err != nil { + return common.Hash{}, err + } + + if response.Error != nil { + return common.Hash{}, fmt.Errorf("%v %v", response.Error.Code, response.Error.Message) + } + + var result types.ArgHash + err = json.Unmarshal(response.Result, &result) + if err != nil { + return common.Hash{}, err + } + + return result.Hash(), nil +} + +// WaitTxToBeMined waits for a transaction to be mined +func (c *AggLayerClient) WaitTxToBeMined(hash common.Hash, ctx context.Context) error { + ticker := time.NewTicker(time.Second) + for { + select { + case <-ctx.Done(): + return errors.New("context finished before tx was mined") + case <-ticker.C: + response, err := rpc.JSONRPCCall(c.url, "interop_getTxStatus", hash) + if err != nil { + return err + } + + if response.Error != nil { + return fmt.Errorf("%v %v", response.Error.Code, response.Error.Message) + } + + var result string + err = json.Unmarshal(response.Result, &result) + if err != nil { + return err + } + if strings.ToLower(result) == "done" { + return nil + } + } + } +} diff --git a/aggregator/agglayer_tx.go b/aggregator/agglayer_tx.go new file mode 100644 index 00000000..b0cd09c9 --- /dev/null +++ b/aggregator/agglayer_tx.go @@ -0,0 +1,63 @@ +package aggregator + +import ( + "crypto/ecdsa" + + "github.com/0xPolygon/cdk-rpc/types" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/crypto" +) + +// ZKP is the struct that contains the zero-knowledge proof +type ZKP struct { + NewStateRoot common.Hash `json:"newStateRoot"` + NewLocalExitRoot common.Hash `json:"newLocalExitRoot"` + Proof types.ArgBytes `json:"proof"` +} + +// Tx is the struct that contains the verified batch transaction +type Tx struct { + RollupID uint32 + LastVerifiedBatch types.ArgUint64 `json:"lastVerifiedBatch"` + NewVerifiedBatch types.ArgUint64 `json:"newVerifiedBatch"` + ZKP ZKP `json:"ZKP"` +} + +// Hash returns a hash that uniquely identifies the tx +func (t *Tx) Hash() common.Hash { + return common.BytesToHash(crypto.Keccak256( + []byte(t.LastVerifiedBatch.Hex()), + []byte(t.NewVerifiedBatch.Hex()), + t.ZKP.NewStateRoot[:], + t.ZKP.NewLocalExitRoot[:], + []byte(t.ZKP.Proof.Hex()), + )) +} + +// Sign returns a signed batch by the private key +func (t *Tx) Sign(privateKey *ecdsa.PrivateKey) (*SignedTx, error) { + hashToSign := t.Hash() + sig, err := crypto.Sign(hashToSign.Bytes(), privateKey) + if err != nil { + return nil, err + } + return &SignedTx{ + Tx: *t, + Signature: sig, + }, nil +} + +// SignedTx is the struct that contains the signed batch transaction +type SignedTx struct { + Tx Tx `json:"tx"` + Signature types.ArgBytes `json:"signature"` +} + +// Signer returns the address of the signer +func (s *SignedTx) Signer() (common.Address, error) { + pubKey, err := crypto.SigToPub(s.Tx.Hash().Bytes(), s.Signature) + if err != nil { + return common.Address{}, err + } + return crypto.PubkeyToAddress(*pubKey), nil +} diff --git a/aggregator/aggregator.go b/aggregator/aggregator.go new file mode 100644 index 00000000..e7d5c7f6 --- /dev/null +++ b/aggregator/aggregator.go @@ -0,0 +1,1725 @@ +package aggregator + +import ( + "bytes" + "context" + "crypto/ecdsa" + "encoding/json" + "errors" + "fmt" + "math/big" + "net" + "strings" + "sync" + "sync/atomic" + "time" + "unicode" + + "github.com/0xPolygon/cdk-rpc/rpc" + cdkTypes "github.com/0xPolygon/cdk-rpc/types" + "github.com/0xPolygon/cdk/aggregator/metrics" + "github.com/0xPolygon/cdk/aggregator/prover" + "github.com/0xPolygon/cdk/config/types" + ethmanTypes "github.com/0xPolygon/cdk/etherman/types" + "github.com/0xPolygon/cdk/l1infotree" + "github.com/0xPolygon/cdk/log" + "github.com/0xPolygon/cdk/state" + "github.com/0xPolygon/cdk/state/datastream" + "github.com/0xPolygonHermez/zkevm-data-streamer/datastreamer" + streamlog "github.com/0xPolygonHermez/zkevm-data-streamer/log" + "github.com/0xPolygonHermez/zkevm-ethtx-manager/ethtxmanager" + ethtxlog "github.com/0xPolygonHermez/zkevm-ethtx-manager/log" + synclog "github.com/0xPolygonHermez/zkevm-synchronizer-l1/log" + "github.com/0xPolygonHermez/zkevm-synchronizer-l1/state/entities" + "github.com/0xPolygonHermez/zkevm-synchronizer-l1/synchronizer" + "github.com/ethereum/go-ethereum/common" + "github.com/iden3/go-iden3-crypto/keccak256" + "google.golang.org/grpc" + grpchealth "google.golang.org/grpc/health/grpc_health_v1" + "google.golang.org/grpc/peer" + "google.golang.org/protobuf/proto" +) + +const ( + dataStreamType = 1 + mockedStateRoot = "0x090bcaf734c4f06c93954a827b45a6e8c67b8e0fd1e0a35a1c5982d6961828f9" + mockedLocalExitRoot = "0x17c04c3760510b48c6012742c540a81aba4bca2f78b9d14bfd2f123e2e53ea3e" +) + +type finalProofMsg struct { + proverName string + proverID string + recursiveProof *state.Proof + finalProof *prover.FinalProof +} + +// Aggregator represents an aggregator +type Aggregator struct { + prover.UnimplementedAggregatorServiceServer + + cfg Config + + state stateInterface + etherman etherman + ethTxManager *ethtxmanager.Client + streamClient *datastreamer.StreamClient + l1Syncr synchronizer.Synchronizer + halted atomic.Bool + + profitabilityChecker aggregatorTxProfitabilityChecker + timeSendFinalProof time.Time + timeCleanupLockedProofs types.Duration + stateDBMutex *sync.Mutex + timeSendFinalProofMutex *sync.RWMutex + + // Data stream handling variables + currentBatchStreamData []byte + currentStreamBatch state.Batch + currentStreamBatchRaw state.BatchRawV2 + currentStreamL2Block state.L2BlockRaw + + finalProof chan finalProofMsg + verifyingProof bool + + srv *grpc.Server + ctx context.Context + exit context.CancelFunc + + sequencerPrivateKey *ecdsa.PrivateKey + aggLayerClient AgglayerClientInterface +} + +// New creates a new aggregator. +func New( + ctx context.Context, + cfg Config, + stateInterface stateInterface, + etherman etherman) (*Aggregator, error) { + var profitabilityChecker aggregatorTxProfitabilityChecker + + switch cfg.TxProfitabilityCheckerType { + case ProfitabilityBase: + profitabilityChecker = NewTxProfitabilityCheckerBase(stateInterface, cfg.IntervalAfterWhichBatchConsolidateAnyway.Duration, cfg.TxProfitabilityMinReward.Int) + case ProfitabilityAcceptAll: + profitabilityChecker = NewTxProfitabilityCheckerAcceptAll(stateInterface, cfg.IntervalAfterWhichBatchConsolidateAnyway.Duration) + } + + // Create ethtxmanager client + cfg.EthTxManager.Log = ethtxlog.Config{ + Environment: ethtxlog.LogEnvironment(cfg.Log.Environment), + Level: cfg.Log.Level, + Outputs: cfg.Log.Outputs, + } + ethTxManager, err := ethtxmanager.New(cfg.EthTxManager) + if err != nil { + log.Fatalf("error creating ethtxmanager client: %v", err) + } + + // Data stream client logs + streamLogConfig := streamlog.Config{ + Environment: streamlog.LogEnvironment(cfg.Log.Environment), + Level: cfg.Log.Level, + Outputs: cfg.Log.Outputs, + } + + log.Init(cfg.Log) + + log.Info("Creating data stream client....") + streamClient, err := datastreamer.NewClientWithLogsConfig(cfg.StreamClient.Server, dataStreamType, streamLogConfig) + if err != nil { + log.Fatalf("failed to create stream client, error: %v", err) + } + log.Info("Data stream client created.") + + // Synchonizer logs + syncLogConfig := synclog.Config{ + Environment: synclog.LogEnvironment(cfg.Log.Environment), + Level: cfg.Log.Level, + Outputs: cfg.Log.Outputs, + } + + cfg.Synchronizer.Log = syncLogConfig + + // Create L1 synchronizer client + cfg.Synchronizer.Etherman.L1URL = cfg.EthTxManager.Etherman.URL + log.Debugf("Creating synchronizer client with config: %+v", cfg.Synchronizer) + l1Syncr, err := synchronizer.NewSynchronizer(ctx, cfg.Synchronizer) + if err != nil { + log.Fatalf("failed to create synchronizer client, error: %v", err) + } + + var ( + aggLayerClient AgglayerClientInterface + sequencerPrivateKey *ecdsa.PrivateKey + ) + + if cfg.SettlementBackend == AggLayer { + aggLayerClient = NewAggLayerClient(cfg.AggLayerURL) + + sequencerPrivateKey, err = newKeyFromKeystore(cfg.SequencerPrivateKey) + if err != nil { + return nil, err + } + } + + a := &Aggregator{ + cfg: cfg, + state: stateInterface, + etherman: etherman, + ethTxManager: ethTxManager, + streamClient: streamClient, + l1Syncr: l1Syncr, + profitabilityChecker: profitabilityChecker, + stateDBMutex: &sync.Mutex{}, + timeSendFinalProofMutex: &sync.RWMutex{}, + timeCleanupLockedProofs: cfg.CleanupLockedProofsInterval, + finalProof: make(chan finalProofMsg), + currentBatchStreamData: []byte{}, + aggLayerClient: aggLayerClient, + sequencerPrivateKey: sequencerPrivateKey, + } + + // Set function to handle the batches from the data stream + a.streamClient.SetProcessEntryFunc(a.handleReceivedDataStream) + a.l1Syncr.SetCallbackOnReorgDone(a.handleReorg) + + return a, nil +} + +func (a *Aggregator) handleReorg(reorgData synchronizer.ReorgExecutionResult) { + log.Warnf("Reorg detected, reorgData: %+v", reorgData) + + ctx := context.Background() + + // Get new latest verified batch number + lastVBatchNumber, err := a.l1Syncr.GetLastestVirtualBatchNumber(ctx) + if err != nil { + log.Errorf("Error getting last virtual batch number: %v", err) + } else { + err = a.state.DeleteBatchesNewerThanBatchNumber(ctx, lastVBatchNumber, nil) + if err != nil { + log.Errorf("Error deleting batches newer than batch number %d: %v", lastVBatchNumber, err) + } + } + + // Halt the aggregator + a.halted.Store(true) + for { + log.Warnf("Halting the aggregator due to a L1 reorg. Reorged data has been delete so it is safe to manually restart the aggregator.") + time.Sleep(10 * time.Second) // nolint:gomnd + } +} + +func (a *Aggregator) handleReceivedDataStream(entry *datastreamer.FileEntry, client *datastreamer.StreamClient, server *datastreamer.StreamServer) error { + ctx := context.Background() + forcedBlockhashL1 := common.Hash{} + + if !a.halted.Load() { + if entry.Type != datastreamer.EntryType(datastreamer.EtBookmark) { + a.currentBatchStreamData = append(a.currentBatchStreamData, entry.Encode()...) + + switch entry.Type { + case datastreamer.EntryType(datastream.EntryType_ENTRY_TYPE_BATCH_START): + batch := &datastream.BatchStart{} + err := proto.Unmarshal(entry.Data, batch) + if err != nil { + log.Errorf("Error unmarshalling batch: %v", err) + return err + } + + a.currentStreamBatch.BatchNumber = batch.Number + a.currentStreamBatch.ChainID = batch.ChainId + a.currentStreamBatch.ForkID = batch.ForkId + a.currentStreamBatch.Type = batch.Type + case datastreamer.EntryType(datastream.EntryType_ENTRY_TYPE_BATCH_END): + batch := &datastream.BatchEnd{} + err := proto.Unmarshal(entry.Data, batch) + if err != nil { + log.Errorf("Error unmarshalling batch: %v", err) + return err + } + + a.currentStreamBatch.LocalExitRoot = common.BytesToHash(batch.LocalExitRoot) + a.currentStreamBatch.StateRoot = common.BytesToHash(batch.StateRoot) + + // Add last block (if any) to the current batch + if a.currentStreamL2Block.BlockNumber != 0 { + a.currentStreamBatchRaw.Blocks = append(a.currentStreamBatchRaw.Blocks, a.currentStreamL2Block) + } + + // Save Current Batch + if a.currentStreamBatch.BatchNumber != 0 { + var batchl2Data []byte + + // Get batchl2Data from L1 + virtualBatch, err := a.l1Syncr.GetVirtualBatchByBatchNumber(ctx, a.currentStreamBatch.BatchNumber) + if err != nil && !errors.Is(err, entities.ErrNotFound) { + log.Errorf("Error getting virtual batch: %v", err) + return err + } + + for errors.Is(err, entities.ErrNotFound) { + log.Debug("Waiting for virtual batch to be available") + time.Sleep(a.cfg.RetryTime.Duration) + virtualBatch, err = a.l1Syncr.GetVirtualBatchByBatchNumber(ctx, a.currentStreamBatch.BatchNumber) + + if err != nil && !errors.Is(err, entities.ErrNotFound) { + log.Errorf("Error getting virtual batch: %v", err) + return err + } + } + + // If the batch is marked as Invalid in the DS we enforce retrieve the data from L1 + if a.cfg.UseL1BatchData || a.currentStreamBatch.Type == datastream.BatchType_BATCH_TYPE_INVALID { + a.currentStreamBatch.BatchL2Data = virtualBatch.BatchL2Data + } else { + batchl2Data, err = state.EncodeBatchV2(&a.currentStreamBatchRaw) + if err != nil { + log.Errorf("Error encoding batch: %v", err) + return err + } + a.currentStreamBatch.BatchL2Data = batchl2Data + } + + if common.Bytes2Hex(batchl2Data) != common.Bytes2Hex(virtualBatch.BatchL2Data) { + log.Warnf("BatchL2Data from L1 and data stream are different for batch %d", a.currentStreamBatch.BatchNumber) + + if a.currentStreamBatch.Type == datastream.BatchType_BATCH_TYPE_INVALID { + log.Warnf("Batch is marked as invalid in data stream") + } else { + log.Warnf("DataStream BatchL2Data:%v", common.Bytes2Hex(batchl2Data)) + } + log.Warnf("L1 BatchL2Data:%v", common.Bytes2Hex(virtualBatch.BatchL2Data)) + } + + // Ger L1InfoRoot + sequence, err := a.l1Syncr.GetSequenceByBatchNumber(ctx, a.currentStreamBatch.BatchNumber) + if err != nil { + log.Errorf("Error getting sequence: %v", err) + return err + } + + for sequence == nil { + log.Debug("Waiting for sequence to be available") + time.Sleep(a.cfg.RetryTime.Duration) + sequence, err = a.l1Syncr.GetSequenceByBatchNumber(ctx, a.currentStreamBatch.BatchNumber) + if err != nil { + log.Errorf("Error getting sequence: %v", err) + return err + } + } + + a.currentStreamBatch.L1InfoRoot = sequence.L1InfoRoot + a.currentStreamBatch.Timestamp = sequence.Timestamp + + // Calculate Acc Input Hash + oldBatch, _, err := a.state.GetBatch(ctx, a.currentStreamBatch.BatchNumber-1, nil) + if err != nil { + log.Errorf("Error getting batch %d: %v", a.currentStreamBatch.BatchNumber-1, err) + return err + } + + // Injected Batch + if a.currentStreamBatch.BatchNumber == 1 { + l1Block, err := a.l1Syncr.GetL1BlockByNumber(ctx, virtualBatch.BlockNumber) + if err != nil { + log.Errorf("Error getting L1 block: %v", err) + return err + } + + forcedBlockhashL1 = l1Block.ParentHash + a.currentStreamBatch.L1InfoRoot = a.currentStreamBatch.GlobalExitRoot + } + + accInputHash, err := calculateAccInputHash(oldBatch.AccInputHash, a.currentStreamBatch.BatchL2Data, a.currentStreamBatch.L1InfoRoot, uint64(a.currentStreamBatch.Timestamp.Unix()), a.currentStreamBatch.Coinbase, forcedBlockhashL1) + if err != nil { + log.Errorf("Error calculating acc input hash: %v", err) + return err + } + + a.currentStreamBatch.AccInputHash = accInputHash + + err = a.state.AddBatch(ctx, &a.currentStreamBatch, a.currentBatchStreamData, nil) + if err != nil { + log.Errorf("Error adding batch: %v", err) + return err + } + } + + // Reset current batch data + a.currentBatchStreamData = []byte{} + a.currentStreamBatchRaw = state.BatchRawV2{ + Blocks: make([]state.L2BlockRaw, 0), + } + a.currentStreamL2Block = state.L2BlockRaw{} + + case datastreamer.EntryType(datastream.EntryType_ENTRY_TYPE_L2_BLOCK): + // Add previous block (if any) to the current batch + if a.currentStreamL2Block.BlockNumber != 0 { + a.currentStreamBatchRaw.Blocks = append(a.currentStreamBatchRaw.Blocks, a.currentStreamL2Block) + } + // "Open" the new block + l2Block := &datastream.L2Block{} + err := proto.Unmarshal(entry.Data, l2Block) + if err != nil { + log.Errorf("Error unmarshalling L2Block: %v", err) + return err + } + + header := state.ChangeL2BlockHeader{ + DeltaTimestamp: l2Block.DeltaTimestamp, + IndexL1InfoTree: l2Block.L1InfotreeIndex, + } + + a.currentStreamL2Block.ChangeL2BlockHeader = header + a.currentStreamL2Block.Transactions = make([]state.L2TxRaw, 0) + a.currentStreamL2Block.BlockNumber = l2Block.Number + a.currentStreamBatch.L1InfoTreeIndex = l2Block.L1InfotreeIndex + a.currentStreamBatch.Coinbase = common.BytesToAddress(l2Block.Coinbase) + a.currentStreamBatch.GlobalExitRoot = common.BytesToHash(l2Block.GlobalExitRoot) + + case datastreamer.EntryType(datastream.EntryType_ENTRY_TYPE_TRANSACTION): + l2Tx := &datastream.Transaction{} + err := proto.Unmarshal(entry.Data, l2Tx) + if err != nil { + log.Errorf("Error unmarshalling L2Tx: %v", err) + return err + } + // New Tx raw + tx, err := state.DecodeTx(common.Bytes2Hex(l2Tx.Encoded)) + if err != nil { + log.Errorf("Error decoding tx: %v", err) + return err + } + + l2TxRaw := state.L2TxRaw{ + EfficiencyPercentage: uint8(l2Tx.EffectiveGasPricePercentage), + TxAlreadyEncoded: false, + Tx: tx, + } + a.currentStreamL2Block.Transactions = append(a.currentStreamL2Block.Transactions, l2TxRaw) + } + } + } + return nil +} + +// Start starts the aggregator +func (a *Aggregator) Start(ctx context.Context) error { + var cancel context.CancelFunc + if ctx == nil { + ctx = context.Background() + } + ctx, cancel = context.WithCancel(ctx) + a.ctx = ctx + a.exit = cancel + + metrics.Register() + + address := fmt.Sprintf("%s:%d", a.cfg.Host, a.cfg.Port) + lis, err := net.Listen("tcp", address) + if err != nil { + log.Fatalf("Failed to listen: %v", err) + } + + a.srv = grpc.NewServer() + prover.RegisterAggregatorServiceServer(a.srv, a) + + healthService := newHealthChecker() + grpchealth.RegisterHealthServer(a.srv, healthService) + + // Initial L1 Sync blocking + err = a.l1Syncr.Sync(true) + if err != nil { + log.Fatalf("Failed to synchronize from L1: %v", err) + return err + } + + // Get last verified batch number to set the starting point for verifications + lastVerifiedBatchNumber, err := a.etherman.GetLatestVerifiedBatchNum() + if err != nil { + return err + } + + // Cleanup data base + err = a.state.DeleteBatchesOlderThanBatchNumber(ctx, lastVerifiedBatchNumber, nil) + if err != nil { + return err + } + + // Delete ungenerated recursive proofs + err = a.state.DeleteUngeneratedProofs(ctx, nil) + if err != nil { + return fmt.Errorf("failed to initialize proofs cache %w", err) + } + + accInputHash, err := a.getVerifiedBatchAccInputHash(ctx, lastVerifiedBatchNumber) + if err != nil { + return err + } + + log.Infof("Last Verified Batch Number:%v", lastVerifiedBatchNumber) + log.Infof("Starting AccInputHash:%v", accInputHash.String()) + + // Store Acc Input Hash of the latest verified batch + dummyBatch := state.Batch{BatchNumber: lastVerifiedBatchNumber, AccInputHash: *accInputHash} + err = a.state.AddBatch(ctx, &dummyBatch, []byte{0}, nil) + if err != nil { + return err + } + + a.resetVerifyProofTime() + + go a.cleanupLockedProofs() + go a.sendFinalProof() + go a.ethTxManager.Start() + + // Keep syncing L1 + go func() { + err := a.l1Syncr.Sync(false) + if err != nil { + log.Fatalf("Failed to synchronize from L1: %v", err) + } + }() + + // Start stream client + err = a.streamClient.Start() + if err != nil { + log.Fatalf("failed to start stream client, error: %v", err) + } + + bookMark := &datastream.BookMark{ + Type: datastream.BookmarkType_BOOKMARK_TYPE_BATCH, + Value: lastVerifiedBatchNumber + 1, + } + + marshalledBookMark, err := proto.Marshal(bookMark) + if err != nil { + log.Fatalf("failed to marshal bookmark: %v", err) + } + + err = a.streamClient.ExecCommandStartBookmark(marshalledBookMark) + if err != nil { + log.Fatalf("failed to connect to data stream: %v", err) + } + + // A this point everything is ready, so start serving + go func() { + log.Infof("Server listening on port %d", a.cfg.Port) + if err := a.srv.Serve(lis); err != nil { + a.exit() + log.Fatalf("Failed to serve: %v", err) + } + }() + + <-ctx.Done() + return ctx.Err() +} + +// Stop stops the Aggregator server. +func (a *Aggregator) Stop() { + a.exit() + a.srv.Stop() +} + +// Channel implements the bi-directional communication channel between the +// Prover client and the Aggregator server. +func (a *Aggregator) Channel(stream prover.AggregatorService_ChannelServer) error { + metrics.ConnectedProver() + defer metrics.DisconnectedProver() + + ctx := stream.Context() + var proverAddr net.Addr + p, ok := peer.FromContext(ctx) + if ok { + proverAddr = p.Addr + } + prover, err := prover.New(stream, proverAddr, a.cfg.ProofStatePollingInterval) + if err != nil { + return err + } + + log := log.WithFields( + "prover", prover.Name(), + "proverId", prover.ID(), + "proverAddr", prover.Addr(), + ) + log.Info("Establishing stream connection with prover") + + // Check if prover supports the required Fork ID + if !prover.SupportsForkID(a.cfg.ForkId) { + err := errors.New("prover does not support required fork ID") + log.Warn(FirstToUpper(err.Error())) + return err + } + + for { + select { + case <-a.ctx.Done(): + // server disconnected + return a.ctx.Err() + case <-ctx.Done(): + // client disconnected + return ctx.Err() + + default: + if !a.halted.Load() { + isIdle, err := prover.IsIdle() + if err != nil { + log.Errorf("Failed to check if prover is idle: %v", err) + time.Sleep(a.cfg.RetryTime.Duration) + continue + } + if !isIdle { + log.Debug("Prover is not idle") + time.Sleep(a.cfg.RetryTime.Duration) + continue + } + + _, err = a.tryBuildFinalProof(ctx, prover, nil) + if err != nil { + log.Errorf("Error checking proofs to verify: %v", err) + } + + proofGenerated, err := a.tryAggregateProofs(ctx, prover) + if err != nil { + log.Errorf("Error trying to aggregate proofs: %v", err) + } + + if !proofGenerated { + proofGenerated, err = a.tryGenerateBatchProof(ctx, prover) + if err != nil { + log.Errorf("Error trying to generate proof: %v", err) + } + } + if !proofGenerated { + // if no proof was generated (aggregated or batch) wait some time before retry + time.Sleep(a.cfg.RetryTime.Duration) + } // if proof was generated we retry immediately as probably we have more proofs to process + } + } + } +} + +// This function waits to receive a final proof from a prover. Once it receives +// the proof, it performs these steps in order: +// - send the final proof to L1 +// - wait for the synchronizer to catch up +// - clean up the cache of recursive proofs +func (a *Aggregator) sendFinalProof() { + for { + select { + case <-a.ctx.Done(): + return + case msg := <-a.finalProof: + ctx := a.ctx + proof := msg.recursiveProof + + log.WithFields("proofId", proof.ProofID, "batches", fmt.Sprintf("%d-%d", proof.BatchNumber, proof.BatchNumberFinal)) + log.Info("Verifying final proof with ethereum smart contract") + + a.startProofVerification() + + finalBatch, _, err := a.state.GetBatch(ctx, proof.BatchNumberFinal, nil) + if err != nil { + log.Errorf("Failed to retrieve batch with number [%d]: %v", proof.BatchNumberFinal, err) + a.endProofVerification() + continue + } + + inputs := ethmanTypes.FinalProofInputs{ + FinalProof: msg.finalProof, + NewLocalExitRoot: finalBatch.LocalExitRoot.Bytes(), + NewStateRoot: finalBatch.StateRoot.Bytes(), + } + + switch a.cfg.SettlementBackend { + case AggLayer: + if success := a.settleWithAggLayer(ctx, proof, inputs); !success { + continue + } + default: + if success := a.settleDirect(ctx, proof, inputs); !success { + continue + } + } + + a.resetVerifyProofTime() + a.endProofVerification() + } + } +} + +func (a *Aggregator) settleWithAggLayer( + ctx context.Context, + proof *state.Proof, + inputs ethmanTypes.FinalProofInputs) bool { + proofStrNo0x := strings.TrimPrefix(inputs.FinalProof.Proof, "0x") + proofBytes := common.Hex2Bytes(proofStrNo0x) + tx := Tx{ + LastVerifiedBatch: cdkTypes.ArgUint64(proof.BatchNumber - 1), + NewVerifiedBatch: cdkTypes.ArgUint64(proof.BatchNumberFinal), + ZKP: ZKP{ + NewStateRoot: common.BytesToHash(inputs.NewStateRoot), + NewLocalExitRoot: common.BytesToHash(inputs.NewLocalExitRoot), + Proof: cdkTypes.ArgBytes(proofBytes), + }, + RollupID: a.etherman.GetRollupId(), + } + signedTx, err := tx.Sign(a.sequencerPrivateKey) + if err != nil { + log.Errorf("failed to sign tx: %v", err) + a.handleFailureToAddVerifyBatchToBeMonitored(ctx, proof) + + return false + } + + log.Debug("final proof signedTx: ", signedTx.Tx.ZKP.Proof.Hex()) + txHash, err := a.aggLayerClient.SendTx(*signedTx) + if err != nil { + log.Errorf("failed to send tx to the agglayer: %v", err) + a.handleFailureToAddVerifyBatchToBeMonitored(ctx, proof) + + return false + } + + log.Infof("tx %s sent to agglayer, waiting to be mined", txHash.Hex()) + log.Debugf("Timeout set to %f seconds", a.cfg.AggLayerTxTimeout.Duration.Seconds()) + waitCtx, cancelFunc := context.WithDeadline(ctx, time.Now().Add(a.cfg.AggLayerTxTimeout.Duration)) + defer cancelFunc() + if err := a.aggLayerClient.WaitTxToBeMined(txHash, waitCtx); err != nil { + log.Errorf("agglayer didn't mine the tx: %v", err) + a.handleFailureToAddVerifyBatchToBeMonitored(ctx, proof) + + return false + } + + return true +} + +// settleDirect sends the final proof to the L1 smart contract directly. +func (a *Aggregator) settleDirect( + ctx context.Context, + proof *state.Proof, + inputs ethmanTypes.FinalProofInputs) bool { + // add batch verification to be monitored + sender := common.HexToAddress(a.cfg.SenderAddress) + to, data, err := a.etherman.BuildTrustedVerifyBatchesTxData(proof.BatchNumber-1, proof.BatchNumberFinal, &inputs, sender) + if err != nil { + log.Errorf("Error estimating batch verification to add to eth tx manager: %v", err) + a.handleFailureToAddVerifyBatchToBeMonitored(ctx, proof) + return false + } + + monitoredTxID, err := a.ethTxManager.Add(ctx, to, nil, big.NewInt(0), data, a.cfg.GasOffset, nil) + if err != nil { + log.Errorf("Error Adding TX to ethTxManager: %v", err) + mTxLogger := ethtxmanager.CreateLogger(monitoredTxID, sender, to) + mTxLogger.Errorf("Error to add batch verification tx to eth tx manager: %v", err) + a.handleFailureToAddVerifyBatchToBeMonitored(ctx, proof) + return false + } + + // process monitored batch verifications before starting a next cycle + a.ethTxManager.ProcessPendingMonitoredTxs(ctx, func(result ethtxmanager.MonitoredTxResult) { + a.handleMonitoredTxResult(result) + }) + + return true +} + +func (a *Aggregator) handleFailureToAddVerifyBatchToBeMonitored(ctx context.Context, proof *state.Proof) { + log := log.WithFields("proofId", proof.ProofID, "batches", fmt.Sprintf("%d-%d", proof.BatchNumber, proof.BatchNumberFinal)) + proof.GeneratingSince = nil + err := a.state.UpdateGeneratedProof(ctx, proof, nil) + if err != nil { + log.Errorf("Failed updating proof state (false): %v", err) + } + a.endProofVerification() +} + +// buildFinalProof builds and return the final proof for an aggregated/batch proof. +func (a *Aggregator) buildFinalProof(ctx context.Context, prover proverInterface, proof *state.Proof) (*prover.FinalProof, error) { + log := log.WithFields( + "prover", prover.Name(), + "proverId", prover.ID(), + "proverAddr", prover.Addr(), + "recursiveProofId", *proof.ProofID, + "batches", fmt.Sprintf("%d-%d", proof.BatchNumber, proof.BatchNumberFinal), + ) + + finalProofID, err := prover.FinalProof(proof.Proof, a.cfg.SenderAddress) + if err != nil { + return nil, fmt.Errorf("failed to get final proof id: %w", err) + } + proof.ProofID = finalProofID + + log.Infof("Final proof ID for batches [%d-%d]: %s", proof.BatchNumber, proof.BatchNumberFinal, *proof.ProofID) + log = log.WithFields("finalProofId", finalProofID) + + finalProof, err := prover.WaitFinalProof(ctx, *proof.ProofID) + if err != nil { + return nil, fmt.Errorf("failed to get final proof from prover: %w", err) + } + + // mock prover sanity check + if string(finalProof.Public.NewStateRoot) == mockedStateRoot && string(finalProof.Public.NewLocalExitRoot) == mockedLocalExitRoot { + // This local exit root and state root come from the mock + // prover, use the one captured by the executor instead + finalBatch, _, err := a.state.GetBatch(ctx, proof.BatchNumberFinal, nil) + if err != nil { + return nil, fmt.Errorf("failed to retrieve batch with number [%d]", proof.BatchNumberFinal) + } + log.Warnf("NewLocalExitRoot and NewStateRoot look like a mock values, using values from executor instead: LER: %v, SR: %v", + finalBatch.LocalExitRoot.TerminalString(), finalBatch.StateRoot.TerminalString()) + finalProof.Public.NewStateRoot = finalBatch.StateRoot.Bytes() + finalProof.Public.NewLocalExitRoot = finalBatch.LocalExitRoot.Bytes() + } + + // Sanity Check: state root from the proof must match the one from the final batch + finalBatch, _, err := a.state.GetBatch(ctx, proof.BatchNumberFinal, nil) + if err != nil { + return nil, fmt.Errorf("failed to retrieve batch with number [%d]", proof.BatchNumberFinal) + } + + if !bytes.Equal(finalProof.Public.NewStateRoot, finalBatch.StateRoot.Bytes()) { + for { + log.Errorf("State root from the proof [%#x] does not match the one from the batch [%#x]. HALTED", finalProof.Public.NewStateRoot, finalBatch.StateRoot.Bytes()) + time.Sleep(a.cfg.RetryTime.Duration) + } + } + + return finalProof, nil +} + +// tryBuildFinalProof checks if the provided proof is eligible to be used to +// build the final proof. If no proof is provided it looks for a previously +// generated proof. If the proof is eligible, then the final proof generation +// is triggered. +func (a *Aggregator) tryBuildFinalProof(ctx context.Context, prover proverInterface, proof *state.Proof) (bool, error) { + proverName := prover.Name() + proverID := prover.ID() + + log := log.WithFields( + "prover", proverName, + "proverId", proverID, + "proverAddr", prover.Addr(), + ) + log.Debug("tryBuildFinalProof start") + + var err error + if !a.canVerifyProof() { + log.Debug("Time to verify proof not reached or proof verification in progress") + return false, nil + } + log.Debug("Send final proof time reached") + + lastVerifiedBatchNumber, err := a.etherman.GetLatestVerifiedBatchNum() + if err != nil { + return false, err + } + + if proof == nil { + // we don't have a proof generating at the moment, check if we + // have a proof ready to verify + + proof, err = a.getAndLockProofReadyToVerify(ctx, prover, lastVerifiedBatchNumber) + if errors.Is(err, state.ErrNotFound) { + // nothing to verify, swallow the error + log.Debug("No proof ready to verify") + return false, nil + } + if err != nil { + return false, err + } + + defer func() { + if err != nil { + // Set the generating state to false for the proof ("unlock" it) + proof.GeneratingSince = nil + err2 := a.state.UpdateGeneratedProof(a.ctx, proof, nil) + if err2 != nil { + log.Errorf("Failed to unlock proof: %v", err2) + } + } + }() + } else { + // we do have a proof generating at the moment, check if it is + // eligible to be verified + eligible, err := a.validateEligibleFinalProof(ctx, proof, lastVerifiedBatchNumber) + if err != nil { + return false, fmt.Errorf("failed to validate eligible final proof, %w", err) + } + if !eligible { + return false, nil + } + } + + log = log.WithFields( + "proofId", *proof.ProofID, + "batches", fmt.Sprintf("%d-%d", proof.BatchNumber, proof.BatchNumberFinal), + ) + + // at this point we have an eligible proof, build the final one using it + finalProof, err := a.buildFinalProof(ctx, prover, proof) + if err != nil { + err = fmt.Errorf("failed to build final proof, %w", err) + log.Error(FirstToUpper(err.Error())) + return false, err + } + + msg := finalProofMsg{ + proverName: proverName, + proverID: proverID, + recursiveProof: proof, + finalProof: finalProof, + } + + select { + case <-a.ctx.Done(): + return false, a.ctx.Err() + case a.finalProof <- msg: + } + + log.Debug("tryBuildFinalProof end") + return true, nil +} + +func (a *Aggregator) validateEligibleFinalProof(ctx context.Context, proof *state.Proof, lastVerifiedBatchNum uint64) (bool, error) { + batchNumberToVerify := lastVerifiedBatchNum + 1 + + if proof.BatchNumber != batchNumberToVerify { + if proof.BatchNumber < batchNumberToVerify && proof.BatchNumberFinal >= batchNumberToVerify { + // We have a proof that contains some batches below the last batch verified, anyway can be eligible as final proof + log.Warnf("Proof %d-%d contains some batches lower than last batch verified %d. Check anyway if it is eligible", proof.BatchNumber, proof.BatchNumberFinal, lastVerifiedBatchNum) + } else if proof.BatchNumberFinal < batchNumberToVerify { + // We have a proof that contains batches below that the last batch verified, we need to delete this proof + log.Warnf("Proof %d-%d lower than next batch to verify %d. Deleting it", proof.BatchNumber, proof.BatchNumberFinal, batchNumberToVerify) + err := a.state.DeleteGeneratedProofs(ctx, proof.BatchNumber, proof.BatchNumberFinal, nil) + if err != nil { + return false, fmt.Errorf("failed to delete discarded proof, err: %w", err) + } + return false, nil + } else { + log.Debugf("Proof batch number %d is not the following to last verfied batch number %d", proof.BatchNumber, lastVerifiedBatchNum) + return false, nil + } + } + + bComplete, err := a.state.CheckProofContainsCompleteSequences(ctx, proof, nil) + if err != nil { + return false, fmt.Errorf("failed to check if proof contains complete sequences, %w", err) + } + if !bComplete { + log.Infof("Recursive proof %d-%d not eligible to be verified: not containing complete sequences", proof.BatchNumber, proof.BatchNumberFinal) + return false, nil + } + return true, nil +} + +func (a *Aggregator) getAndLockProofReadyToVerify(ctx context.Context, prover proverInterface, lastVerifiedBatchNum uint64) (*state.Proof, error) { + a.stateDBMutex.Lock() + defer a.stateDBMutex.Unlock() + + // Get proof ready to be verified + proofToVerify, err := a.state.GetProofReadyToVerify(ctx, lastVerifiedBatchNum, nil) + if err != nil { + return nil, err + } + + now := time.Now().Round(time.Microsecond) + proofToVerify.GeneratingSince = &now + + err = a.state.UpdateGeneratedProof(ctx, proofToVerify, nil) + if err != nil { + return nil, err + } + + return proofToVerify, nil +} + +func (a *Aggregator) unlockProofsToAggregate(ctx context.Context, proof1 *state.Proof, proof2 *state.Proof) error { + // Release proofs from generating state in a single transaction + dbTx, err := a.state.BeginStateTransaction(ctx) + if err != nil { + log.Warnf("Failed to begin transaction to release proof aggregation state, err: %v", err) + return err + } + + proof1.GeneratingSince = nil + err = a.state.UpdateGeneratedProof(ctx, proof1, dbTx) + if err == nil { + proof2.GeneratingSince = nil + err = a.state.UpdateGeneratedProof(ctx, proof2, dbTx) + } + + if err != nil { + if err := dbTx.Rollback(ctx); err != nil { + err := fmt.Errorf("failed to rollback proof aggregation state: %w", err) + log.Error(FirstToUpper(err.Error())) + return err + } + return fmt.Errorf("failed to release proof aggregation state: %w", err) + } + + err = dbTx.Commit(ctx) + if err != nil { + return fmt.Errorf("failed to release proof aggregation state %w", err) + } + + return nil +} + +func (a *Aggregator) getAndLockProofsToAggregate(ctx context.Context, prover proverInterface) (*state.Proof, *state.Proof, error) { + log := log.WithFields( + "prover", prover.Name(), + "proverId", prover.ID(), + "proverAddr", prover.Addr(), + ) + + a.stateDBMutex.Lock() + defer a.stateDBMutex.Unlock() + + proof1, proof2, err := a.state.GetProofsToAggregate(ctx, nil) + if err != nil { + return nil, nil, err + } + + // Set proofs in generating state in a single transaction + dbTx, err := a.state.BeginStateTransaction(ctx) + if err != nil { + log.Errorf("Failed to begin transaction to set proof aggregation state, err: %v", err) + return nil, nil, err + } + + now := time.Now().Round(time.Microsecond) + proof1.GeneratingSince = &now + err = a.state.UpdateGeneratedProof(ctx, proof1, dbTx) + if err == nil { + proof2.GeneratingSince = &now + err = a.state.UpdateGeneratedProof(ctx, proof2, dbTx) + } + + if err != nil { + if err := dbTx.Rollback(ctx); err != nil { + err := fmt.Errorf("failed to rollback proof aggregation state %w", err) + log.Error(FirstToUpper(err.Error())) + return nil, nil, err + } + return nil, nil, fmt.Errorf("failed to set proof aggregation state %w", err) + } + + err = dbTx.Commit(ctx) + if err != nil { + return nil, nil, fmt.Errorf("failed to set proof aggregation state %w", err) + } + + return proof1, proof2, nil +} + +func (a *Aggregator) tryAggregateProofs(ctx context.Context, prover proverInterface) (bool, error) { + proverName := prover.Name() + proverID := prover.ID() + + log := log.WithFields( + "prover", proverName, + "proverId", proverID, + "proverAddr", prover.Addr(), + ) + log.Debug("tryAggregateProofs start") + + proof1, proof2, err0 := a.getAndLockProofsToAggregate(ctx, prover) + if errors.Is(err0, state.ErrNotFound) { + // nothing to aggregate, swallow the error + log.Debug("Nothing to aggregate") + return false, nil + } + if err0 != nil { + return false, err0 + } + + var ( + aggrProofID *string + err error + ) + + defer func() { + if err != nil { + err2 := a.unlockProofsToAggregate(a.ctx, proof1, proof2) + if err2 != nil { + log.Errorf("Failed to release aggregated proofs, err: %v", err2) + } + } + log.Debug("tryAggregateProofs end") + }() + + log.Infof("Aggregating proofs: %d-%d and %d-%d", proof1.BatchNumber, proof1.BatchNumberFinal, proof2.BatchNumber, proof2.BatchNumberFinal) + + batches := fmt.Sprintf("%d-%d", proof1.BatchNumber, proof2.BatchNumberFinal) + log = log.WithFields("batches", batches) + + inputProver := map[string]interface{}{ + "recursive_proof_1": proof1.Proof, + "recursive_proof_2": proof2.Proof, + } + b, err := json.Marshal(inputProver) + if err != nil { + err = fmt.Errorf("failed to serialize input prover, %w", err) + log.Error(FirstToUpper(err.Error())) + return false, err + } + + proof := &state.Proof{ + BatchNumber: proof1.BatchNumber, + BatchNumberFinal: proof2.BatchNumberFinal, + Prover: &proverName, + ProverID: &proverID, + InputProver: string(b), + } + + aggrProofID, err = prover.AggregatedProof(proof1.Proof, proof2.Proof) + if err != nil { + err = fmt.Errorf("failed to get aggregated proof id, %w", err) + log.Error(FirstToUpper(err.Error())) + return false, err + } + + proof.ProofID = aggrProofID + + log.Infof("Proof ID for aggregated proof: %v", *proof.ProofID) + log = log.WithFields("proofId", *proof.ProofID) + + recursiveProof, err := prover.WaitRecursiveProof(ctx, *proof.ProofID) + if err != nil { + err = fmt.Errorf("failed to get aggregated proof from prover, %w", err) + log.Error(FirstToUpper(err.Error())) + return false, err + } + + log.Info("Aggregated proof generated") + + proof.Proof = recursiveProof + + // update the state by removing the 2 aggregated proofs and storing the + // newly generated recursive proof + dbTx, err := a.state.BeginStateTransaction(ctx) + if err != nil { + err = fmt.Errorf("failed to begin transaction to update proof aggregation state, %w", err) + log.Error(FirstToUpper(err.Error())) + return false, err + } + + err = a.state.DeleteGeneratedProofs(ctx, proof1.BatchNumber, proof2.BatchNumberFinal, dbTx) + if err != nil { + if err := dbTx.Rollback(ctx); err != nil { + err := fmt.Errorf("failed to rollback proof aggregation state, %w", err) + log.Error(FirstToUpper(err.Error())) + return false, err + } + err = fmt.Errorf("failed to delete previously aggregated proofs, %w", err) + log.Error(FirstToUpper(err.Error())) + return false, err + } + + now := time.Now().Round(time.Microsecond) + proof.GeneratingSince = &now + + err = a.state.AddGeneratedProof(ctx, proof, dbTx) + if err != nil { + if err := dbTx.Rollback(ctx); err != nil { + err := fmt.Errorf("failed to rollback proof aggregation state, %w", err) + log.Error(FirstToUpper(err.Error())) + return false, err + } + err = fmt.Errorf("failed to store the recursive proof, %w", err) + log.Error(FirstToUpper(err.Error())) + return false, err + } + + err = dbTx.Commit(ctx) + if err != nil { + err = fmt.Errorf("failed to store the recursive proof, %w", err) + log.Error(FirstToUpper(err.Error())) + return false, err + } + + // NOTE(pg): the defer func is useless from now on, use a different variable + // name for errors (or shadow err in inner scopes) to not trigger it. + + // state is up to date, check if we can send the final proof using the + // one just crafted. + finalProofBuilt, finalProofErr := a.tryBuildFinalProof(ctx, prover, proof) + if finalProofErr != nil { + // just log the error and continue to handle the aggregated proof + log.Errorf("Failed trying to check if recursive proof can be verified: %v", finalProofErr) + } + + // NOTE(pg): prover is done, use a.ctx from now on + + if !finalProofBuilt { + proof.GeneratingSince = nil + + // final proof has not been generated, update the recursive proof + err := a.state.UpdateGeneratedProof(a.ctx, proof, nil) + if err != nil { + err = fmt.Errorf("failed to store batch proof result, %w", err) + log.Error(FirstToUpper(err.Error())) + return false, err + } + } + + return true, nil +} + +func (a *Aggregator) getVerifiedBatchAccInputHash(ctx context.Context, batchNumber uint64) (*common.Hash, error) { + accInputHash, err := a.etherman.GetBatchAccInputHash(ctx, batchNumber) + if err != nil { + return nil, err + } + + return &accInputHash, nil +} + +func (a *Aggregator) getAndLockBatchToProve(ctx context.Context, prover proverInterface) (*state.Batch, *state.Proof, error) { + proverID := prover.ID() + proverName := prover.Name() + + log := log.WithFields( + "prover", proverName, + "proverId", proverID, + "proverAddr", prover.Addr(), + ) + + a.stateDBMutex.Lock() + defer a.stateDBMutex.Unlock() + + // Get last virtual batch number from L1 + lastVerifiedBatchNumber, err := a.etherman.GetLatestVerifiedBatchNum() + if err != nil { + return nil, nil, err + } + + proofExists := true + batchNumberToVerify := lastVerifiedBatchNumber + + // Look for the batch number to verify + for proofExists { + batchNumberToVerify++ + proofExists, err = a.state.CheckProofExistsForBatch(ctx, batchNumberToVerify, nil) + if err != nil { + log.Infof("Error checking proof exists for batch %d", batchNumberToVerify) + return nil, nil, err + } + } + + // Check if the batch has been sequenced + sequence, err := a.l1Syncr.GetSequenceByBatchNumber(ctx, batchNumberToVerify) + if err != nil && !errors.Is(err, entities.ErrNotFound) { + return nil, nil, err + } + + // Not found, so it it not possible to verify the batch yet + if sequence == nil || errors.Is(err, entities.ErrNotFound) { + log.Infof("No sequence found for batch %d", batchNumberToVerify) + return nil, nil, state.ErrNotFound + } + + stateSequence := state.Sequence{ + FromBatchNumber: sequence.FromBatchNumber, + ToBatchNumber: sequence.ToBatchNumber, + } + + err = a.state.AddSequence(ctx, stateSequence, nil) + if err != nil { + log.Infof("Error storing sequence for batch %d", batchNumberToVerify) + return nil, nil, err + } + + batch, _, err := a.state.GetBatch(ctx, batchNumberToVerify, nil) + if err != nil { + return batch, nil, err + } + + // All the data required to generate a proof is ready + log.Infof("Found virtual batch %d pending to generate proof", batch.BatchNumber) + log = log.WithFields("batch", batch.BatchNumber) + + log.Info("Checking profitability to aggregate batch") + + // pass pol collateral as zero here, bcs in smart contract fee for aggregator is not defined yet + isProfitable, err := a.profitabilityChecker.IsProfitable(ctx, big.NewInt(0)) + if err != nil { + log.Errorf("Failed to check aggregator profitability, err: %v", err) + return nil, nil, err + } + + if !isProfitable { + log.Infof("Batch is not profitable, pol collateral %d", big.NewInt(0)) + return nil, nil, err + } + + now := time.Now().Round(time.Microsecond) + proof := &state.Proof{ + BatchNumber: batch.BatchNumber, + BatchNumberFinal: batch.BatchNumber, + Prover: &proverName, + ProverID: &proverID, + GeneratingSince: &now, + } + + // Avoid other prover to process the same batch + err = a.state.AddGeneratedProof(ctx, proof, nil) + if err != nil { + log.Errorf("Failed to add batch proof, err: %v", err) + return nil, nil, err + } + + return batch, proof, nil +} + +func (a *Aggregator) tryGenerateBatchProof(ctx context.Context, prover proverInterface) (bool, error) { + log := log.WithFields( + "prover", prover.Name(), + "proverId", prover.ID(), + "proverAddr", prover.Addr(), + ) + log.Debug("tryGenerateBatchProof start") + + batchToProve, proof, err0 := a.getAndLockBatchToProve(ctx, prover) + if errors.Is(err0, state.ErrNotFound) { + // nothing to proof, swallow the error + log.Debug("Nothing to generate proof") + return false, nil + } + if err0 != nil { + return false, err0 + } + + log = log.WithFields("batch", batchToProve.BatchNumber) + + var ( + genProofID *string + err error + ) + + defer func() { + if err != nil { + log.Debug("Deleting proof in progress") + err2 := a.state.DeleteGeneratedProofs(a.ctx, proof.BatchNumber, proof.BatchNumberFinal, nil) + if err2 != nil { + log.Errorf("Failed to delete proof in progress, err: %v", err2) + } + } + log.Debug("tryGenerateBatchProof end") + }() + + log.Infof("Sending zki + batch to the prover, batchNumber [%d]", batchToProve.BatchNumber) + inputProver, err := a.buildInputProver(ctx, batchToProve) + if err != nil { + err = fmt.Errorf("failed to build input prover, %w", err) + log.Error(FirstToUpper(err.Error())) + return false, err + } + + log.Infof("Sending a batch to the prover. OldAccInputHash [%#x], L1InfoRoot [%#x]", + inputProver.PublicInputs.OldAccInputHash, inputProver.PublicInputs.L1InfoRoot) + + genProofID, err = prover.BatchProof(inputProver) + if err != nil { + err = fmt.Errorf("failed to get batch proof id, %w", err) + log.Error(FirstToUpper(err.Error())) + return false, err + } + + proof.ProofID = genProofID + + log = log.WithFields("proofId", *proof.ProofID) + + resGetProof, err := prover.WaitRecursiveProof(ctx, *proof.ProofID) + if err != nil { + err = fmt.Errorf("failed to get proof from prover, %w", err) + log.Error(FirstToUpper(err.Error())) + return false, err + } + + log.Info("Batch proof generated") + + proof.Proof = resGetProof + + // NOTE(pg): the defer func is useless from now on, use a different variable + // name for errors (or shadow err in inner scopes) to not trigger it. + + finalProofBuilt, finalProofErr := a.tryBuildFinalProof(ctx, prover, proof) + if finalProofErr != nil { + // just log the error and continue to handle the generated proof + log.Errorf("Error trying to build final proof: %v", finalProofErr) + } + + // NOTE(pg): prover is done, use a.ctx from now on + + if !finalProofBuilt { + proof.GeneratingSince = nil + + // final proof has not been generated, update the batch proof + err := a.state.UpdateGeneratedProof(a.ctx, proof, nil) + if err != nil { + err = fmt.Errorf("failed to store batch proof result, %w", err) + log.Error(FirstToUpper(err.Error())) + return false, err + } + } + + return true, nil +} + +// canVerifyProof returns true if we have reached the timeout to verify a proof +// and no other prover is verifying a proof (verifyingProof = false). +func (a *Aggregator) canVerifyProof() bool { + a.timeSendFinalProofMutex.RLock() + defer a.timeSendFinalProofMutex.RUnlock() + return a.timeSendFinalProof.Before(time.Now()) && !a.verifyingProof +} + +// startProofVerification sets to true the verifyingProof variable to indicate that there is a proof verification in progress +func (a *Aggregator) startProofVerification() { + a.timeSendFinalProofMutex.Lock() + defer a.timeSendFinalProofMutex.Unlock() + a.verifyingProof = true +} + +// endProofVerification set verifyingProof to false to indicate that there is not proof verification in progress +func (a *Aggregator) endProofVerification() { + a.timeSendFinalProofMutex.Lock() + defer a.timeSendFinalProofMutex.Unlock() + a.verifyingProof = false +} + +// resetVerifyProofTime updates the timeout to verify a proof. +func (a *Aggregator) resetVerifyProofTime() { + a.timeSendFinalProofMutex.Lock() + defer a.timeSendFinalProofMutex.Unlock() + a.timeSendFinalProof = time.Now().Add(a.cfg.VerifyProofInterval.Duration) +} + +func (a *Aggregator) buildInputProver(ctx context.Context, batchToVerify *state.Batch) (*prover.StatelessInputProver, error) { + isForcedBatch := false + batchRawData := &state.BatchRawV2{} + var err error + + if batchToVerify.BatchNumber == 1 || batchToVerify.ForcedBatchNum != nil { + isForcedBatch = true + } else { + batchRawData, err = state.DecodeBatchV2(batchToVerify.BatchL2Data) + if err != nil { + log.Errorf("Failed to decode batch data, err: %v", err) + return nil, err + } + } + + l1InfoTreeData := map[uint32]*prover.L1Data{} + forcedBlockhashL1 := common.Hash{} + l1InfoRoot := batchToVerify.L1InfoRoot.Bytes() + if !isForcedBatch { + tree, err := l1infotree.NewL1InfoTree(32, [][32]byte{}) // nolint:gomnd + if err != nil { + return nil, err + } + + leaves, err := a.l1Syncr.GetLeafsByL1InfoRoot(ctx, batchToVerify.L1InfoRoot) + if err != nil && !errors.Is(err, entities.ErrNotFound) { + return nil, err + } + + aLeaves := make([][32]byte, len(leaves)) + for i, leaf := range leaves { + aLeaves[i] = l1infotree.HashLeafData(leaf.GlobalExitRoot, leaf.PreviousBlockHash, uint64(leaf.Timestamp.Unix())) + } + + for _, l2blockRaw := range batchRawData.Blocks { + _, contained := l1InfoTreeData[l2blockRaw.IndexL1InfoTree] + if !contained && l2blockRaw.IndexL1InfoTree != 0 { + leaves, err := a.l1Syncr.GetL1InfoTreeLeaves(ctx, []uint32{l2blockRaw.IndexL1InfoTree}) + if err != nil { + log.Errorf("Error getting l1InfoTreeLeaf: %v", err) + return nil, err + } + + l1InfoTreeLeaf := leaves[l2blockRaw.IndexL1InfoTree] + + // Calculate smt proof + log.Infof("Calling tree.ComputeMerkleProof") + smtProof, calculatedL1InfoRoot, err := tree.ComputeMerkleProof(l2blockRaw.IndexL1InfoTree, aLeaves) + if err != nil { + log.Errorf("Error computing merkle proof: %v", err) + return nil, err + } + + if batchToVerify.L1InfoRoot != calculatedL1InfoRoot { + return nil, fmt.Errorf("error: l1InfoRoot mismatch. L1InfoRoot: %s, calculatedL1InfoRoot: %s. l1InfoTreeIndex: %d", batchToVerify.L1InfoRoot.String(), calculatedL1InfoRoot.String(), l2blockRaw.IndexL1InfoTree) + } + + protoProof := make([][]byte, len(smtProof)) + for i, proof := range smtProof { + tmpProof := proof + protoProof[i] = tmpProof[:] + } + + l1InfoTreeData[l2blockRaw.IndexL1InfoTree] = &prover.L1Data{ + GlobalExitRoot: l1InfoTreeLeaf.GlobalExitRoot.Bytes(), + BlockhashL1: l1InfoTreeLeaf.PreviousBlockHash.Bytes(), + MinTimestamp: uint32(l1InfoTreeLeaf.Timestamp.Unix()), + SmtProof: protoProof, + } + } + } + } else { + // Initial batch must be handled differently + if batchToVerify.BatchNumber == 1 { + virtualBatch, err := a.l1Syncr.GetVirtualBatchByBatchNumber(ctx, batchToVerify.BatchNumber) + if err != nil { + log.Errorf("Error getting virtual batch: %v", err) + return nil, err + } + l1Block, err := a.l1Syncr.GetL1BlockByNumber(ctx, virtualBatch.BlockNumber) + if err != nil { + log.Errorf("Error getting l1 block: %v", err) + return nil, err + } + + forcedBlockhashL1 = l1Block.ParentHash + l1InfoRoot = batchToVerify.GlobalExitRoot.Bytes() + } /*else { + forcedBlockhashL1, err = a.state.GetForcedBatchParentHash(ctx, *batchToVerify.ForcedBatchNum, nil) + if err != nil { + return nil, err + } + }*/ + } + + // Get Witness + witness, err := getWitness(batchToVerify.BatchNumber, a.cfg.WitnessURL, a.cfg.UseFullWitness) + if err != nil { + log.Errorf("Failed to get witness, err: %v", err) + return nil, err + } + + // Check Witness length + if len(witness) > 100*1204 && !a.cfg.UseFullWitness { // nolint: gomnd + log.Warnf("Witness length is %d bytes. Check full witness configuration on %s", len(witness), a.cfg.WitnessURL) + } + + // Get Old Acc Input Hash + oldBatch, _, err := a.state.GetBatch(ctx, batchToVerify.BatchNumber-1, nil) + if err != nil { + return nil, err + } + + inputProver := &prover.StatelessInputProver{ + PublicInputs: &prover.StatelessPublicInputs{ + Witness: witness, + OldAccInputHash: oldBatch.AccInputHash.Bytes(), + OldBatchNum: batchToVerify.BatchNumber - 1, + ChainId: batchToVerify.ChainID, + ForkId: batchToVerify.ForkID, + BatchL2Data: batchToVerify.BatchL2Data, + L1InfoRoot: l1InfoRoot, + TimestampLimit: uint64(batchToVerify.Timestamp.Unix()), + SequencerAddr: batchToVerify.Coinbase.String(), + AggregatorAddr: a.cfg.SenderAddress, + L1InfoTreeData: l1InfoTreeData, + ForcedBlockhashL1: forcedBlockhashL1.Bytes(), + }, + } + + printInputProver(inputProver) + return inputProver, nil +} + +func calculateAccInputHash(oldAccInputHash common.Hash, batchData []byte, l1InfoRoot common.Hash, timestampLimit uint64, sequencerAddr common.Address, forcedBlockhashL1 common.Hash) (common.Hash, error) { + v1 := oldAccInputHash.Bytes() + v2 := batchData + v3 := l1InfoRoot.Bytes() + v4 := big.NewInt(0).SetUint64(timestampLimit).Bytes() + v5 := sequencerAddr.Bytes() + v6 := forcedBlockhashL1.Bytes() + + // Add 0s to make values 32 bytes long + for len(v1) < 32 { + v1 = append([]byte{0}, v1...) + } + for len(v3) < 32 { + v3 = append([]byte{0}, v3...) + } + for len(v4) < 8 { + v4 = append([]byte{0}, v4...) + } + for len(v5) < 20 { + v5 = append([]byte{0}, v5...) + } + for len(v6) < 32 { + v6 = append([]byte{0}, v6...) + } + + v2 = keccak256.Hash(v2) + + log.Debugf("OldAccInputHash: %v", oldAccInputHash) + log.Debugf("BatchHashData: %v", common.Bytes2Hex(v2)) + log.Debugf("L1InfoRoot: %v", l1InfoRoot) + log.Debugf("TimeStampLimit: %v", timestampLimit) + log.Debugf("Sequencer Address: %v", sequencerAddr) + log.Debugf("Forced BlockHashL1: %v", forcedBlockhashL1) + + return common.BytesToHash(keccak256.Hash(v1, v2, v3, v4, v5, v6)), nil +} + +func getWitness(batchNumber uint64, URL string, fullWitness bool) ([]byte, error) { + var witness string + var response rpc.Response + var err error + + if fullWitness { + response, err = rpc.JSONRPCCall(URL, "zkevm_getBatchWitness", "1", batchNumber, "full") + if err != nil { + return nil, err + } + } else { + response, err = rpc.JSONRPCCall(URL, "zkevm_getBatchWitness", "batch-1", batchNumber) + if err != nil { + return nil, err + } + } + + err = json.Unmarshal(response.Result, &witness) + if err != nil { + return nil, err + } + + witnessString := strings.TrimLeft(witness, "0x") + if len(witnessString)%2 != 0 { + witnessString = "0" + witnessString + } + bytes := common.Hex2Bytes(witnessString) + + return bytes, nil +} + +func printInputProver(inputProver *prover.StatelessInputProver) { + log.Debugf("Witness length: %v", len(inputProver.PublicInputs.Witness)) + log.Debugf("BatchL2Data length: %v", len(inputProver.PublicInputs.BatchL2Data)) + // log.Debugf("Full DataStream: %v", common.Bytes2Hex(inputProver.PublicInputs.DataStream)) + log.Debugf("OldAccInputHash: %v", common.BytesToHash(inputProver.PublicInputs.OldAccInputHash)) + log.Debugf("L1InfoRoot: %v", common.BytesToHash(inputProver.PublicInputs.L1InfoRoot)) + log.Debugf("TimestampLimit: %v", inputProver.PublicInputs.TimestampLimit) + log.Debugf("SequencerAddr: %v", inputProver.PublicInputs.SequencerAddr) + log.Debugf("AggregatorAddr: %v", inputProver.PublicInputs.AggregatorAddr) + log.Debugf("L1InfoTreeData: %+v", inputProver.PublicInputs.L1InfoTreeData) + log.Debugf("ForcedBlockhashL1: %v", common.BytesToHash(inputProver.PublicInputs.ForcedBlockhashL1)) +} + +// healthChecker will provide an implementation of the HealthCheck interface. +type healthChecker struct{} + +// newHealthChecker returns a health checker according to standard package +// grpc.health.v1. +func newHealthChecker() *healthChecker { + return &healthChecker{} +} + +// HealthCheck interface implementation. + +// Check returns the current status of the server for unary gRPC health requests, +// for now if the server is up and able to respond we will always return SERVING. +func (hc *healthChecker) Check(ctx context.Context, req *grpchealth.HealthCheckRequest) (*grpchealth.HealthCheckResponse, error) { + log.Info("Serving the Check request for health check") + return &grpchealth.HealthCheckResponse{ + Status: grpchealth.HealthCheckResponse_SERVING, + }, nil +} + +// Watch returns the current status of the server for stream gRPC health requests, +// for now if the server is up and able to respond we will always return SERVING. +func (hc *healthChecker) Watch(req *grpchealth.HealthCheckRequest, server grpchealth.Health_WatchServer) error { + log.Info("Serving the Watch request for health check") + return server.Send(&grpchealth.HealthCheckResponse{ + Status: grpchealth.HealthCheckResponse_SERVING, + }) +} + +func (a *Aggregator) handleMonitoredTxResult(result ethtxmanager.MonitoredTxResult) { + mTxResultLogger := ethtxmanager.CreateMonitoredTxResultLogger(result) + if result.Status == ethtxmanager.MonitoredTxStatusFailed { + mTxResultLogger.Fatal("failed to send batch verification, TODO: review this fatal and define what to do in this case") + } + + // TODO: REVIEW THIS + + /* + // monitoredIDFormat: "proof-from-%v-to-%v" + idSlice := strings.Split(result.ID, "-") + proofBatchNumberStr := idSlice[2] + proofBatchNumber, err := strconv.ParseUint(proofBatchNumberStr, encoding.Base10, 0) + + if err != nil { + mTxResultLogger.Errorf("failed to read final proof batch number from monitored tx: %v", err) + } + + proofBatchNumberFinalStr := idSlice[4] + proofBatchNumberFinal, err := strconv.ParseUint(proofBatchNumberFinalStr, encoding.Base10, 0) + + if err != nil { + mTxResultLogger.Errorf("failed to read final proof batch number final from monitored tx: %v", err) + } + + log := log.WithFields("txId", result.ID, "batches", fmt.Sprintf("%d-%d", proofBatchNumber, proofBatchNumberFinal)) + log.Info("Final proof verified") + + // wait for the synchronizer to catch up the verified batches + log.Debug("A final proof has been sent, waiting for the network to be synced") + + for !a.isSynced(a.ctx, &proofBatchNumberFinal) { + log.Info("Waiting for synchronizer to sync...") + time.Sleep(a.cfg.RetryTime.Duration) + } + + // network is synced with the final proof, we can safely delete all recursive + // proofs up to the last synced batch + err = a.State.CleanupGeneratedProofs(a.ctx, proofBatchNumberFinal, nil) + + if err != nil { + log.Errorf("Failed to store proof aggregation result: %v", err) + } + */ +} + +/* +func buildMonitoredTxID(batchNumber, batchNumberFinal uint64) string { + return fmt.Sprintf(monitoredIDFormat, batchNumber, batchNumberFinal) +} +*/ + +func (a *Aggregator) cleanupLockedProofs() { + for { + select { + case <-a.ctx.Done(): + return + case <-time.After(a.timeCleanupLockedProofs.Duration): + n, err := a.state.CleanupLockedProofs(a.ctx, a.cfg.GeneratingProofCleanupThreshold, nil) + if err != nil { + log.Errorf("Failed to cleanup locked proofs: %v", err) + } + if n == 1 { + log.Warn("Found a stale proof and removed from cache") + } else if n > 1 { + log.Warnf("Found %d stale proofs and removed from cache", n) + } + } + } +} + +// FirstToUpper returns the string passed as argument with the first letter in +// uppercase. +func FirstToUpper(s string) string { + runes := []rune(s) + runes[0] = unicode.ToUpper(runes[0]) + return string(runes) +} diff --git a/aggregator/config.go b/aggregator/config.go new file mode 100644 index 00000000..64132f2f --- /dev/null +++ b/aggregator/config.go @@ -0,0 +1,167 @@ +package aggregator + +import ( + "crypto/ecdsa" + "fmt" + "math/big" + "os" + "path/filepath" + + "github.com/0xPolygon/cdk/config/types" + "github.com/0xPolygon/cdk/db" + "github.com/0xPolygon/cdk/encoding" + "github.com/0xPolygon/cdk/log" + "github.com/0xPolygonHermez/zkevm-ethtx-manager/ethtxmanager" + syncronizerConfig "github.com/0xPolygonHermez/zkevm-synchronizer-l1/config" + "github.com/ethereum/go-ethereum/accounts/keystore" +) + +// SettlementBackend is the type of the settlement backend +type SettlementBackend string + +const ( + // AggLayer settlement backend + AggLayer SettlementBackend = "agglayer" + + // L1 settlement backend + L1 SettlementBackend = "l1" +) + +// TokenAmountWithDecimals is a wrapper type that parses token amount with decimals to big int +type TokenAmountWithDecimals struct { + *big.Int `validate:"required"` +} + +// UnmarshalText unmarshal token amount from float string to big int +func (t *TokenAmountWithDecimals) UnmarshalText(data []byte) error { + amount, ok := new(big.Float).SetString(string(data)) + if !ok { + return fmt.Errorf("failed to unmarshal string to float") + } + coin := new(big.Float).SetInt(big.NewInt(encoding.TenToThePowerOf18)) + bigval := new(big.Float).Mul(amount, coin) + result := new(big.Int) + bigval.Int(result) + t.Int = result + + return nil +} + +// Config represents the configuration of the aggregator +type Config struct { + // Host for the grpc server + Host string `mapstructure:"Host"` + // Port for the grpc server + Port int `mapstructure:"Port"` + + // RetryTime is the time the aggregator main loop sleeps if there are no proofs to aggregate + // or batches to generate proofs. It is also used in the isSynced loop + RetryTime types.Duration `mapstructure:"RetryTime"` + + // VerifyProofInterval is the interval of time to verify/send an proof in L1 + VerifyProofInterval types.Duration `mapstructure:"VerifyProofInterval"` + + // ProofStatePollingInterval is the interval time to polling the prover about the generation state of a proof + ProofStatePollingInterval types.Duration `mapstructure:"ProofStatePollingInterval"` + + // TxProfitabilityCheckerType type for checking is it profitable for aggregator to validate batch + // possible values: base/acceptall + TxProfitabilityCheckerType TxProfitabilityCheckerType `mapstructure:"TxProfitabilityCheckerType"` + + // TxProfitabilityMinReward min reward for base tx profitability checker when aggregator will validate batch + // this parameter is used for the base tx profitability checker + TxProfitabilityMinReward TokenAmountWithDecimals `mapstructure:"TxProfitabilityMinReward"` + + // IntervalAfterWhichBatchConsolidateAnyway this is interval for the main sequencer, that will check if there is no transactions + IntervalAfterWhichBatchConsolidateAnyway types.Duration `mapstructure:"IntervalAfterWhichBatchConsolidateAnyway"` + + // ChainID is the L2 ChainID provided by the Network Config + ChainID uint64 + + // ForkID is the L2 ForkID provided by the Network Config + ForkId uint64 `mapstructure:"ForkId"` + + // SenderAddress defines which private key the eth tx manager needs to use + // to sign the L1 txs + SenderAddress string `mapstructure:"SenderAddress"` + + // CleanupLockedProofsInterval is the interval of time to clean up locked proofs. + CleanupLockedProofsInterval types.Duration `mapstructure:"CleanupLockedProofsInterval"` + + // GeneratingProofCleanupThreshold represents the time interval after + // which a proof in generating state is considered to be stuck and + // allowed to be cleared. + GeneratingProofCleanupThreshold string `mapstructure:"GeneratingProofCleanupThreshold"` + + // GasOffset is the amount of gas to be added to the gas estimation in order + // to provide an amount that is higher than the estimated one. This is used + // to avoid the TX getting reverted in case something has changed in the network + // state after the estimation which can cause the TX to require more gas to be + // executed. + // + // ex: + // gas estimation: 1000 + // gas offset: 100 + // final gas: 1100 + GasOffset uint64 `mapstructure:"GasOffset"` + + // WitnessURL is the URL of the witness server + WitnessURL string `mapstructure:"WitnessURL"` + + // UseL1BatchData is a flag to enable the use of L1 batch data in the aggregator + UseL1BatchData bool `mapstructure:"UseL1BatchData"` + + // UseFullWitness is a flag to enable the use of full witness in the aggregator + UseFullWitness bool `mapstructure:"UseFullWitness"` + + // DB is the database configuration + DB db.Config `mapstructure:"DB"` + + // StreamClient is the config for the stream client + StreamClient StreamClientCfg `mapstructure:"StreamClient"` + + // EthTxManager is the config for the ethtxmanager + EthTxManager ethtxmanager.Config `mapstructure:"EthTxManager"` + + // Log is the log configuration + Log log.Config `mapstructure:"Log"` + + // Synchornizer config + Synchronizer syncronizerConfig.Config `mapstructure:"Synchronizer"` + + // SettlementBackend configuration defines how a final ZKP should be settled. Directly to L1 or over the Beethoven service. + SettlementBackend SettlementBackend `mapstructure:"SettlementBackend" jsonschema:"enum=agglayer,enum=l1"` + + // SequencerPrivateKey Private key of the trusted sequencer + SequencerPrivateKey types.KeystoreFileConfig `mapstructure:"SequencerPrivateKey"` + + // AggLayerTxTimeout is the interval time to wait for a tx to be mined from the agglayer + AggLayerTxTimeout types.Duration `mapstructure:"AggLayerTxTimeout"` + + // AggLayerURL url of the agglayer service + AggLayerURL string `mapstructure:"AggLayerURL"` +} + +// StreamClientCfg contains the data streamer's configuration properties +type StreamClientCfg struct { + // Datastream server to connect + Server string `mapstructure:"Server"` + // Log is the log configuration + Log log.Config `mapstructure:"Log"` +} + +// newKeyFromKeystore creates a private key from a keystore file +func newKeyFromKeystore(cfg types.KeystoreFileConfig) (*ecdsa.PrivateKey, error) { + if cfg.Path == "" && cfg.Password == "" { + return nil, nil + } + keystoreEncrypted, err := os.ReadFile(filepath.Clean(cfg.Path)) + if err != nil { + return nil, err + } + key, err := keystore.DecryptKey(keystoreEncrypted, cfg.Password) + if err != nil { + return nil, err + } + return key.PrivateKey, nil +} diff --git a/aggregator/interfaces.go b/aggregator/interfaces.go new file mode 100644 index 00000000..e0372975 --- /dev/null +++ b/aggregator/interfaces.go @@ -0,0 +1,62 @@ +package aggregator + +import ( + "context" + "math/big" + + "github.com/0xPolygon/cdk/aggregator/prover" + ethmanTypes "github.com/0xPolygon/cdk/etherman/types" + "github.com/0xPolygon/cdk/state" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/jackc/pgx/v4" +) + +// Consumer interfaces required by the package. + +type proverInterface interface { + Name() string + ID() string + Addr() string + IsIdle() (bool, error) + BatchProof(input *prover.StatelessInputProver) (*string, error) + AggregatedProof(inputProof1, inputProof2 string) (*string, error) + FinalProof(inputProof string, aggregatorAddr string) (*string, error) + WaitRecursiveProof(ctx context.Context, proofID string) (string, error) + WaitFinalProof(ctx context.Context, proofID string) (*prover.FinalProof, error) +} + +// etherman contains the methods required to interact with ethereum +type etherman interface { + GetRollupId() uint32 + GetLatestVerifiedBatchNum() (uint64, error) + BuildTrustedVerifyBatchesTxData(lastVerifiedBatch, newVerifiedBatch uint64, inputs *ethmanTypes.FinalProofInputs, beneficiary common.Address) (to *common.Address, data []byte, err error) + GetLatestBlockHeader(ctx context.Context) (*types.Header, error) + GetBatchAccInputHash(ctx context.Context, batchNumber uint64) (common.Hash, error) +} + +// aggregatorTxProfitabilityChecker interface for different profitability +// checking algorithms. +type aggregatorTxProfitabilityChecker interface { + IsProfitable(context.Context, *big.Int) (bool, error) +} + +// stateInterface gathers the methods to interact with the state. +type stateInterface interface { + BeginStateTransaction(ctx context.Context) (pgx.Tx, error) + CheckProofContainsCompleteSequences(ctx context.Context, proof *state.Proof, dbTx pgx.Tx) (bool, error) + GetProofReadyToVerify(ctx context.Context, lastVerfiedBatchNumber uint64, dbTx pgx.Tx) (*state.Proof, error) + GetProofsToAggregate(ctx context.Context, dbTx pgx.Tx) (*state.Proof, *state.Proof, error) + AddGeneratedProof(ctx context.Context, proof *state.Proof, dbTx pgx.Tx) error + UpdateGeneratedProof(ctx context.Context, proof *state.Proof, dbTx pgx.Tx) error + DeleteGeneratedProofs(ctx context.Context, batchNumber uint64, batchNumberFinal uint64, dbTx pgx.Tx) error + DeleteUngeneratedProofs(ctx context.Context, dbTx pgx.Tx) error + CleanupGeneratedProofs(ctx context.Context, batchNumber uint64, dbTx pgx.Tx) error + CleanupLockedProofs(ctx context.Context, duration string, dbTx pgx.Tx) (int64, error) + CheckProofExistsForBatch(ctx context.Context, batchNumber uint64, dbTx pgx.Tx) (bool, error) + AddSequence(ctx context.Context, sequence state.Sequence, dbTx pgx.Tx) error + AddBatch(ctx context.Context, batch *state.Batch, datastream []byte, dbTx pgx.Tx) error + GetBatch(ctx context.Context, batchNumber uint64, dbTx pgx.Tx) (*state.Batch, []byte, error) + DeleteBatchesOlderThanBatchNumber(ctx context.Context, batchNumber uint64, dbTx pgx.Tx) error + DeleteBatchesNewerThanBatchNumber(ctx context.Context, batchNumber uint64, dbTx pgx.Tx) error +} diff --git a/aggregator/metrics/metrics.go b/aggregator/metrics/metrics.go new file mode 100644 index 00000000..98d3477d --- /dev/null +++ b/aggregator/metrics/metrics.go @@ -0,0 +1,51 @@ +package metrics + +import ( + "github.com/0xPolygon/cdk/metrics" + "github.com/prometheus/client_golang/prometheus" +) + +const ( + prefix = "aggregator_" + currentConnectedProversName = prefix + "current_connected_provers" + currentWorkingProversName = prefix + "current_working_provers" +) + +// Register the metrics for the sequencer package. +func Register() { + gauges := []prometheus.GaugeOpts{ + { + Name: currentConnectedProversName, + Help: "[AGGREGATOR] current connected provers", + }, + { + Name: currentWorkingProversName, + Help: "[AGGREGATOR] current working provers", + }, + } + + metrics.RegisterGauges(gauges...) +} + +// ConnectedProver increments the gauge for the current number of connected +// provers. +func ConnectedProver() { + metrics.GaugeInc(currentConnectedProversName) +} + +// DisconnectedProver decrements the gauge for the current number of connected +// provers. +func DisconnectedProver() { + metrics.GaugeDec(currentConnectedProversName) +} + +// WorkingProver increments the gauge for the current number of working +// provers. +func WorkingProver() { + metrics.GaugeInc(currentWorkingProversName) +} + +// IdlingProver decrements the gauge for the current number of working provers. +func IdlingProver() { + metrics.GaugeDec(currentWorkingProversName) +} diff --git a/aggregator/profitabilitychecker.go b/aggregator/profitabilitychecker.go new file mode 100644 index 00000000..27e3f705 --- /dev/null +++ b/aggregator/profitabilitychecker.go @@ -0,0 +1,91 @@ +package aggregator + +import ( + "context" + "math/big" + "time" +) + +// TxProfitabilityCheckerType checks profitability of batch validation +type TxProfitabilityCheckerType string + +const ( + // ProfitabilityBase checks pol collateral with min reward + ProfitabilityBase = "base" + // ProfitabilityAcceptAll validate batch anyway and don't check anything + ProfitabilityAcceptAll = "acceptall" +) + +// TxProfitabilityCheckerBase checks pol collateral with min reward +type TxProfitabilityCheckerBase struct { + State stateInterface + IntervalAfterWhichBatchSentAnyway time.Duration + MinReward *big.Int +} + +// NewTxProfitabilityCheckerBase init base tx profitability checker +func NewTxProfitabilityCheckerBase(state stateInterface, interval time.Duration, minReward *big.Int) *TxProfitabilityCheckerBase { + return &TxProfitabilityCheckerBase{ + State: state, + IntervalAfterWhichBatchSentAnyway: interval, + MinReward: minReward, + } +} + +// IsProfitable checks pol collateral with min reward +func (pc *TxProfitabilityCheckerBase) IsProfitable(ctx context.Context, polCollateral *big.Int) (bool, error) { + //if pc.IntervalAfterWhichBatchSentAnyway != 0 { + // ok, err := isConsolidatedBatchAppeared(ctx, pc.State, pc.IntervalAfterWhichBatchSentAnyway) + // if err != nil { + // return false, err + // } + // if ok { + // return true, nil + // } + //} + + return polCollateral.Cmp(pc.MinReward) >= 0, nil +} + +// TxProfitabilityCheckerAcceptAll validate batch anyway and don't check anything +type TxProfitabilityCheckerAcceptAll struct { + State stateInterface + IntervalAfterWhichBatchSentAnyway time.Duration +} + +// NewTxProfitabilityCheckerAcceptAll init tx profitability checker that accept all txs +func NewTxProfitabilityCheckerAcceptAll(state stateInterface, interval time.Duration) *TxProfitabilityCheckerAcceptAll { + return &TxProfitabilityCheckerAcceptAll{ + State: state, + IntervalAfterWhichBatchSentAnyway: interval, + } +} + +// IsProfitable validate batch anyway and don't check anything +func (pc *TxProfitabilityCheckerAcceptAll) IsProfitable(ctx context.Context, polCollateral *big.Int) (bool, error) { + //if pc.IntervalAfterWhichBatchSentAnyway != 0 { + // ok, err := isConsolidatedBatchAppeared(ctx, pc.State, pc.IntervalAfterWhichBatchSentAnyway) + // if err != nil { + // return false, err + // } + // if ok { + // return true, nil + // } + //} + + return true, nil +} + +// TODO: now it's impossible to check, when batch got consolidated, bcs it's not saved +//func isConsolidatedBatchAppeared(ctx context.Context, state stateInterface, intervalAfterWhichBatchConsolidatedAnyway time.Duration) (bool, error) { +// batch, err := state.GetLastVerifiedBatch(ctx, nil) +// if err != nil { +// return false, fmt.Errorf("failed to get last verified batch, err: %v", err) +// } +// interval := intervalAfterWhichBatchConsolidatedAnyway * time.Minute +// if batch..Before(time.Now().Add(-interval)) { +// return true, nil +// } +// +// return false, err +//} diff --git a/aggregator/prover/aggregator.pb.go b/aggregator/prover/aggregator.pb.go new file mode 100644 index 00000000..b79d134b --- /dev/null +++ b/aggregator/prover/aggregator.pb.go @@ -0,0 +1,2819 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.34.1 +// protoc v5.27.0 +// 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{10, 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{15, 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 + // *AggregatorMessage_GenStatelessBatchProofRequest + 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 +} + +func (x *AggregatorMessage) GetGenStatelessBatchProofRequest() *GenStatelessBatchProofRequest { + if x, ok := x.GetRequest().(*AggregatorMessage_GenStatelessBatchProofRequest); ok { + return x.GenStatelessBatchProofRequest + } + 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"` +} + +type AggregatorMessage_GenStatelessBatchProofRequest struct { + GenStatelessBatchProofRequest *GenStatelessBatchProofRequest `protobuf:"bytes,8,opt,name=gen_stateless_batch_proof_request,json=genStatelessBatchProofRequest,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() {} + +func (*AggregatorMessage_GenStatelessBatchProofRequest) 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 +} + +type GenStatelessBatchProofRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Input *StatelessInputProver `protobuf:"bytes,1,opt,name=input,proto3" json:"input,omitempty"` +} + +func (x *GenStatelessBatchProofRequest) Reset() { + *x = GenStatelessBatchProofRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_aggregator_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GenStatelessBatchProofRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GenStatelessBatchProofRequest) ProtoMessage() {} + +func (x *GenStatelessBatchProofRequest) 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 GenStatelessBatchProofRequest.ProtoReflect.Descriptor instead. +func (*GenStatelessBatchProofRequest) Descriptor() ([]byte, []int) { + return file_aggregator_proto_rawDescGZIP(), []int{5} +} + +func (x *GenStatelessBatchProofRequest) GetInput() *StatelessInputProver { + 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[6] + 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[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 GenAggregatedProofRequest.ProtoReflect.Descriptor instead. +func (*GenAggregatedProofRequest) Descriptor() ([]byte, []int) { + return file_aggregator_proto_rawDescGZIP(), []int{6} +} + +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[7] + 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[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 GenFinalProofRequest.ProtoReflect.Descriptor instead. +func (*GenFinalProofRequest) Descriptor() ([]byte, []int) { + return file_aggregator_proto_rawDescGZIP(), []int{7} +} + +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[8] + 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[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 CancelRequest.ProtoReflect.Descriptor instead. +func (*CancelRequest) Descriptor() ([]byte, []int) { + return file_aggregator_proto_rawDescGZIP(), []int{8} +} + +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[9] + 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[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 GetProofRequest.ProtoReflect.Descriptor instead. +func (*GetProofRequest) Descriptor() ([]byte, []int) { + return file_aggregator_proto_rawDescGZIP(), []int{9} +} + +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[10] + 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[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 GetStatusResponse.ProtoReflect.Descriptor instead. +func (*GetStatusResponse) Descriptor() ([]byte, []int) { + return file_aggregator_proto_rawDescGZIP(), []int{10} +} + +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[11] + 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[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 GenBatchProofResponse.ProtoReflect.Descriptor instead. +func (*GenBatchProofResponse) Descriptor() ([]byte, []int) { + return file_aggregator_proto_rawDescGZIP(), []int{11} +} + +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[12] + 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[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 GenAggregatedProofResponse.ProtoReflect.Descriptor instead. +func (*GenAggregatedProofResponse) Descriptor() ([]byte, []int) { + return file_aggregator_proto_rawDescGZIP(), []int{12} +} + +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[13] + 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[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 GenFinalProofResponse.ProtoReflect.Descriptor instead. +func (*GenFinalProofResponse) Descriptor() ([]byte, []int) { + return file_aggregator_proto_rawDescGZIP(), []int{13} +} + +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[14] + 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[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 CancelResponse.ProtoReflect.Descriptor instead. +func (*CancelResponse) Descriptor() ([]byte, []int) { + return file_aggregator_proto_rawDescGZIP(), []int{14} +} + +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[15] + 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[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 GetProofResponse.ProtoReflect.Descriptor instead. +func (*GetProofResponse) Descriptor() ([]byte, []int) { + return file_aggregator_proto_rawDescGZIP(), []int{15} +} + +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[16] + 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[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 FinalProof.ProtoReflect.Descriptor instead. +func (*FinalProof) Descriptor() ([]byte, []int) { + return file_aggregator_proto_rawDescGZIP(), []int{16} +} + +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[17] + 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[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 PublicInputs.ProtoReflect.Descriptor instead. +func (*PublicInputs) Descriptor() ([]byte, []int) { + return file_aggregator_proto_rawDescGZIP(), []int{17} +} + +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 +} + +type StatelessPublicInputs struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Witness []byte `protobuf:"bytes,1,opt,name=witness,proto3" json:"witness,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,11,opt,name=aggregator_addr,json=aggregatorAddr,proto3" json:"aggregator_addr,omitempty"` + L1InfoTreeData map[uint32]*L1Data `protobuf:"bytes,12,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 *StatelessPublicInputs) Reset() { + *x = StatelessPublicInputs{} + if protoimpl.UnsafeEnabled { + mi := &file_aggregator_proto_msgTypes[18] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *StatelessPublicInputs) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*StatelessPublicInputs) ProtoMessage() {} + +func (x *StatelessPublicInputs) 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 StatelessPublicInputs.ProtoReflect.Descriptor instead. +func (*StatelessPublicInputs) Descriptor() ([]byte, []int) { + return file_aggregator_proto_rawDescGZIP(), []int{18} +} + +func (x *StatelessPublicInputs) GetWitness() []byte { + if x != nil { + return x.Witness + } + return nil +} + +func (x *StatelessPublicInputs) GetOldAccInputHash() []byte { + if x != nil { + return x.OldAccInputHash + } + return nil +} + +func (x *StatelessPublicInputs) GetOldBatchNum() uint64 { + if x != nil { + return x.OldBatchNum + } + return 0 +} + +func (x *StatelessPublicInputs) GetChainId() uint64 { + if x != nil { + return x.ChainId + } + return 0 +} + +func (x *StatelessPublicInputs) GetForkId() uint64 { + if x != nil { + return x.ForkId + } + return 0 +} + +func (x *StatelessPublicInputs) GetBatchL2Data() []byte { + if x != nil { + return x.BatchL2Data + } + return nil +} + +func (x *StatelessPublicInputs) GetL1InfoRoot() []byte { + if x != nil { + return x.L1InfoRoot + } + return nil +} + +func (x *StatelessPublicInputs) GetTimestampLimit() uint64 { + if x != nil { + return x.TimestampLimit + } + return 0 +} + +func (x *StatelessPublicInputs) GetSequencerAddr() string { + if x != nil { + return x.SequencerAddr + } + return "" +} + +func (x *StatelessPublicInputs) GetForcedBlockhashL1() []byte { + if x != nil { + return x.ForcedBlockhashL1 + } + return nil +} + +func (x *StatelessPublicInputs) GetAggregatorAddr() string { + if x != nil { + return x.AggregatorAddr + } + return "" +} + +func (x *StatelessPublicInputs) 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[19] + 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[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 L1Data.ProtoReflect.Descriptor instead. +func (*L1Data) Descriptor() ([]byte, []int) { + return file_aggregator_proto_rawDescGZIP(), []int{19} +} + +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[20] + 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[20] + 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{20} +} + +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 +} + +type StatelessInputProver struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + PublicInputs *StatelessPublicInputs `protobuf:"bytes,1,opt,name=public_inputs,json=publicInputs,proto3" json:"public_inputs,omitempty"` +} + +func (x *StatelessInputProver) Reset() { + *x = StatelessInputProver{} + if protoimpl.UnsafeEnabled { + mi := &file_aggregator_proto_msgTypes[21] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *StatelessInputProver) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*StatelessInputProver) ProtoMessage() {} + +func (x *StatelessInputProver) ProtoReflect() protoreflect.Message { + mi := &file_aggregator_proto_msgTypes[21] + 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 StatelessInputProver.ProtoReflect.Descriptor instead. +func (*StatelessInputProver) Descriptor() ([]byte, []int) { + return file_aggregator_proto_rawDescGZIP(), []int{21} +} + +func (x *StatelessInputProver) GetPublicInputs() *StatelessPublicInputs { + if x != nil { + return x.PublicInputs + } + 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[22] + 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[22] + 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{22} +} + +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, 0xb7, 0x05, 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, 0x12, 0x78, 0x0a, 0x21, 0x67, 0x65, 0x6e, 0x5f, 0x73, + 0x74, 0x61, 0x74, 0x65, 0x6c, 0x65, 0x73, 0x73, 0x5f, 0x62, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x70, + 0x72, 0x6f, 0x6f, 0x66, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, 0x08, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x2e, + 0x76, 0x31, 0x2e, 0x47, 0x65, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x6c, 0x65, 0x73, 0x73, 0x42, + 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, 0x6f, 0x6f, 0x66, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x48, 0x00, 0x52, 0x1d, 0x67, 0x65, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x6c, 0x65, 0x73, 0x73, + 0x42, 0x61, 0x74, 0x63, 0x68, 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, 0x5a, 0x0a, 0x1d, 0x47, 0x65, 0x6e, + 0x53, 0x74, 0x61, 0x74, 0x65, 0x6c, 0x65, 0x73, 0x73, 0x42, 0x61, 0x74, 0x63, 0x68, 0x50, 0x72, + 0x6f, 0x6f, 0x66, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x39, 0x0a, 0x05, 0x69, 0x6e, + 0x70, 0x75, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x61, 0x67, 0x67, 0x72, + 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x6c, + 0x65, 0x73, 0x73, 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, 0xe4, 0x04, 0x0a, 0x15, 0x53, 0x74, + 0x61, 0x74, 0x65, 0x6c, 0x65, 0x73, 0x73, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x49, 0x6e, 0x70, + 0x75, 0x74, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x77, 0x69, 0x74, 0x6e, 0x65, 0x73, 0x73, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0c, 0x52, 0x07, 0x77, 0x69, 0x74, 0x6e, 0x65, 0x73, 0x73, 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, 0x0b, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x0e, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x41, 0x64, 0x64, + 0x72, 0x12, 0x63, 0x0a, 0x11, 0x6c, 0x31, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x5f, 0x74, 0x72, 0x65, + 0x65, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x0c, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x38, 0x2e, 0x61, + 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x61, + 0x74, 0x65, 0x6c, 0x65, 0x73, 0x73, 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, + 0x61, 0x0a, 0x14, 0x53, 0x74, 0x61, 0x74, 0x65, 0x6c, 0x65, 0x73, 0x73, 0x49, 0x6e, 0x70, 0x75, + 0x74, 0x50, 0x72, 0x6f, 0x76, 0x65, 0x72, 0x12, 0x49, 0x0a, 0x0d, 0x70, 0x75, 0x62, 0x6c, 0x69, + 0x63, 0x5f, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, + 0x2e, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 0x2e, 0x76, 0x31, 0x2e, 0x53, + 0x74, 0x61, 0x74, 0x65, 0x6c, 0x65, 0x73, 0x73, 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, 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, 0x41, 0x5a, 0x3f, 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, 0x61, 0x67, 0x67, 0x72, + 0x65, 0x67, 0x61, 0x74, 0x6f, 0x72, 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, 27) +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 + (*GenStatelessBatchProofRequest)(nil), // 8: aggregator.v1.GenStatelessBatchProofRequest + (*GenAggregatedProofRequest)(nil), // 9: aggregator.v1.GenAggregatedProofRequest + (*GenFinalProofRequest)(nil), // 10: aggregator.v1.GenFinalProofRequest + (*CancelRequest)(nil), // 11: aggregator.v1.CancelRequest + (*GetProofRequest)(nil), // 12: aggregator.v1.GetProofRequest + (*GetStatusResponse)(nil), // 13: aggregator.v1.GetStatusResponse + (*GenBatchProofResponse)(nil), // 14: aggregator.v1.GenBatchProofResponse + (*GenAggregatedProofResponse)(nil), // 15: aggregator.v1.GenAggregatedProofResponse + (*GenFinalProofResponse)(nil), // 16: aggregator.v1.GenFinalProofResponse + (*CancelResponse)(nil), // 17: aggregator.v1.CancelResponse + (*GetProofResponse)(nil), // 18: aggregator.v1.GetProofResponse + (*FinalProof)(nil), // 19: aggregator.v1.FinalProof + (*PublicInputs)(nil), // 20: aggregator.v1.PublicInputs + (*StatelessPublicInputs)(nil), // 21: aggregator.v1.StatelessPublicInputs + (*L1Data)(nil), // 22: aggregator.v1.L1Data + (*InputProver)(nil), // 23: aggregator.v1.InputProver + (*StatelessInputProver)(nil), // 24: aggregator.v1.StatelessInputProver + (*PublicInputsExtended)(nil), // 25: aggregator.v1.PublicInputsExtended + nil, // 26: aggregator.v1.PublicInputs.L1InfoTreeDataEntry + nil, // 27: aggregator.v1.StatelessPublicInputs.L1InfoTreeDataEntry + nil, // 28: aggregator.v1.InputProver.DbEntry + nil, // 29: 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 + 9, // 2: aggregator.v1.AggregatorMessage.gen_aggregated_proof_request:type_name -> aggregator.v1.GenAggregatedProofRequest + 10, // 3: aggregator.v1.AggregatorMessage.gen_final_proof_request:type_name -> aggregator.v1.GenFinalProofRequest + 11, // 4: aggregator.v1.AggregatorMessage.cancel_request:type_name -> aggregator.v1.CancelRequest + 12, // 5: aggregator.v1.AggregatorMessage.get_proof_request:type_name -> aggregator.v1.GetProofRequest + 8, // 6: aggregator.v1.AggregatorMessage.gen_stateless_batch_proof_request:type_name -> aggregator.v1.GenStatelessBatchProofRequest + 13, // 7: aggregator.v1.ProverMessage.get_status_response:type_name -> aggregator.v1.GetStatusResponse + 14, // 8: aggregator.v1.ProverMessage.gen_batch_proof_response:type_name -> aggregator.v1.GenBatchProofResponse + 15, // 9: aggregator.v1.ProverMessage.gen_aggregated_proof_response:type_name -> aggregator.v1.GenAggregatedProofResponse + 16, // 10: aggregator.v1.ProverMessage.gen_final_proof_response:type_name -> aggregator.v1.GenFinalProofResponse + 17, // 11: aggregator.v1.ProverMessage.cancel_response:type_name -> aggregator.v1.CancelResponse + 18, // 12: aggregator.v1.ProverMessage.get_proof_response:type_name -> aggregator.v1.GetProofResponse + 23, // 13: aggregator.v1.GenBatchProofRequest.input:type_name -> aggregator.v1.InputProver + 24, // 14: aggregator.v1.GenStatelessBatchProofRequest.input:type_name -> aggregator.v1.StatelessInputProver + 1, // 15: aggregator.v1.GetStatusResponse.status:type_name -> aggregator.v1.GetStatusResponse.Status + 0, // 16: aggregator.v1.GenBatchProofResponse.result:type_name -> aggregator.v1.Result + 0, // 17: aggregator.v1.GenAggregatedProofResponse.result:type_name -> aggregator.v1.Result + 0, // 18: aggregator.v1.GenFinalProofResponse.result:type_name -> aggregator.v1.Result + 0, // 19: aggregator.v1.CancelResponse.result:type_name -> aggregator.v1.Result + 19, // 20: aggregator.v1.GetProofResponse.final_proof:type_name -> aggregator.v1.FinalProof + 2, // 21: aggregator.v1.GetProofResponse.result:type_name -> aggregator.v1.GetProofResponse.Result + 25, // 22: aggregator.v1.FinalProof.public:type_name -> aggregator.v1.PublicInputsExtended + 26, // 23: aggregator.v1.PublicInputs.l1_info_tree_data:type_name -> aggregator.v1.PublicInputs.L1InfoTreeDataEntry + 27, // 24: aggregator.v1.StatelessPublicInputs.l1_info_tree_data:type_name -> aggregator.v1.StatelessPublicInputs.L1InfoTreeDataEntry + 20, // 25: aggregator.v1.InputProver.public_inputs:type_name -> aggregator.v1.PublicInputs + 28, // 26: aggregator.v1.InputProver.db:type_name -> aggregator.v1.InputProver.DbEntry + 29, // 27: aggregator.v1.InputProver.contracts_bytecode:type_name -> aggregator.v1.InputProver.ContractsBytecodeEntry + 21, // 28: aggregator.v1.StatelessInputProver.public_inputs:type_name -> aggregator.v1.StatelessPublicInputs + 20, // 29: aggregator.v1.PublicInputsExtended.public_inputs:type_name -> aggregator.v1.PublicInputs + 22, // 30: aggregator.v1.PublicInputs.L1InfoTreeDataEntry.value:type_name -> aggregator.v1.L1Data + 22, // 31: aggregator.v1.StatelessPublicInputs.L1InfoTreeDataEntry.value:type_name -> aggregator.v1.L1Data + 5, // 32: aggregator.v1.AggregatorService.Channel:input_type -> aggregator.v1.ProverMessage + 4, // 33: aggregator.v1.AggregatorService.Channel:output_type -> aggregator.v1.AggregatorMessage + 33, // [33:34] is the sub-list for method output_type + 32, // [32:33] is the sub-list for method input_type + 32, // [32:32] is the sub-list for extension type_name + 32, // [32:32] is the sub-list for extension extendee + 0, // [0:32] 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.(*GenStatelessBatchProofRequest); 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.(*GenAggregatedProofRequest); 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.(*GenFinalProofRequest); 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.(*CancelRequest); 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.(*GetProofRequest); 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.(*GetStatusResponse); 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.(*GenBatchProofResponse); 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.(*GenAggregatedProofResponse); 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.(*GenFinalProofResponse); 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.(*CancelResponse); 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.(*GetProofResponse); 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.(*FinalProof); 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.(*PublicInputs); 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.(*StatelessPublicInputs); 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.(*L1Data); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_aggregator_proto_msgTypes[20].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[21].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*StatelessInputProver); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_aggregator_proto_msgTypes[22].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), + (*AggregatorMessage_GenStatelessBatchProofRequest)(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[15].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: 27, + 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 00000000..32bdb107 --- /dev/null +++ b/aggregator/prover/aggregator_grpc.pb.go @@ -0,0 +1,150 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.4.0 +// - protoc v5.27.0 +// 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.62.0 or later. +const _ = grpc.SupportPackageIsVersion8 + +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. +// +// * +// Define all methods implementes by the gRPC +// Channel: prover receives aggregator messages and returns prover messages with the same id +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) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + stream, err := c.cc.NewStream(ctx, &AggregatorService_ServiceDesc.Streams[0], AggregatorService_Channel_FullMethodName, cOpts...) + if err != nil { + return nil, err + } + x := &aggregatorServiceChannelClient{ClientStream: 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 +// +// * +// Define all methods implementes by the gRPC +// Channel: prover receives aggregator messages and returns prover messages with the same id +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{ServerStream: 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/aggregator/prover/prover.go b/aggregator/prover/prover.go new file mode 100644 index 00000000..b6da22d4 --- /dev/null +++ b/aggregator/prover/prover.go @@ -0,0 +1,336 @@ +package prover + +import ( + "context" + "errors" + "fmt" + "net" + "time" + + "github.com/0xPolygon/cdk/aggregator/metrics" + "github.com/0xPolygon/cdk/config/types" + "github.com/0xPolygon/cdk/log" +) + +var ( + ErrBadProverResponse = errors.New("Prover returned wrong type for response") //nolint:revive + ErrProverInternalError = errors.New("Prover returned INTERNAL_ERROR response") //nolint:revive + ErrProverCompletedError = errors.New("Prover returned COMPLETED_ERROR response") //nolint:revive + ErrBadRequest = errors.New("Prover returned ERROR for a bad request") //nolint:revive + ErrUnspecified = errors.New("Prover returned an UNSPECIFIED response") //nolint:revive + ErrUnknown = errors.New("Prover returned an unknown response") //nolint:revive + ErrProofCanceled = errors.New("Proof has been canceled") //nolint:revive +) + +// Prover abstraction of the grpc prover client. +type Prover struct { + name string + id string + address net.Addr + proofStatePollingInterval types.Duration + stream AggregatorService_ChannelServer +} + +// New returns a new Prover instance. +func New(stream AggregatorService_ChannelServer, addr net.Addr, proofStatePollingInterval types.Duration) (*Prover, error) { + p := &Prover{ + stream: stream, + address: addr, + proofStatePollingInterval: proofStatePollingInterval, + } + status, err := p.Status() + if err != nil { + return nil, fmt.Errorf("Failed to retrieve prover id %w", err) + } + p.name = status.ProverName + p.id = status.ProverId + return p, nil +} + +// Name returns the Prover name. +func (p *Prover) Name() string { return p.name } + +// ID returns the Prover ID. +func (p *Prover) ID() string { return p.id } + +// Addr returns the prover IP address. +func (p *Prover) Addr() string { + if p.address == nil { + return "" + } + return p.address.String() +} + +// Status gets the prover status. +func (p *Prover) Status() (*GetStatusResponse, error) { + req := &AggregatorMessage{ + Request: &AggregatorMessage_GetStatusRequest{ + GetStatusRequest: &GetStatusRequest{}, + }, + } + res, err := p.call(req) + if err != nil { + return nil, err + } + if msg, ok := res.Response.(*ProverMessage_GetStatusResponse); ok { + return msg.GetStatusResponse, nil + } + return nil, fmt.Errorf("%w, wanted %T, got %T", ErrBadProverResponse, &ProverMessage_GetStatusResponse{}, res.Response) +} + +// IsIdle returns true if the prover is idling. +func (p *Prover) IsIdle() (bool, error) { + status, err := p.Status() + if err != nil { + return false, err + } + return status.Status == GetStatusResponse_STATUS_IDLE, nil +} + +// SupportsForkID returns true if the prover supports the given fork id. +func (p *Prover) SupportsForkID(forkID uint64) bool { + status, err := p.Status() + if err != nil { + log.Warnf("Error asking status for prover ID %s: %v", p.ID(), err) + return false + } + + log.Debugf("Prover %s supports fork ID %d", p.ID(), status.ForkId) + + return status.ForkId == forkID +} + +// BatchProof instructs the prover to generate a batch proof for the provided +// input. It returns the ID of the proof being computed. +func (p *Prover) BatchProof(input *StatelessInputProver) (*string, error) { + metrics.WorkingProver() + + req := &AggregatorMessage{ + Request: &AggregatorMessage_GenStatelessBatchProofRequest{ + GenStatelessBatchProofRequest: &GenStatelessBatchProofRequest{Input: input}, + }, + } + res, err := p.call(req) + if err != nil { + return nil, err + } + + if msg, ok := res.Response.(*ProverMessage_GenBatchProofResponse); ok { + switch msg.GenBatchProofResponse.Result { + case Result_RESULT_UNSPECIFIED: + return nil, fmt.Errorf("failed to generate proof %s, %w, input %v", msg.GenBatchProofResponse.String(), ErrUnspecified, input) + case Result_RESULT_OK: + return &msg.GenBatchProofResponse.Id, nil + case Result_RESULT_ERROR: + return nil, fmt.Errorf("failed to generate proof %s, %w, input %v", msg.GenBatchProofResponse.String(), ErrBadRequest, input) + case Result_RESULT_INTERNAL_ERROR: + return nil, fmt.Errorf("failed to generate proof %s, %w, input %v", msg.GenBatchProofResponse.String(), ErrProverInternalError, input) + default: + return nil, fmt.Errorf("failed to generate proof %s, %w,input %v", msg.GenBatchProofResponse.String(), ErrUnknown, input) + } + } + + return nil, fmt.Errorf("%w, wanted %T, got %T", ErrBadProverResponse, &ProverMessage_GenBatchProofResponse{}, res.Response) +} + +// AggregatedProof instructs the prover to generate an aggregated proof from +// the two inputs provided. It returns the ID of the proof being computed. +func (p *Prover) AggregatedProof(inputProof1, inputProof2 string) (*string, error) { + metrics.WorkingProver() + + req := &AggregatorMessage{ + Request: &AggregatorMessage_GenAggregatedProofRequest{ + GenAggregatedProofRequest: &GenAggregatedProofRequest{ + RecursiveProof_1: inputProof1, + RecursiveProof_2: inputProof2, + }, + }, + } + res, err := p.call(req) + if err != nil { + return nil, err + } + + if msg, ok := res.Response.(*ProverMessage_GenAggregatedProofResponse); ok { + switch msg.GenAggregatedProofResponse.Result { + case Result_RESULT_UNSPECIFIED: + return nil, fmt.Errorf("failed to aggregate proofs %s, %w, input 1 %s, input 2 %s", + msg.GenAggregatedProofResponse.String(), ErrUnspecified, inputProof1, inputProof2) + case Result_RESULT_OK: + return &msg.GenAggregatedProofResponse.Id, nil + case Result_RESULT_ERROR: + return nil, fmt.Errorf("failed to aggregate proofs %s, %w, input 1 %s, input 2 %s", + msg.GenAggregatedProofResponse.String(), ErrBadRequest, inputProof1, inputProof2) + case Result_RESULT_INTERNAL_ERROR: + return nil, fmt.Errorf("failed to aggregate proofs %s, %w, input 1 %s, input 2 %s", + msg.GenAggregatedProofResponse.String(), ErrProverInternalError, inputProof1, inputProof2) + default: + return nil, fmt.Errorf("failed to aggregate proofs %s, %w, input 1 %s, input 2 %s", + msg.GenAggregatedProofResponse.String(), ErrUnknown, inputProof1, inputProof2) + } + } + + return nil, fmt.Errorf("%w, wanted %T, got %T", ErrBadProverResponse, &ProverMessage_GenAggregatedProofResponse{}, res.Response) +} + +// FinalProof instructs the prover to generate a final proof for the given +// input. It returns the ID of the proof being computed. +func (p *Prover) FinalProof(inputProof string, aggregatorAddr string) (*string, error) { + metrics.WorkingProver() + + req := &AggregatorMessage{ + Request: &AggregatorMessage_GenFinalProofRequest{ + GenFinalProofRequest: &GenFinalProofRequest{ + RecursiveProof: inputProof, + AggregatorAddr: aggregatorAddr, + }, + }, + } + res, err := p.call(req) + if err != nil { + return nil, err + } + + if msg, ok := res.Response.(*ProverMessage_GenFinalProofResponse); ok { + switch msg.GenFinalProofResponse.Result { + case Result_RESULT_UNSPECIFIED: + return nil, fmt.Errorf("failed to generate final proof %s, %w, input %s", + msg.GenFinalProofResponse.String(), ErrUnspecified, inputProof) + case Result_RESULT_OK: + return &msg.GenFinalProofResponse.Id, nil + case Result_RESULT_ERROR: + return nil, fmt.Errorf("failed to generate final proof %s, %w, input %s", + msg.GenFinalProofResponse.String(), ErrBadRequest, inputProof) + case Result_RESULT_INTERNAL_ERROR: + return nil, fmt.Errorf("failed to generate final proof %s, %w, input %s", + msg.GenFinalProofResponse.String(), ErrProverInternalError, inputProof) + default: + return nil, fmt.Errorf("failed to generate final proof %s, %w, input %s", + msg.GenFinalProofResponse.String(), ErrUnknown, inputProof) + } + } + return nil, fmt.Errorf("%w, wanted %T, got %T", ErrBadProverResponse, &ProverMessage_GenFinalProofResponse{}, res.Response) +} + +// CancelProofRequest asks the prover to stop the generation of the proof +// matching the provided proofID. +func (p *Prover) CancelProofRequest(proofID string) error { + req := &AggregatorMessage{ + Request: &AggregatorMessage_CancelRequest{ + CancelRequest: &CancelRequest{Id: proofID}, + }, + } + res, err := p.call(req) + if err != nil { + return err + } + if msg, ok := res.Response.(*ProverMessage_CancelResponse); ok { + switch msg.CancelResponse.Result { + case Result_RESULT_UNSPECIFIED: + return fmt.Errorf("failed to cancel proof id [%s], %w, %s", + proofID, ErrUnspecified, msg.CancelResponse.String()) + case Result_RESULT_OK: + return nil + case Result_RESULT_ERROR: + return fmt.Errorf("failed to cancel proof id [%s], %w, %s", + proofID, ErrBadRequest, msg.CancelResponse.String()) + case Result_RESULT_INTERNAL_ERROR: + return fmt.Errorf("failed to cancel proof id [%s], %w, %s", + proofID, ErrProverInternalError, msg.CancelResponse.String()) + default: + return fmt.Errorf("failed to cancel proof id [%s], %w, %s", + proofID, ErrUnknown, msg.CancelResponse.String()) + } + } + return fmt.Errorf("%w, wanted %T, got %T", ErrBadProverResponse, &ProverMessage_CancelResponse{}, res.Response) +} + +// WaitRecursiveProof waits for a recursive proof to be generated by the prover +// and returns it. +func (p *Prover) WaitRecursiveProof(ctx context.Context, proofID string) (string, error) { + res, err := p.waitProof(ctx, proofID) + if err != nil { + return "", err + } + resProof := res.Proof.(*GetProofResponse_RecursiveProof) + return resProof.RecursiveProof, nil +} + +// WaitFinalProof waits for the final proof to be generated by the prover and +// returns it. +func (p *Prover) WaitFinalProof(ctx context.Context, proofID string) (*FinalProof, error) { + res, err := p.waitProof(ctx, proofID) + if err != nil { + return nil, err + } + resProof := res.Proof.(*GetProofResponse_FinalProof) + return resProof.FinalProof, nil +} + +// waitProof waits for a proof to be generated by the prover and returns the +// prover response. +func (p *Prover) waitProof(ctx context.Context, proofID string) (*GetProofResponse, error) { + defer metrics.IdlingProver() + + req := &AggregatorMessage{ + Request: &AggregatorMessage_GetProofRequest{ + GetProofRequest: &GetProofRequest{ + // TODO(pg): set Timeout field? + Id: proofID, + }, + }, + } + + for { + select { + case <-ctx.Done(): + return nil, ctx.Err() + default: + res, err := p.call(req) + if err != nil { + return nil, err + } + if msg, ok := res.Response.(*ProverMessage_GetProofResponse); ok { + switch msg.GetProofResponse.Result { + case GetProofResponse_RESULT_PENDING: + time.Sleep(p.proofStatePollingInterval.Duration) + continue + case GetProofResponse_RESULT_UNSPECIFIED: + return nil, fmt.Errorf("failed to get proof ID: %s, %w, prover response: %s", + proofID, ErrUnspecified, msg.GetProofResponse.String()) + case GetProofResponse_RESULT_COMPLETED_OK: + return msg.GetProofResponse, nil + case GetProofResponse_RESULT_ERROR: + return nil, fmt.Errorf("failed to get proof with ID %s, %w, prover response: %s", + proofID, ErrBadRequest, msg.GetProofResponse.String()) + case GetProofResponse_RESULT_COMPLETED_ERROR: + return nil, fmt.Errorf("failed to get proof with ID %s, %w, prover response: %s", + proofID, ErrProverCompletedError, msg.GetProofResponse.String()) + case GetProofResponse_RESULT_INTERNAL_ERROR: + return nil, fmt.Errorf("failed to get proof ID: %s, %w, prover response: %s", + proofID, ErrProverInternalError, msg.GetProofResponse.String()) + case GetProofResponse_RESULT_CANCEL: + return nil, fmt.Errorf("proof generation was cancelled for proof ID %s, %w, prover response: %s", + proofID, ErrProofCanceled, msg.GetProofResponse.String()) + default: + return nil, fmt.Errorf("failed to get proof ID: %s, %w, prover response: %s", + proofID, ErrUnknown, msg.GetProofResponse.String()) + } + } + return nil, fmt.Errorf("%w, wanted %T, got %T", ErrBadProverResponse, &ProverMessage_GetProofResponse{}, res.Response) + } + } +} + +// call sends a message to the prover and waits to receive the response over +// the connection stream. +func (p *Prover) call(req *AggregatorMessage) (*ProverMessage, error) { + if err := p.stream.Send(req); err != nil { + return nil, err + } + res, err := p.stream.Recv() + if err != nil { + return nil, err + } + return res, nil +} diff --git a/cmd/cdk/main.go b/cmd/cdk/main.go deleted file mode 100644 index 06ab7d0f..00000000 --- a/cmd/cdk/main.go +++ /dev/null @@ -1 +0,0 @@ -package main diff --git a/cmd/main.go b/cmd/main.go new file mode 100644 index 00000000..5b548bd3 --- /dev/null +++ b/cmd/main.go @@ -0,0 +1,90 @@ +package main + +import ( + "os" + + zkevm "github.com/0xPolygon/cdk" + "github.com/0xPolygon/cdk/config" + "github.com/0xPolygon/cdk/log" + "github.com/urfave/cli/v2" +) + +const appName = "cdk" + +const ( + // SEQUENCE_SENDER name to identify the sequence-sender component + SEQUENCE_SENDER = "sequence-sender" + // AGGREGATOR name to identify the aggregator component + AGGREGATOR = "aggregator" +) + +const ( + // 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(SEQUENCE_SENDER, AGGREGATOR), + } +) + +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 cdk client", + Action: start, + Flags: append(flags, &networkFlag, &customNetworkFlag), + }, + } + + 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 00000000..04bb9c80 --- /dev/null +++ b/cmd/run.go @@ -0,0 +1,257 @@ +package main + +import ( + "context" + "crypto/ecdsa" + "fmt" + "os" + "os/signal" + "runtime" + + zkevm "github.com/0xPolygon/cdk" + dataCommitteeClient "github.com/0xPolygon/cdk-data-availability/client" + "github.com/0xPolygon/cdk/aggregator" + "github.com/0xPolygon/cdk/config" + "github.com/0xPolygon/cdk/dataavailability" + "github.com/0xPolygon/cdk/dataavailability/datacommittee" + "github.com/0xPolygon/cdk/db" + "github.com/0xPolygon/cdk/etherman" + "github.com/0xPolygon/cdk/log" + "github.com/0xPolygon/cdk/sequencesender" + "github.com/0xPolygon/cdk/state" + "github.com/0xPolygon/cdk/state/pgstatestorage" + ethtxman "github.com/0xPolygonHermez/zkevm-ethtx-manager/etherman" + "github.com/0xPolygonHermez/zkevm-ethtx-manager/etherman/etherscan" + "github.com/jackc/pgx/v4/pgxpool" + "github.com/urfave/cli/v2" +) + +func start(cliCtx *cli.Context) error { + c, err := config.Load(cliCtx, true) + if err != nil { + return err + } + + log.Init(c.Log) + + if c.Log.Environment == log.EnvironmentDevelopment { + zkevm.PrintVersion(os.Stdout) + log.Info("Starting application") + } else if c.Log.Environment == log.EnvironmentProduction { + logVersion() + } + + components := cliCtx.StringSlice(config.FlagComponents) + + for _, component := range components { + switch component { + case SEQUENCE_SENDER: + c.SequenceSender.Log = c.Log + seqSender := createSequenceSender(*c) + // start sequence sender in a goroutine, checking for errors + go seqSender.Start(cliCtx.Context) + + case AGGREGATOR: + aggregator := createAggregator(cliCtx.Context, *c, !cliCtx.Bool(config.FlagMigrations)) + // start aggregator in a goroutine, checking for errors + go func() { + if err := aggregator.Start(cliCtx.Context); err != nil { + log.Fatal(err) + } + }() + } + } + + waitSignal(nil) + + return nil +} + +func createAggregator(ctx context.Context, c config.Config, runMigrations bool) *aggregator.Aggregator { + // Migrations + if runMigrations { + log.Infof("Running DB migrations host: %s:%s db:%s user:%s", c.Aggregator.DB.Host, c.Aggregator.DB.Port, c.Aggregator.DB.Name, c.Aggregator.DB.User) + runAggregatorMigrations(c.Aggregator.DB) + } + + // DB + stateSqlDB, err := db.NewSQLDB(c.Aggregator.DB) + if err != nil { + log.Fatal(err) + } + + etherman, err := newEtherman(c) + if err != nil { + log.Fatal(err) + } + + // READ CHAIN ID FROM POE SC + l2ChainID, err := etherman.GetL2ChainID() + if err != nil { + log.Fatal(err) + } + + st := newState(&c, l2ChainID, stateSqlDB) + + c.Aggregator.ChainID = l2ChainID + + checkAggregatorMigrations(c.Aggregator.DB) + + // Populate Network config + c.Aggregator.Synchronizer.Etherman.Contracts.GlobalExitRootManagerAddr = c.NetworkConfig.L1Config.GlobalExitRootManagerAddr + c.Aggregator.Synchronizer.Etherman.Contracts.RollupManagerAddr = c.NetworkConfig.L1Config.RollupManagerAddr + c.Aggregator.Synchronizer.Etherman.Contracts.ZkEVMAddr = c.NetworkConfig.L1Config.ZkEVMAddr + + aggregator, err := aggregator.New(ctx, c.Aggregator, st, etherman) + if err != nil { + log.Fatal(err) + } + + return aggregator +} + +func createSequenceSender(cfg config.Config) *sequencesender.SequenceSender { + ethman, err := etherman.NewClient(etherman.Config{ + EthermanConfig: ethtxman.Config{ + URL: cfg.SequenceSender.EthTxManager.Etherman.URL, + MultiGasProvider: cfg.SequenceSender.EthTxManager.Etherman.MultiGasProvider, + L1ChainID: cfg.SequenceSender.EthTxManager.Etherman.L1ChainID, + Etherscan: etherscan.Config{ + ApiKey: cfg.SequenceSender.EthTxManager.Etherman.Etherscan.ApiKey, + Url: cfg.SequenceSender.EthTxManager.Etherman.Etherscan.Url, + }, + HTTPHeaders: cfg.SequenceSender.EthTxManager.Etherman.HTTPHeaders, + }, + IsValidiumMode: cfg.SequenceSender.IsValidiumMode, + }, cfg.NetworkConfig.L1Config) + if err != nil { + log.Fatal(err) + } + + auth, _, err := ethman.LoadAuthFromKeyStore(cfg.SequenceSender.PrivateKey.Path, cfg.SequenceSender.PrivateKey.Password) + if err != nil { + log.Fatal(err) + } + cfg.SequenceSender.SenderAddress = auth.From + + da, err := newDataAvailability(cfg, ethman) + if err != nil { + log.Fatal(err) + } + + seqSender, err := sequencesender.New(cfg.SequenceSender, ethman, da) + if err != nil { + log.Fatal(err) + } + + return seqSender +} + +func newDataAvailability(c config.Config, etherman *etherman.Client) (*dataavailability.DataAvailability, error) { + if !c.SequenceSender.IsValidiumMode { + return nil, nil + } + + // Backend specific config + daProtocolName, err := etherman.GetDAProtocolName() + if err != nil { + return nil, fmt.Errorf("error getting data availability protocol name: %v", err) + } + var daBackend dataavailability.DABackender + switch daProtocolName { + case string(dataavailability.DataAvailabilityCommittee): + var ( + pk *ecdsa.PrivateKey + err error + ) + _, pk, err = etherman.LoadAuthFromKeyStore(c.SequenceSender.PrivateKey.Path, c.SequenceSender.PrivateKey.Password) + if err != nil { + return nil, err + } + dacAddr, err := etherman.GetDAProtocolAddr() + if err != nil { + return nil, fmt.Errorf("error getting trusted sequencer URI. Error: %v", err) + } + + daBackend, err = datacommittee.New( + c.SequenceSender.EthTxManager.Etherman.URL, + dacAddr, + pk, + dataCommitteeClient.NewFactory(), + ) + if err != nil { + return nil, err + } + default: + return nil, fmt.Errorf("unexpected / unsupported DA protocol: %s", daProtocolName) + } + + return dataavailability.New(daBackend) +} + +func runAggregatorMigrations(c db.Config) { + runMigrations(c, db.AggregatorMigrationName) +} + +func checkAggregatorMigrations(c db.Config) { + err := db.CheckMigrations(c, db.AggregatorMigrationName) + 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) { + config := etherman.Config{ + URL: c.Aggregator.EthTxManager.Etherman.URL, + } + return etherman.NewClient(config, c.NetworkConfig.L1Config) +} + +func logVersion() { + log.Infow("Starting application", + // 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), + ) +} + +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 newState(c *config.Config, l2ChainID uint64, sqlDB *pgxpool.Pool) *state.State { + stateCfg := state.Config{ + DB: c.Aggregator.DB, + ChainID: l2ChainID, + } + + stateDb := pgstatestorage.NewPostgresStorage(stateCfg, sqlDB) + + st := state.NewState(stateCfg, stateDb) + return st +} diff --git a/cmd/version.go b/cmd/version.go new file mode 100644 index 00000000..51766c02 --- /dev/null +++ b/cmd/version.go @@ -0,0 +1,13 @@ +package main + +import ( + "os" + + zkevm "github.com/0xPolygon/cdk" + "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 00000000..e2638907 --- /dev/null +++ b/config/config.go @@ -0,0 +1,136 @@ +package config + +import ( + "bytes" + "path/filepath" + "strings" + + "github.com/0xPolygon/cdk/aggregator" + "github.com/0xPolygon/cdk/etherman" + "github.com/0xPolygon/cdk/log" + "github.com/0xPolygon/cdk/sequencesender" + "github.com/0xPolygonHermez/zkevm-ethtx-manager/ethtxmanager" + "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" +) + +/* +Config represents the configuration of the entire Hermez Node +The file is [TOML format] +You could find some examples: + - `config/environments/local/local.node.config.toml`: running a permisionless node + - `config/environments/mainnet/node.config.toml` + - `config/environments/public/node.config.toml` + - `test/config/test.node.config.toml`: configuration for a trusted node used in CI + +[TOML format]: https://en.wikipedia.org/wiki/TOML +*/ +type Config struct { + // Configuration of the etherman (client for access L1) + Etherman etherman.Config + // Configuration for ethereum transaction manager + EthTxManager ethtxmanager.Config + // Configuration of the aggregator + Aggregator aggregator.Config + // Configure Log level for all the services, allow also to store the logs in a file + Log log.Config + // Configuration of the genesis of the network. This is used to known the initial state of the network + NetworkConfig NetworkConfig + // Configuration of the sequence sender service + SequenceSender sequencesender.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("CDK") + 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 00000000..f8dce471 --- /dev/null +++ b/config/default.go @@ -0,0 +1,118 @@ +package config + +// DefaultValues is the default configuration +const DefaultValues = ` +ForkUpgradeBatchNumber = 0 +ForkUpgradeNewForkId = 0 + +[Log] +Environment = "development" # "production" or "development" +Level = "info" +Outputs = ["stderr"] + +[SequenceSender] +IsValidiumMode = false +WaitPeriodSendSequence = "15s" +LastBatchVirtualizationTimeMaxWaitPeriod = "10s" +L1BlockTimestampMargin = "30s" +MaxTxSizeForL1 = 131072 +L2Coinbase = "0xfa3b44587990f97ba8b6ba7e230a5f0e95d14b3d" +PrivateKey = {Path = "./test/sequencer.keystore", Password = "testonly"} +SequencesTxFileName = "sequencesender.json" +GasOffset = 80000 +WaitPeriodPurgeTxFile = "15m" +MaxPendingTx = 1 + [SequenceSender.StreamClient] + Server = "127.0.0.1:6900" + [SequenceSender.EthTxManager] + FrequencyToMonitorTxs = "1s" + WaitTxToBeMined = "2m" + GetReceiptMaxTime = "250ms" + GetReceiptWaitInterval = "1s" + PrivateKeys = [ + {Path = "./test/sequencer.keystore", Password = "testonly"}, + ] + ForcedGas = 0 + GasPriceMarginFactor = 1 + MaxGasPriceLimit = 0 + PersistenceFilename = "ethtxmanager.json" + ReadPendingL1Txs = false + SafeStatusL1NumberOfBlocks = 0 + FinalizedStatusL1NumberOfBlocks = 0 + [SequenceSender.EthTxManager.Etherman] + URL = "http://127.0.0.1:8545" + MultiGasProvider = false + L1ChainID = 1337 +[Aggregator] +Host = "0.0.0.0" +Port = 50081 +RetryTime = "5s" +VerifyProofInterval = "10s" +TxProfitabilityCheckerType = "acceptall" +TxProfitabilityMinReward = "1.1" +ProofStatePollingInterval = "5s" +SenderAddress = "" +CleanupLockedProofsInterval = "2m" +GeneratingProofCleanupThreshold = "10m" +ForkId = 9 +GasOffset = 0 +WitnessURL = "localhost:8123" +UseL1BatchData = true +UseFullWitness = false +SettlementBackend = "l1" +AggLayerTxTimeout = "5m" +AggLayerURL = "" +SequencerPrivateKey = {} + [Aggregator.DB] + Name = "aggregator_db" + User = "aggregator_user" + Password = "aggregator_password" + Host = "cdk-aggregator-db" + Port = "5432" + EnableLog = false + MaxConns = 200 + [Aggregator.Log] + Environment = "development" # "production" or "development" + Level = "info" + Outputs = ["stderr"] + [Aggregator.StreamClient] + Server = "localhost:6900" + [Aggregator.EthTxManager] + FrequencyToMonitorTxs = "1s" + WaitTxToBeMined = "2m" + GetReceiptMaxTime = "250ms" + GetReceiptWaitInterval = "1s" + PrivateKeys = [ + {Path = "/pk/aggregator.keystore", Password = "testonly"}, + ] + ForcedGas = 0 + GasPriceMarginFactor = 1 + MaxGasPriceLimit = 0 + PersistenceFilename = "" + ReadPendingL1Txs = false + SafeStatusL1NumberOfBlocks = 0 + FinalizedStatusL1NumberOfBlocks = 0 + [Aggregator.EthTxManager.Etherman] + URL = "" + L1ChainID = 11155111 + HTTPHeaders = [] + [Aggregator.Synchronizer] + [Aggregator.Synchronizer.DB] + Name = "sync_db" + User = "sync_user" + Password = "sync_password" + Host = "cdk-l1-sync-db" + Port = "5432" + EnableLog = false + MaxConns = 10 + [Aggregator.Synchronizer.Synchronizer] + SyncInterval = "10s" + SyncChunkSize = 1000 + GenesisBlockNumber = 5511080 + SyncUpToBlock = "finalized" + BlockFinality = "finalized" + OverrideStorageCheck = false + [Aggregator.Synchronizer.Etherman] + [Aggregator.Synchronizer.Etherman.Validium] + Enabled = false +` diff --git a/config/mainnetgenesis.go b/config/mainnetgenesis.go new file mode 100644 index 00000000..d981590a --- /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 00000000..1d33aba0 --- /dev/null +++ b/config/network.go @@ -0,0 +1,178 @@ +package config + +import ( + "encoding/json" + "errors" + "fmt" + "io" + "os" + + "github.com/0xPolygon/cdk/etherman" + "github.com/0xPolygon/cdk/log" + "github.com/0xPolygon/cdk/state" + "github.com/ethereum/go-ethereum/common" + "github.com/urfave/cli/v2" +) + +// 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 state.Genesis +} + +type network string +type leafType uint8 + +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 +) + +// 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 netwrork 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 = state.Genesis{ + BlockNumber: cfgJSON.GenesisBlockNum, + Root: common.HexToHash(cfgJSON.Root), + Actions: []*state.GenesisAction{}, + } + + for _, account := range cfgJSON.Genesis { + if account.Balance != "" && account.Balance != "0" { + action := &state.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 := &state.GenesisAction{ + Address: account.Address, + Type: int(LeafTypeNonce), + Value: account.Nonce, + } + cfg.Genesis.Actions = append(cfg.Genesis.Actions, action) + } + if account.Bytecode != "" { + action := &state.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 := &state.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 00000000..75041ad9 --- /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 00000000..7612291f --- /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 00000000..71e06a04 --- /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 00000000..620834e9 --- /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/dataavailability/config.go b/dataavailability/config.go new file mode 100644 index 00000000..8163e7bc --- /dev/null +++ b/dataavailability/config.go @@ -0,0 +1,9 @@ +package dataavailability + +// DABackendType is the data availability protocol for the CDK +type DABackendType string + +const ( + // DataAvailabilityCommittee is the DAC protocol backend + DataAvailabilityCommittee DABackendType = "DataAvailabilityCommittee" +) diff --git a/dataavailability/dataavailability.go b/dataavailability/dataavailability.go new file mode 100644 index 00000000..f385d09d --- /dev/null +++ b/dataavailability/dataavailability.go @@ -0,0 +1,34 @@ +package dataavailability + +import ( + "context" + + "github.com/0xPolygon/cdk/etherman/types" +) + +// DataAvailability implements an abstract data availability integration +type DataAvailability struct { + backend DABackender +} + +// New creates a DataAvailability instance +func New(backend DABackender) (*DataAvailability, error) { + da := &DataAvailability{ + backend: backend, + } + + return da, da.backend.Init() +} + +// PostSequence sends the sequence data to the data availability backend, and returns the dataAvailabilityMessage +// as expected by the contract +func (d *DataAvailability) PostSequence(ctx context.Context, sequences []types.Sequence) ([]byte, error) { + batchesData := [][]byte{} + for _, batch := range sequences { + // Do not send to the DA backend data that will be stored to L1 + if batch.ForcedBatchTimestamp == 0 { + batchesData = append(batchesData, batch.BatchL2Data) + } + } + return d.backend.PostSequence(ctx, batchesData) +} diff --git a/dataavailability/datacommittee/datacommittee.go b/dataavailability/datacommittee/datacommittee.go new file mode 100644 index 00000000..dd1e6cfa --- /dev/null +++ b/dataavailability/datacommittee/datacommittee.go @@ -0,0 +1,318 @@ +package datacommittee + +import ( + "crypto/ecdsa" + "errors" + "fmt" + "math/big" + "math/rand" + "sort" + "strings" + + "github.com/0xPolygon/cdk-data-availability/client" + daTypes "github.com/0xPolygon/cdk-data-availability/types" + "github.com/0xPolygon/cdk/etherman/smartcontracts/polygondatacommittee" + "github.com/0xPolygon/cdk/log" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/ethclient" + "golang.org/x/net/context" +) + +const unexpectedHashTemplate = "missmatch on transaction data. Expected hash %s, actual hash: %s" + +// DataCommitteeMember represents a member of the Data Committee +type DataCommitteeMember struct { + Addr common.Address + URL string +} + +// DataCommittee represents a specific committee +type DataCommittee struct { + AddressesHash common.Hash + Members []DataCommitteeMember + RequiredSignatures uint64 +} + +// Backend implements the DAC integration +type Backend struct { + dataCommitteeContract *polygondatacommittee.Polygondatacommittee + privKey *ecdsa.PrivateKey + dataCommitteeClientFactory client.Factory + + committeeMembers []DataCommitteeMember + selectedCommitteeMember int + ctx context.Context +} + +// New creates an instance of Backend +func New( + l1RPCURL string, + dataCommitteeAddr common.Address, + privKey *ecdsa.PrivateKey, + dataCommitteeClientFactory client.Factory, +) (*Backend, error) { + ethClient, err := ethclient.Dial(l1RPCURL) + if err != nil { + log.Errorf("error connecting to %s: %+v", l1RPCURL, err) + return nil, err + } + + dataCommittee, err := polygondatacommittee.NewPolygondatacommittee(dataCommitteeAddr, ethClient) + if err != nil { + return nil, err + } + + return &Backend{ + dataCommitteeContract: dataCommittee, + privKey: privKey, + dataCommitteeClientFactory: dataCommitteeClientFactory, + ctx: context.Background(), + }, nil +} + +// Init loads the DAC to be cached when needed +func (d *Backend) Init() error { + committee, err := d.getCurrentDataCommittee() + if err != nil { + return err + } + selectedCommitteeMember := -1 + if committee != nil { + d.committeeMembers = committee.Members + if len(committee.Members) > 0 { + selectedCommitteeMember = rand.Intn(len(committee.Members)) //nolint:gosec + } + } + d.selectedCommitteeMember = selectedCommitteeMember + return nil +} + +// GetSequence gets backend data one hash at a time. This should be optimized on the DAC side to get them all at once. +func (d *Backend) GetSequence(_ context.Context, hashes []common.Hash, _ []byte) ([][]byte, error) { + // TODO: optimize this on the DAC side by implementing a multi batch retrieve api) + var batchData [][]byte + for _, h := range hashes { + data, err := d.GetBatchL2Data(h) + if err != nil { + return nil, err + } + batchData = append(batchData, data) + } + return batchData, nil +} + +// GetBatchL2Data returns the data from the DAC. It checks that it matches with the expected hash +func (d *Backend) GetBatchL2Data(hash common.Hash) ([]byte, error) { + intialMember := d.selectedCommitteeMember + found := false + for !found && intialMember != -1 { + member := d.committeeMembers[d.selectedCommitteeMember] + log.Infof("trying to get data from %s at %s", member.Addr.Hex(), member.URL) + c := d.dataCommitteeClientFactory.New(member.URL) + data, err := c.GetOffChainData(d.ctx, hash) + if err != nil { + log.Warnf( + "error getting data from DAC node %s at %s: %s", + member.Addr.Hex(), member.URL, err, + ) + d.selectedCommitteeMember = (d.selectedCommitteeMember + 1) % len(d.committeeMembers) + if d.selectedCommitteeMember == intialMember { + break + } + continue + } + actualTransactionsHash := crypto.Keccak256Hash(data) + if actualTransactionsHash != hash { + unexpectedHash := fmt.Errorf( + unexpectedHashTemplate, hash, actualTransactionsHash, + ) + log.Warnf( + "error getting data from DAC node %s at %s: %s", + member.Addr.Hex(), member.URL, unexpectedHash, + ) + d.selectedCommitteeMember = (d.selectedCommitteeMember + 1) % len(d.committeeMembers) + if d.selectedCommitteeMember == intialMember { + break + } + continue + } + return data, nil + } + if err := d.Init(); err != nil { + return nil, fmt.Errorf("error loading data committee: %s", err) + } + return nil, fmt.Errorf("couldn't get the data from any committee member") +} + +type signatureMsg struct { + addr common.Address + signature []byte + err error +} + +// PostSequence sends the sequence data to the data availability backend, and returns the dataAvailabilityMessage +// as expected by the contract +func (s *Backend) PostSequence(ctx context.Context, batchesData [][]byte) ([]byte, error) { + // Get current committee + committee, err := s.getCurrentDataCommittee() + if err != nil { + return nil, err + } + + // Authenticate as trusted sequencer by signing the sequence + sequence := make(daTypes.Sequence, 0, len(batchesData)) + for _, batchData := range batchesData { + sequence = append(sequence, batchData) + } + signedSequence, err := sequence.Sign(s.privKey) + if err != nil { + return nil, err + } + + // Request signatures to all members in parallel + ch := make(chan signatureMsg, len(committee.Members)) + signatureCtx, cancelSignatureCollection := context.WithCancel(ctx) + for _, member := range committee.Members { + go requestSignatureFromMember(signatureCtx, *signedSequence, member, ch) + } + + // Collect signatures + var ( + msgs = make(signatureMsgs, 0, len(committee.Members)) + collectedSignatures uint64 + failedToCollect uint64 + ) + for collectedSignatures < committee.RequiredSignatures { + msg := <-ch + if msg.err != nil { + log.Errorf("error when trying to get signature from %s: %s", msg.addr, msg.err) + failedToCollect++ + if len(committee.Members)-int(failedToCollect) < int(committee.RequiredSignatures) { + cancelSignatureCollection() + return nil, errors.New("too many members failed to send their signature") + } + } else { + log.Infof("received signature from %s", msg.addr) + collectedSignatures++ + } + msgs = append(msgs, msg) + } + + // Stop requesting as soon as we have N valid signatures + cancelSignatureCollection() + + return buildSignaturesAndAddrs(msgs, committee.Members), nil +} + +func requestSignatureFromMember(ctx context.Context, signedSequence daTypes.SignedSequence, member DataCommitteeMember, ch chan signatureMsg) { + select { + case <-ctx.Done(): + return + default: + } + + // request + c := client.New(member.URL) + log.Infof("sending request to sign the sequence to %s at %s", member.Addr.Hex(), member.URL) + signature, err := c.SignSequence(signedSequence) + if err != nil { + ch <- signatureMsg{ + addr: member.Addr, + err: err, + } + return + } + // verify returned signature + signedSequence.Signature = signature + signer, err := signedSequence.Signer() + if err != nil { + ch <- signatureMsg{ + addr: member.Addr, + err: err, + } + return + } + if signer != member.Addr { + ch <- signatureMsg{ + addr: member.Addr, + err: fmt.Errorf("invalid signer. Expected %s, actual %s", member.Addr.Hex(), signer.Hex()), + } + return + } + ch <- signatureMsg{ + addr: member.Addr, + signature: signature, + } +} + +func buildSignaturesAndAddrs(sigs signatureMsgs, members []DataCommitteeMember) []byte { + const ( + sigLen = 65 + ) + res := make([]byte, 0, len(sigs)*sigLen+len(members)*common.AddressLength) + sort.Sort(sigs) + for _, msg := range sigs { + log.Debugf("adding signature %s from %s", common.Bytes2Hex(msg.signature), msg.addr.Hex()) + res = append(res, msg.signature...) + } + for _, member := range members { + log.Debugf("adding addr %s", common.Bytes2Hex(member.Addr.Bytes())) + res = append(res, member.Addr.Bytes()...) + } + log.Debugf("full res %s", common.Bytes2Hex(res)) + return res +} + +type signatureMsgs []signatureMsg + +func (s signatureMsgs) Len() int { return len(s) } +func (s signatureMsgs) Less(i, j int) bool { + return strings.ToUpper(s[i].addr.Hex()) < strings.ToUpper(s[j].addr.Hex()) +} +func (s signatureMsgs) Swap(i, j int) { s[i], s[j] = s[j], s[i] } + +// getCurrentDataCommittee return the currently registered data committee +func (d *Backend) getCurrentDataCommittee() (*DataCommittee, error) { + addrsHash, err := d.dataCommitteeContract.CommitteeHash(&bind.CallOpts{Pending: false}) + if err != nil { + return nil, fmt.Errorf("error getting CommitteeHash from L1 SC: %w", err) + } + + reqSign, err := d.dataCommitteeContract.RequiredAmountOfSignatures(&bind.CallOpts{Pending: false}) + if err != nil { + return nil, fmt.Errorf("error getting RequiredAmountOfSignatures from L1 SC: %w", err) + } + + members, err := d.getCurrentDataCommitteeMembers() + if err != nil { + return nil, err + } + + return &DataCommittee{ + AddressesHash: addrsHash, + RequiredSignatures: reqSign.Uint64(), + Members: members, + }, nil +} + +// getCurrentDataCommitteeMembers return the currently registered data committee members +func (d *Backend) getCurrentDataCommitteeMembers() ([]DataCommitteeMember, error) { + nMembers, err := d.dataCommitteeContract.GetAmountOfMembers(&bind.CallOpts{Pending: false}) + if err != nil { + return nil, fmt.Errorf("error getting GetAmountOfMembers from L1 SC: %w", err) + } + members := make([]DataCommitteeMember, 0, nMembers.Int64()) + for i := int64(0); i < nMembers.Int64(); i++ { + member, err := d.dataCommitteeContract.Members(&bind.CallOpts{Pending: false}, big.NewInt(i)) + if err != nil { + return nil, fmt.Errorf("error getting Members %d from L1 SC: %w", i, err) + } + members = append(members, DataCommitteeMember{ + Addr: member.Addr, + URL: member.Url, + }) + } + return members, nil +} diff --git a/dataavailability/datacommittee/datacommittee_test.go b/dataavailability/datacommittee/datacommittee_test.go new file mode 100644 index 00000000..ddb0de29 --- /dev/null +++ b/dataavailability/datacommittee/datacommittee_test.go @@ -0,0 +1,131 @@ +package datacommittee + +import ( + "math/big" + "testing" + + "github.com/0xPolygon/cdk/etherman/smartcontracts/polygondatacommittee" + "github.com/0xPolygon/cdk/log" + "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/crypto" + "github.com/ethereum/go-ethereum/ethclient/simulated" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func TestUpdateDataCommitteeEvent(t *testing.T) { + // Set up testing environment + dac, ethBackend, auth, da := newTestingEnv(t) + + // Update the committee + requiredAmountOfSignatures := big.NewInt(2) + URLs := []string{"1", "2", "3"} + addrs := []common.Address{ + common.HexToAddress("0x1"), + common.HexToAddress("0x2"), + common.HexToAddress("0x3"), + } + addrsBytes := []byte{} + for _, addr := range addrs { + addrsBytes = append(addrsBytes, addr.Bytes()...) + } + _, err := da.SetupCommittee(auth, requiredAmountOfSignatures, URLs, addrsBytes) + require.NoError(t, err) + ethBackend.Commit() + + // Assert the committee update + actualSetup, err := dac.getCurrentDataCommittee() + require.NoError(t, err) + expectedMembers := []DataCommitteeMember{} + expectedSetup := DataCommittee{ + RequiredSignatures: uint64(len(URLs) - 1), + AddressesHash: crypto.Keccak256Hash(addrsBytes), + } + for i, url := range URLs { + expectedMembers = append(expectedMembers, DataCommitteeMember{ + URL: url, + Addr: addrs[i], + }) + } + expectedSetup.Members = expectedMembers + assert.Equal(t, expectedSetup, *actualSetup) +} + +func init() { + log.Init(log.Config{ + Level: "debug", + Outputs: []string{"stderr"}, + }) +} + +// This function prepare the blockchain, the wallet with funds and deploy the smc +func newTestingEnv(t *testing.T) ( + dac *Backend, + ethBackend *simulated.Backend, + auth *bind.TransactOpts, + da *polygondatacommittee.Polygondatacommittee, +) { + t.Helper() + privateKey, err := crypto.GenerateKey() + if err != nil { + log.Fatal(err) + } + auth, err = bind.NewKeyedTransactorWithChainID(privateKey, big.NewInt(1337)) + if err != nil { + log.Fatal(err) + } + dac, ethBackend, da, err = newSimulatedDacman(t, auth) + if err != nil { + log.Fatal(err) + } + return dac, ethBackend, auth, da +} + +// NewSimulatedEtherman creates an etherman that uses a simulated blockchain. It's important to notice that the ChainID of the auth +// must be 1337. The address that holds the auth will have an initial balance of 10 ETH +func newSimulatedDacman(t *testing.T, auth *bind.TransactOpts) ( + dacman *Backend, + ethBackend *simulated.Backend, + da *polygondatacommittee.Polygondatacommittee, + err error, +) { + t.Helper() + if auth == nil { + // read only client + return &Backend{}, nil, nil, nil + } + // 10000000 ETH in wei + balance, _ := new(big.Int).SetString("10000000000000000000000000", 10) //nolint:gomnd + address := auth.From + genesisAlloc := map[common.Address]types.Account{ + address: { + Balance: balance, + }, + } + blockGasLimit := uint64(999999999999999999) //nolint:gomnd + client := simulated.NewBackend(genesisAlloc, simulated.WithBlockGasLimit(blockGasLimit)) + + // DAC Setup + _, _, da, err = polygondatacommittee.DeployPolygondatacommittee(auth, client.Client()) + if err != nil { + return &Backend{}, nil, nil, err + } + client.Commit() + _, err = da.Initialize(auth) + if err != nil { + return &Backend{}, nil, nil, err + } + client.Commit() + _, err = da.SetupCommittee(auth, big.NewInt(0), []string{}, []byte{}) + if err != nil { + return &Backend{}, nil, nil, err + } + client.Commit() + + c := &Backend{ + dataCommitteeContract: da, + } + return c, client, da, nil +} diff --git a/dataavailability/interfaces.go b/dataavailability/interfaces.go new file mode 100644 index 00000000..ba86e1a6 --- /dev/null +++ b/dataavailability/interfaces.go @@ -0,0 +1,40 @@ +package dataavailability + +import ( + "context" + + "github.com/ethereum/go-ethereum/common" +) + +// DABackender is an interface for components that store and retrieve batch data +type DABackender interface { + SequenceRetriever + SequenceSender + // Init initializes the DABackend + Init() error +} + +// SequenceSender is used to send provided sequence of batches +type SequenceSender interface { + // PostSequence sends the sequence data to the data availability backend, and returns the dataAvailabilityMessage + // as expected by the contract + PostSequence(ctx context.Context, batchesData [][]byte) ([]byte, error) +} + +// SequenceRetriever is used to retrieve batch data +type SequenceRetriever interface { + // GetSequence retrieves the sequence data from the data availability backend + GetSequence(ctx context.Context, batchHashes []common.Hash, dataAvailabilityMessage []byte) ([][]byte, error) +} + +// BatchDataProvider is used to retrieve batch data +type BatchDataProvider interface { + // GetBatchL2Data retrieve the data of a batch from the DA backend. The returned data must be the pre-image of the hash + GetBatchL2Data(batchNum []uint64, batchHashes []common.Hash, dataAvailabilityMessage []byte) ([][]byte, error) +} + +// DataManager is an interface for components that send and retrieve batch data +type DataManager interface { + BatchDataProvider + SequenceSender +} diff --git a/db/config.go b/db/config.go new file mode 100644 index 00000000..ad56155f --- /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 00000000..21b31938 --- /dev/null +++ b/db/db.go @@ -0,0 +1,123 @@ +package db + +import ( + "context" + "fmt" + + "github.com/0xPolygon/cdk/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 ( + // AggregatorMigrationName is the name of the migration used by packr to pack the migration file + AggregatorMigrationName = "zkevm-aggregator-db" +) + +var packrMigrations = map[string]*packr.Box{ + AggregatorMigrationName: packr.New(AggregatorMigrationName, "./migrations/aggregator"), +} + +// 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 00000000..3b425b13 --- /dev/null +++ b/db/logger.go @@ -0,0 +1,27 @@ +package db + +import ( + "context" + "fmt" + + "github.com/0xPolygon/cdk/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/aggregator/0001.sql b/db/migrations/aggregator/0001.sql new file mode 100644 index 00000000..963dbea7 --- /dev/null +++ b/db/migrations/aggregator/0001.sql @@ -0,0 +1,32 @@ +-- +migrate Down +DROP SCHEMA IF EXISTS aggregator CASCADE; + +-- +migrate Up +CREATE SCHEMA aggregator; + +CREATE TABLE IF NOT EXISTS aggregator.batch ( + batch_num BIGINT NOT NULL, + batch jsonb NOT NULL, + datastream varchar NOT NULL, + PRIMARY KEY (batch_num) +); + +CREATE TABLE IF NOT EXISTS aggregator.proof ( + batch_num BIGINT NOT NULL REFERENCES aggregator.batch (batch_num) ON DELETE CASCADE, + batch_num_final BIGINT NOT NULL, + proof varchar NULL, + proof_id varchar NULL, + input_prover varchar NULL, + prover varchar NULL, + prover_id varchar NULL, + created_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), + updated_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), + generating_since timestamptz NULL, + PRIMARY KEY (batch_num, batch_num_final) +); + +CREATE TABLE IF NOT EXISTS aggregator.sequence ( + from_batch_num BIGINT NOT NULL REFERENCES aggregator.batch (batch_num) ON DELETE CASCADE, + to_batch_num BIGINT NOT NULL, + PRIMARY KEY (from_batch_num) +); diff --git a/encoding/encoding.go b/encoding/encoding.go new file mode 100644 index 00000000..5568746c --- /dev/null +++ b/encoding/encoding.go @@ -0,0 +1,110 @@ +package encoding + +import ( + "fmt" + "math/big" + "strconv" + "strings" + + "github.com/0xPolygon/cdk/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/aggregator.go b/etherman/aggregator.go new file mode 100644 index 00000000..e653c2db --- /dev/null +++ b/etherman/aggregator.go @@ -0,0 +1,113 @@ +package etherman + +import ( + "context" + "errors" + "fmt" + "math/big" + "strings" + + "github.com/0xPolygon/cdk/encoding" + ethmanTypes "github.com/0xPolygon/cdk/etherman/types" + "github.com/0xPolygon/cdk/log" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/crypto" +) + +// 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 +} + +// GetBatchAccInputHash gets the batch accumulated input hash from the ethereum +func (etherman *Client) GetBatchAccInputHash(ctx context.Context, batchNumber uint64) (common.Hash, error) { + rollupData, err := etherman.RollupManager.GetRollupSequencedBatches(&bind.CallOpts{Pending: false}, etherman.RollupID, batchNumber) + if err != nil { + return common.Hash{}, err + } + return rollupData.AccInputHash, nil +} + +// GetRollupId returns the rollup id +func (etherMan *Client) GetRollupId() uint32 { + return etherMan.RollupID +} + +// 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 +} + +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 +} diff --git a/etherman/config.go b/etherman/config.go new file mode 100644 index 00000000..15904d91 --- /dev/null +++ b/etherman/config.go @@ -0,0 +1,17 @@ +package etherman + +import "github.com/0xPolygonHermez/zkevm-ethtx-manager/etherman" + +// Config represents the configuration of the etherman +type Config struct { + // URL is the URL of the Ethereum node for L1 + URL string `mapstructure:"URL"` + + EthermanConfig etherman.Config + + // IsValidiumMode is a flag to indicate if the sequence sender is running in validium mode + IsValidiumMode bool + + // ForkIDChunkSize is the max interval for each call to L1 provider to get the forkIDs + ForkIDChunkSize uint64 `mapstructure:"ForkIDChunkSize"` +} diff --git a/etherman/errors.go b/etherman/errors.go new file mode 100644 index 00000000..38a4e47d --- /dev/null +++ b/etherman/errors.go @@ -0,0 +1,52 @@ +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") + // ErrNotFound is used when the object is not found + ErrNotFound = errors.New("not found") + // 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") + + 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/errors_test.go b/etherman/errors_test.go new file mode 100644 index 00000000..186768e6 --- /dev/null +++ b/etherman/errors_test.go @@ -0,0 +1,37 @@ +package etherman + +import ( + "fmt" + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestTryParseWithExactMatch(t *testing.T) { + expected := ErrTimestampMustBeInsideRange + smartContractErr := expected + + actualErr, ok := tryParseError(smartContractErr) + + assert.ErrorIs(t, actualErr, expected) + assert.True(t, ok) +} + +func TestTryParseWithContains(t *testing.T) { + expected := ErrTimestampMustBeInsideRange + smartContractErr := fmt.Errorf(" execution reverted: ProofOfEfficiency::sequenceBatches: %s", expected) + + actualErr, ok := tryParseError(smartContractErr) + + assert.ErrorIs(t, actualErr, expected) + assert.True(t, ok) +} + +func TestTryParseWithNonExistingErr(t *testing.T) { + smartContractErr := fmt.Errorf("some non-existing err") + + actualErr, ok := tryParseError(smartContractErr) + + assert.Nil(t, actualErr) + assert.False(t, ok) +} diff --git a/etherman/etherman.go b/etherman/etherman.go new file mode 100644 index 00000000..d9c6476d --- /dev/null +++ b/etherman/etherman.go @@ -0,0 +1,1686 @@ +package etherman + +import ( + "context" + "crypto/ecdsa" + "encoding/json" + "errors" + "fmt" + "math/big" + "os" + "path/filepath" + "strings" + "time" + + "github.com/0xPolygon/cdk/etherman/etherscan" + "github.com/0xPolygon/cdk/etherman/ethgasstation" + "github.com/0xPolygon/cdk/etherman/smartcontracts/dataavailabilityprotocol" + "github.com/0xPolygon/cdk/etherman/smartcontracts/oldpolygonzkevm" + "github.com/0xPolygon/cdk/etherman/smartcontracts/oldpolygonzkevmglobalexitroot" + "github.com/0xPolygon/cdk/etherman/smartcontracts/pol" + "github.com/0xPolygon/cdk/etherman/smartcontracts/polygonrollupmanager" + "github.com/0xPolygon/cdk/etherman/smartcontracts/polygonzkevm" + "github.com/0xPolygon/cdk/etherman/smartcontracts/polygonzkevmglobalexitroot" + ethmanTypes "github.com/0xPolygon/cdk/etherman/types" + "github.com/0xPolygon/cdk/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)")) +) + +// 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 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.GasPricer1559 + 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 + DAProtocol *dataavailabilityprotocol.Dataavailabilityprotocol + 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.EthermanConfig.URL) + if err != nil { + log.Errorf("error connecting to %s: %+v", cfg.EthermanConfig.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.EthermanConfig.MultiGasProvider { + if cfg.EthermanConfig.Etherscan.ApiKey == "" { + log.Info("No ApiKey provided for etherscan. Ignoring provider...") + } else { + log.Info("ApiKey detected for etherscan") + gProviders = append(gProviders, etherscan.NewEtherscanService(cfg.EthermanConfig.Etherscan.ApiKey)) + } + gProviders = append(gProviders, ethgasstation.NewEthGasStationService()) + } + + // Get RollupID + rollupID, err := rollupManager.RollupAddressToID(&bind.CallOpts{Pending: false}, l1Config.ZkEVMAddr) + if err != nil { + return nil, err + } + log.Debug("rollupID: ", rollupID) + + client := &Client{ + EthClient: ethClient, + ZkEVM: zkevm, + OldZkEVM: oldZkevm, + RollupManager: rollupManager, + Pol: pol, + GlobalExitRootManager: globalExitRoot, + SCAddresses: scAddresses, + RollupID: rollupID, + GasProviders: externalGasProviders{ + MultiGasProvider: cfg.EthermanConfig.MultiGasProvider, + Providers: gProviders, + }, + l1Cfg: l1Config, + cfg: cfg, + auth: map[common.Address]bind.TransactOpts{}, + } + + if cfg.IsValidiumMode { + dapAddr, err := zkevm.DataAvailabilityProtocol(&bind.CallOpts{Pending: false}) + if err != nil { + return nil, err + } + + client.DAProtocol, err = dataavailabilityprotocol.NewDataavailabilityprotocol(dapAddr, ethClient) + if err != nil { + return nil, err + } + } + + return client, nil +} + +// VerifyGenBlockNumber verifies if the genesis Block Number is valid +func (etherMan *Client) VerifyGenBlockNumber(ctx context.Context, genBlockNumber uint64) (bool, error) { + 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) + } + return true, 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) { + logs, err := etherMan.EthClient.FilterLogs(ctx, query) + if err != nil { + return nil, nil, err + } + var blocks []Block + blocksOrder := make(map[common.Hash][]Order) + for _, vLog := range logs { + err := etherMan.processEvent(ctx, vLog, &blocks, &blocksOrder) + if err != nil { + log.Warnf("error processing event. Retrying... Error: %s. vLog: %+v", err.Error(), vLog) + return nil, nil, err + } + } + 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: initialSequenceBatches.Sequencer, + 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 := operations.WaitTxToBeMined(ctx, etherMan.EthClient, tx, timeout) + // if errors.Is(err, context.DeadlineExceeded) { + // return false, nil + // } + // if err != nil { + // return false, err + // } + return true, nil +} + +// BuildSequenceBatchesTx builds a tx to be sent to the PoE SC method SequenceBatches. +func (etherMan *Client) BuildSequenceBatchesTx(sender common.Address, sequences []ethmanTypes.Sequence, maxSequenceTimestamp uint64, lastSequencedBatchNumber uint64, l2Coinbase common.Address, dataAvailabilityMessage []byte) (*types.Transaction, error) { + opts, err := etherMan.getAuthByAddress(sender) + if err == ErrNotFound { + return 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) + + return etherMan.sequenceBatches(opts, sequences, maxSequenceTimestamp, lastSequencedBatchNumber, l2Coinbase, dataAvailabilityMessage) +} + +func (etherMan *Client) sequenceBatches(opts bind.TransactOpts, sequences []ethmanTypes.Sequence, maxSequenceTimestamp uint64, lastSequencedBatchNumber uint64, l2Coinbase common.Address, dataAvailabilityMessage []byte) (tx *types.Transaction, err error) { + if etherMan.cfg.IsValidiumMode { + return etherMan.sequenceBatchesValidium(opts, sequences, maxSequenceTimestamp, lastSequencedBatchNumber, l2Coinbase, dataAvailabilityMessage) + } + + return etherMan.sequenceBatchesRollup(opts, sequences, maxSequenceTimestamp, lastSequencedBatchNumber, l2Coinbase) +} + +func (etherMan *Client) sequenceBatchesRollup(opts bind.TransactOpts, sequences []ethmanTypes.Sequence, maxSequenceTimestamp uint64, lastSequencedBatchNumber uint64, l2Coinbase common.Address) (*types.Transaction, error) { + batches := make([]polygonzkevm.PolygonRollupBaseEtrogBatchData, len(sequences)) + for i, seq := range sequences { + var ger common.Hash + if seq.ForcedBatchTimestamp > 0 { + ger = seq.GlobalExitRoot + } + + batches[i] = polygonzkevm.PolygonRollupBaseEtrogBatchData{ + Transactions: seq.BatchL2Data, + ForcedGlobalExitRoot: ger, + ForcedTimestamp: uint64(seq.ForcedBatchTimestamp), + ForcedBlockHashL1: seq.PrevBlockHash, + } + } + + tx, err := etherMan.ZkEVM.SequenceBatches(&opts, batches, maxSequenceTimestamp, lastSequencedBatchNumber, 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, maxSequenceTimestamp, lastSequencedBatchNumber, 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, etherMan.l1Cfg.ZkEVMAddr, common.Bytes2Hex(input), b) + if parsedErr, ok := tryParseError(err); ok { + err = parsedErr + } + } + + return tx, err +} + +func (etherMan *Client) sequenceBatchesValidium(opts bind.TransactOpts, sequences []ethmanTypes.Sequence, maxSequenceTimestamp uint64, lastSequencedBatchNumber uint64, l2Coinbase common.Address, dataAvailabilityMessage []byte) (*types.Transaction, error) { + batches := make([]polygonzkevm.PolygonValidiumEtrogValidiumBatchData, len(sequences)) + for i, seq := range sequences { + var ger common.Hash + if seq.ForcedBatchTimestamp > 0 { + ger = seq.GlobalExitRoot + } + + batches[i] = polygonzkevm.PolygonValidiumEtrogValidiumBatchData{ + TransactionsHash: crypto.Keccak256Hash(seq.BatchL2Data), + ForcedGlobalExitRoot: ger, + ForcedTimestamp: uint64(seq.ForcedBatchTimestamp), + ForcedBlockHashL1: seq.PrevBlockHash, + } + } + + tx, err := etherMan.ZkEVM.SequenceBatchesValidium(&opts, batches, maxSequenceTimestamp, lastSequencedBatchNumber, l2Coinbase, dataAvailabilityMessage) + 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("sequenceBatchesValidium", batches, maxSequenceTimestamp, lastSequencedBatchNumber, l2Coinbase, dataAvailabilityMessage) + 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, etherMan.l1Cfg.ZkEVMAddr, 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 +// return nil, nil, 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 +} + +// 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 := operations.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, *ecdsa.PrivateKey, error) { + auth, pk, err := newAuthFromKeystore(path, password, etherMan.l1Cfg.L1ChainID) + if err != nil { + return nil, nil, err + } + + log.Infof("loaded authorization for address: %v", auth.From.String()) + etherMan.auth[auth.From] = auth + return &auth, pk, 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, *ecdsa.PrivateKey, error) { + log.Infof("reading key from: %v", path) + key, err := newKeyFromKeystore(path, password) + if err != nil { + return bind.TransactOpts{}, nil, err + } + if key == nil { + return bind.TransactOpts{}, nil, nil + } + auth, err := bind.NewKeyedTransactorWithChainID(key.PrivateKey, new(big.Int).SetUint64(chainID)) + if err != nil { + return bind.TransactOpts{}, nil, err + } + return *auth, key.PrivateKey, 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 +} + +// GetLatestBlockHeader gets the latest block header from the ethereum +func (etherMan *Client) GetLatestBlockHeader(ctx context.Context) (*types.Header, error) { + header, err := etherMan.EthClient.HeaderByNumber(ctx, big.NewInt(int64(rpc.LatestBlockNumber))) + if err != nil || header == nil { + return nil, err + } + return header, nil +} + +// GetDAProtocolAddr returns the address of the data availability protocol +func (etherMan *Client) GetDAProtocolAddr() (common.Address, error) { + return etherMan.ZkEVM.DataAvailabilityProtocol(&bind.CallOpts{Pending: false}) +} + +// GetDAProtocolName returns the name of the data availability protocol +func (etherMan *Client) GetDAProtocolName() (string, error) { + return etherMan.DAProtocol.GetProcotolName(&bind.CallOpts{Pending: false}) +} diff --git a/etherman/etherscan/etherscan.go b/etherman/etherscan/etherscan.go new file mode 100644 index 00000000..a8e98c27 --- /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/0xPolygon/cdk/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 00000000..38c0ffb9 --- /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/0xPolygon/cdk/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 00000000..cf642299 --- /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/0xPolygon/cdk/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 00000000..62547444 --- /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/0xPolygon/cdk/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/mock_etherscan.go b/etherman/mock_etherscan.go new file mode 100644 index 00000000..d3a128c4 --- /dev/null +++ b/etherman/mock_etherscan.go @@ -0,0 +1,59 @@ +// Code generated by mockery v2.39.0. DO NOT EDIT. + +package etherman + +import ( + context "context" + big "math/big" + + mock "github.com/stretchr/testify/mock" +) + +// etherscanMock is an autogenerated mock type for the GasPricer type +type etherscanMock struct { + mock.Mock +} + +// SuggestGasPrice provides a mock function with given fields: ctx +func (_m *etherscanMock) SuggestGasPrice(ctx context.Context) (*big.Int, error) { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for SuggestGasPrice") + } + + var r0 *big.Int + var r1 error + if rf, ok := ret.Get(0).(func(context.Context) (*big.Int, error)); ok { + return rf(ctx) + } + if rf, ok := ret.Get(0).(func(context.Context) *big.Int); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*big.Int) + } + } + + if rf, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = rf(ctx) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// newEtherscanMock creates a new instance of etherscanMock. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func newEtherscanMock(t interface { + mock.TestingT + Cleanup(func()) +}) *etherscanMock { + mock := ðerscanMock{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/etherman/mock_ethgasstation.go b/etherman/mock_ethgasstation.go new file mode 100644 index 00000000..ed0e3346 --- /dev/null +++ b/etherman/mock_ethgasstation.go @@ -0,0 +1,59 @@ +// Code generated by mockery v2.39.0. DO NOT EDIT. + +package etherman + +import ( + context "context" + big "math/big" + + mock "github.com/stretchr/testify/mock" +) + +// ethGasStationMock is an autogenerated mock type for the GasPricer type +type ethGasStationMock struct { + mock.Mock +} + +// SuggestGasPrice provides a mock function with given fields: ctx +func (_m *ethGasStationMock) SuggestGasPrice(ctx context.Context) (*big.Int, error) { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for SuggestGasPrice") + } + + var r0 *big.Int + var r1 error + if rf, ok := ret.Get(0).(func(context.Context) (*big.Int, error)); ok { + return rf(ctx) + } + if rf, ok := ret.Get(0).(func(context.Context) *big.Int); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*big.Int) + } + } + + if rf, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = rf(ctx) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// newEthGasStationMock creates a new instance of ethGasStationMock. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func newEthGasStationMock(t interface { + mock.TestingT + Cleanup(func()) +}) *ethGasStationMock { + mock := ðGasStationMock{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/etherman/simulated.go b/etherman/simulated.go new file mode 100644 index 00000000..8645e858 --- /dev/null +++ b/etherman/simulated.go @@ -0,0 +1,208 @@ +package etherman + +import ( + "context" + "fmt" + "math/big" + + "github.com/0xPolygon/cdk/etherman/smartcontracts/mockpolygonrollupmanager" + "github.com/0xPolygon/cdk/etherman/smartcontracts/mockverifier" + "github.com/0xPolygon/cdk/etherman/smartcontracts/pol" + "github.com/0xPolygon/cdk/etherman/smartcontracts/polygonrollupmanager" + "github.com/0xPolygon/cdk/etherman/smartcontracts/polygonzkevm" + "github.com/0xPolygon/cdk/etherman/smartcontracts/polygonzkevmbridge" + "github.com/0xPolygon/cdk/etherman/smartcontracts/polygonzkevmglobalexitroot" + "github.com/0xPolygon/cdk/etherman/smartcontracts/proxy" + "github.com/0xPolygon/cdk/log" + "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/crypto" + "github.com/ethereum/go-ethereum/ethclient/simulated" +) + +// NewSimulatedEtherman creates an etherman that uses a simulated blockchain. It's important to notice that the ChainID of the auth +// must be 1337. The address that holds the auth will have an initial balance of 10 ETH +func NewSimulatedEtherman(cfg Config, auth *bind.TransactOpts) (*Client, *simulated.Backend, common.Address, *polygonzkevmbridge.Polygonzkevmbridge, error) { + if auth == nil { + // read only client + return &Client{}, nil, common.Address{}, nil, nil + } + // 10000000 ETH in wei + balance, _ := new(big.Int).SetString("10000000000000000000000000", 10) //nolint:gomnd + address := auth.From + genesisAlloc := map[common.Address]types.Account{ + address: { + Balance: balance, + }, + } + blockGasLimit := uint64(999999999999999999) //nolint:gomnd + client := simulated.NewBackend(genesisAlloc, simulated.WithBlockGasLimit(blockGasLimit)) + + // Deploy contracts + const polDecimalPlaces = 18 + totalSupply, _ := new(big.Int).SetString("10000000000000000000000000000", 10) //nolint:gomnd + polAddr, _, polContract, err := pol.DeployPol(auth, client.Client(), "Pol Token", "POL", polDecimalPlaces, totalSupply) + if err != nil { + log.Error("error: ", err) + return nil, nil, common.Address{}, nil, err + } + rollupVerifierAddr, _, _, err := mockverifier.DeployMockverifier(auth, client.Client()) + if err != nil { + return nil, nil, common.Address{}, nil, err + } + nonce, err := client.Client().PendingNonceAt(context.TODO(), auth.From) + if err != nil { + log.Error("error: ", err) + return nil, nil, common.Address{}, nil, err + } + const posBridge = 3 + calculatedBridgeAddr := crypto.CreateAddress(auth.From, nonce+posBridge) + const posRollupManager = 4 + calculatedRollupManagerAddr := crypto.CreateAddress(auth.From, nonce+posRollupManager) + genesis := common.HexToHash("0xfd3434cd8f67e59d73488a2b8da242dd1f02849ea5dd99f0ca22c836c3d5b4a9") // Random value. Needs to be different to 0x0 + exitManagerAddr, _, globalExitRoot, err := polygonzkevmglobalexitroot.DeployPolygonzkevmglobalexitroot(auth, client.Client(), calculatedRollupManagerAddr, calculatedBridgeAddr) + if err != nil { + log.Error("error: ", err) + return nil, nil, common.Address{}, nil, err + } + implementationBridgeAddr, _, _, err := polygonzkevmbridge.DeployPolygonzkevmbridge(auth, client.Client()) + if err != nil { + log.Error("error: ", err) + return nil, nil, common.Address{}, nil, err + } + + implementationMockRollupManagerAddr, _, _, err := mockpolygonrollupmanager.DeployMockpolygonrollupmanager(auth, client.Client(), exitManagerAddr, polAddr, calculatedBridgeAddr) + if err != nil { + log.Error("error: ", err) + return nil, nil, common.Address{}, nil, err + } + client.Commit() + bridgeAddr, _, _, err := proxy.DeployProxy(auth, client.Client(), implementationBridgeAddr, implementationBridgeAddr, []byte{}) + if err != nil { + log.Error("error: ", err) + return nil, nil, common.Address{}, nil, err + } + mockRollupManagerAddr, _, _, err := proxy.DeployProxy(auth, client.Client(), implementationMockRollupManagerAddr, implementationMockRollupManagerAddr, []byte{}) + if err != nil { + log.Error("error: ", err) + return nil, nil, common.Address{}, nil, err + } + if calculatedRollupManagerAddr != mockRollupManagerAddr { + return nil, nil, common.Address{}, nil, fmt.Errorf("RollupManagerAddr (%s) is different from the expected contract address (%s)", + mockRollupManagerAddr.String(), calculatedRollupManagerAddr.String()) + } + initZkevmAddr, _, _, err := polygonzkevm.DeployPolygonzkevm(auth, client.Client(), exitManagerAddr, polAddr, bridgeAddr, mockRollupManagerAddr) + if err != nil { + log.Error("error: ", err) + return nil, nil, common.Address{}, nil, err + } + mockRollupManager, err := mockpolygonrollupmanager.NewMockpolygonrollupmanager(mockRollupManagerAddr, client.Client()) + if err != nil { + log.Error("error: ", err) + return nil, nil, common.Address{}, nil, err + } + br, err := polygonzkevmbridge.NewPolygonzkevmbridge(bridgeAddr, client.Client()) + if err != nil { + log.Error("error: ", err) + return nil, nil, common.Address{}, nil, err + } + client.Commit() + _, err = br.Initialize(auth, 0, common.Address{}, 0, exitManagerAddr, mockRollupManagerAddr, []byte{}) + if err != nil { + log.Error("error: ", err) + return nil, nil, common.Address{}, nil, err + } + client.Commit() + _, err = mockRollupManager.Initialize(auth, auth.From, 10000, 10000, auth.From, auth.From, auth.From, common.Address{}, common.Address{}, 0, 0) //nolint:gomnd + if err != nil { + log.Error("error: ", err) + return nil, nil, common.Address{}, nil, err + } + client.Commit() + _, err = mockRollupManager.AddNewRollupType(auth, initZkevmAddr, rollupVerifierAddr, 6, 0, genesis, "PolygonZkEvm Rollup") //nolint:gomnd + if err != nil { + log.Error("error: ", err) + return nil, nil, common.Address{}, nil, err + } + client.Commit() + + rollUpTypeID, err := mockRollupManager.RollupTypeCount(&bind.CallOpts{Pending: false}) + if err != nil { + log.Error("error: ", err) + return nil, nil, common.Address{}, nil, err + } + var zkevmChainID uint64 = 100 + _, err = mockRollupManager.CreateNewRollup(auth, rollUpTypeID, zkevmChainID, auth.From, auth.From, common.Address{}, "http://localhost", "PolygonZkEvm Rollup") + if err != nil { + log.Error("error: ", err) + return nil, nil, common.Address{}, nil, err + } + client.Commit() + + rollupID, err := mockRollupManager.ChainIDToRollupID(&bind.CallOpts{Pending: false}, zkevmChainID) + if err != nil { + log.Error("error: ", err) + return nil, nil, common.Address{}, nil, err + } + rollupData, err := mockRollupManager.RollupIDToRollupData(&bind.CallOpts{Pending: false}, rollupID) + if err != nil { + log.Error("error: ", err) + return nil, nil, common.Address{}, nil, err + } + zkevmAddr := rollupData.RollupContract + + if calculatedBridgeAddr != bridgeAddr { + return nil, nil, common.Address{}, nil, fmt.Errorf("bridgeAddr (%s) is different from the expected contract address (%s)", + bridgeAddr.String(), calculatedBridgeAddr.String()) + } + + rollupManager, err := polygonrollupmanager.NewPolygonrollupmanager(mockRollupManagerAddr, client.Client()) + if err != nil { + log.Error("error: ", err) + return nil, nil, common.Address{}, nil, err + } + + trueZkevm, err := polygonzkevm.NewPolygonzkevm(zkevmAddr, client.Client()) //nolint + if err != nil { + log.Error("error: ", err) + return nil, nil, common.Address{}, nil, err + } + + // Approve the bridge and zkevm to spend 10000 pol tokens. + approvedAmount, _ := new(big.Int).SetString("10000000000000000000000", 10) //nolint:gomnd + _, err = polContract.Approve(auth, bridgeAddr, approvedAmount) + if err != nil { + log.Error("error: ", err) + return nil, nil, common.Address{}, nil, err + } + _, err = polContract.Approve(auth, zkevmAddr, approvedAmount) + if err != nil { + log.Error("error: ", err) + return nil, nil, common.Address{}, nil, err + } + + _, err = trueZkevm.SetForceBatchAddress(auth, common.Address{}) + if err != nil { + log.Error("error: ", err) + return nil, nil, common.Address{}, nil, err + } + client.Commit() + + c := &Client{ + EthClient: client.Client(), + ZkEVM: trueZkevm, + RollupManager: rollupManager, + Pol: polContract, + GlobalExitRootManager: globalExitRoot, + RollupID: rollupID, + SCAddresses: []common.Address{zkevmAddr, mockRollupManagerAddr, exitManagerAddr}, + auth: map[common.Address]bind.TransactOpts{}, + cfg: cfg, + } + err = c.AddOrReplaceAuth(*auth) + if err != nil { + return nil, nil, common.Address{}, nil, err + } + return c, client, polAddr, br, nil +} diff --git a/etherman/smartcontracts/abi/dataavailabilityprotocol.abi b/etherman/smartcontracts/abi/dataavailabilityprotocol.abi new file mode 100644 index 00000000..32135ee0 --- /dev/null +++ b/etherman/smartcontracts/abi/dataavailabilityprotocol.abi @@ -0,0 +1,33 @@ +[ + { + "inputs": [], + "name": "getProcotolName", + "outputs": [ + { + "internalType": "string", + "name": "", + "type": "string" + } + ], + "stateMutability": "pure", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "hash", + "type": "bytes32" + }, + { + "internalType": "bytes", + "name": "dataAvailabilityMessage", + "type": "bytes" + } + ], + "name": "verifyMessage", + "outputs": [], + "stateMutability": "view", + "type": "function" + } +] \ No newline at end of file diff --git a/etherman/smartcontracts/abi/etrogpolygonzkevm.abi b/etherman/smartcontracts/abi/etrogpolygonzkevm.abi new file mode 100644 index 00000000..6b4f9c24 --- /dev/null +++ b/etherman/smartcontracts/abi/etrogpolygonzkevm.abi @@ -0,0 +1,1210 @@ +[ + { + "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": "ForceBatchesDecentralized", + "type": "error" + }, + { + "inputs": [], + "name": "ForceBatchesNotAllowedOnEmergencyState", + "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": "HaltTimeoutNotExpiredAfterEmergencyState", + "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": [ + { + "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": "address", + "name": "newForceBatchAddress", + "type": "address" + } + ], + "name": "SetForceBatchAddress", + "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": false, + "internalType": "uint64", + "name": "numBatch", + "type": "uint64" + }, + { + "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": "UpdateEtrogSequence", + "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": "SET_UP_ETROG_TX", + "outputs": [ + { + "internalType": "bytes", + "name": "", + "type": "bytes" + } + ], + "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": "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": "forceBatchAddress", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "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": "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": [ + { + "internalType": "address", + "name": "_admin", + "type": "address" + }, + { + "internalType": "address", + "name": "_trustedSequencer", + "type": "address" + }, + { + "internalType": "string", + "name": "_trustedSequencerURL", + "type": "string" + }, + { + "internalType": "string", + "name": "_networkName", + "type": "string" + }, + { + "internalType": "bytes32", + "name": "_lastAccInputHash", + "type": "bytes32" + } + ], + "name": "initializeUpgrade", + "outputs": [], + "stateMutability": "nonpayable", + "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": "address", + "name": "newForceBatchAddress", + "type": "address" + } + ], + "name": "setForceBatchAddress", + "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/mockpolygonrollupmanager.abi b/etherman/smartcontracts/abi/mockpolygonrollupmanager.abi new file mode 100644 index 00000000..e5b6bea1 --- /dev/null +++ b/etherman/smartcontracts/abi/mockpolygonrollupmanager.abi @@ -0,0 +1,1963 @@ +[ + { + "inputs": [ + { + "internalType": "contract IPolygonZkEVMGlobalExitRootV2", + "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": "RollupAddressAlreadyExist", + "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 IPolygonZkEVMGlobalExitRootV2", + "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 PolygonZkEVMExistentEtrog", + "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": "lastDeactivatedEmergencyStateTimestamp", + "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 00000000..2c532b86 --- /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 00000000..3007afc8 --- /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 00000000..f7547c00 --- /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 00000000..9b1be9d7 --- /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 00000000..cb102756 --- /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/polygondatacommittee.abi b/etherman/smartcontracts/abi/polygondatacommittee.abi new file mode 100644 index 00000000..71356f29 --- /dev/null +++ b/etherman/smartcontracts/abi/polygondatacommittee.abi @@ -0,0 +1,239 @@ +[ + { + "inputs": [], + "name": "CommitteeAddressDoesntExist", + "type": "error" + }, + { + "inputs": [], + "name": "EmptyURLNotAllowed", + "type": "error" + }, + { + "inputs": [], + "name": "TooManyRequiredSignatures", + "type": "error" + }, + { + "inputs": [], + "name": "UnexpectedAddrsAndSignaturesSize", + "type": "error" + }, + { + "inputs": [], + "name": "UnexpectedAddrsBytesLength", + "type": "error" + }, + { + "inputs": [], + "name": "UnexpectedCommitteeHash", + "type": "error" + }, + { + "inputs": [], + "name": "WrongAddrOrder", + "type": "error" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bytes32", + "name": "committeeHash", + "type": "bytes32" + } + ], + "name": "CommitteeUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "uint8", + "name": "version", + "type": "uint8" + } + ], + "name": "Initialized", + "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" + }, + { + "inputs": [], + "name": "committeeHash", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "getAmountOfMembers", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "getProcotolName", + "outputs": [ + { + "internalType": "string", + "name": "", + "type": "string" + } + ], + "stateMutability": "pure", + "type": "function" + }, + { + "inputs": [], + "name": "initialize", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "members", + "outputs": [ + { + "internalType": "string", + "name": "url", + "type": "string" + }, + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "renounceOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "requiredAmountOfSignatures", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "_requiredAmountOfSignatures", + "type": "uint256" + }, + { + "internalType": "string[]", + "name": "urls", + "type": "string[]" + }, + { + "internalType": "bytes", + "name": "addrsBytes", + "type": "bytes" + } + ], + "name": "setupCommittee", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "signedHash", + "type": "bytes32" + }, + { + "internalType": "bytes", + "name": "signaturesAndAddrs", + "type": "bytes" + } + ], + "name": "verifyMessage", + "outputs": [], + "stateMutability": "view", + "type": "function" + } +] \ 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 00000000..e5b6bea1 --- /dev/null +++ b/etherman/smartcontracts/abi/polygonrollupmanager.abi @@ -0,0 +1,1963 @@ +[ + { + "inputs": [ + { + "internalType": "contract IPolygonZkEVMGlobalExitRootV2", + "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": "RollupAddressAlreadyExist", + "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 IPolygonZkEVMGlobalExitRootV2", + "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 PolygonZkEVMExistentEtrog", + "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": "lastDeactivatedEmergencyStateTimestamp", + "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 00000000..5a68cc5a --- /dev/null +++ b/etherman/smartcontracts/abi/polygonzkevm.abi @@ -0,0 +1,1302 @@ +[ + { + "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": "ForceBatchesDecentralized", + "type": "error" + }, + { + "inputs": [], + "name": "ForceBatchesNotAllowedOnEmergencyState", + "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": "HaltTimeoutNotExpiredAfterEmergencyState", + "type": "error" + }, + { + "inputs": [], + "name": "HugeTokenMetadataNotSupported", + "type": "error" + }, + { + "inputs": [], + "name": "InitNumBatchAboveLastVerifiedBatch", + "type": "error" + }, + { + "inputs": [], + "name": "InitNumBatchDoesNotMatchPendingState", + "type": "error" + }, + { + "inputs": [], + "name": "InitSequencedBatchDoesNotMatch", + "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": "MaxTimestampSequenceInvalid", + "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": "SequenceWithDataAvailabilityNotAllowed", + "type": "error" + }, + { + "inputs": [], + "name": "SequenceZeroBatches", + "type": "error" + }, + { + "inputs": [], + "name": "SequencedTimestampBelowForcedTimestamp", + "type": "error" + }, + { + "inputs": [], + "name": "SequencedTimestampInvalid", + "type": "error" + }, + { + "inputs": [], + "name": "StoredRootMustBeDifferentThanNewRoot", + "type": "error" + }, + { + "inputs": [], + "name": "SwitchToSameValue", + "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": [ + { + "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": "address", + "name": "newDataAvailabilityProtocol", + "type": "address" + } + ], + "name": "SetDataAvailabilityProtocol", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "newForceBatchAddress", + "type": "address" + } + ], + "name": "SetForceBatchAddress", + "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": [], + "name": "SwitchSequenceWithDataAvailability", + "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": "TIMESTAMP_RANGE", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "acceptAdminRole", + "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": [], + "name": "dataAvailabilityProtocol", + "outputs": [ + { + "internalType": "contract IDataAvailabilityProtocol", + "name": "", + "type": "address" + } + ], + "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": "forceBatchAddress", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "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": "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": "isSequenceWithDataAvailabilityAllowed", + "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": "uint64", + "name": "maxSequenceTimestamp", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "initSequencedBatch", + "type": "uint64" + }, + { + "internalType": "address", + "name": "l2Coinbase", + "type": "address" + } + ], + "name": "sequenceBatches", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "bytes32", + "name": "transactionsHash", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "forcedGlobalExitRoot", + "type": "bytes32" + }, + { + "internalType": "uint64", + "name": "forcedTimestamp", + "type": "uint64" + }, + { + "internalType": "bytes32", + "name": "forcedBlockHashL1", + "type": "bytes32" + } + ], + "internalType": "struct PolygonValidiumEtrog.ValidiumBatchData[]", + "name": "batches", + "type": "tuple[]" + }, + { + "internalType": "uint64", + "name": "maxSequenceTimestamp", + "type": "uint64" + }, + { + "internalType": "uint64", + "name": "initSequencedBatch", + "type": "uint64" + }, + { + "internalType": "address", + "name": "l2Coinbase", + "type": "address" + }, + { + "internalType": "bytes", + "name": "dataAvailabilityMessage", + "type": "bytes" + } + ], + "name": "sequenceBatchesValidium", + "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": "contract IDataAvailabilityProtocol", + "name": "newDataAvailabilityProtocol", + "type": "address" + } + ], + "name": "setDataAvailabilityProtocol", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newForceBatchAddress", + "type": "address" + } + ], + "name": "setForceBatchAddress", + "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": "bool", + "name": "newIsSequenceWithDataAvailabilityAllowed", + "type": "bool" + } + ], + "name": "switchSequenceWithDataAvailability", + "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 00000000..5ab04774 --- /dev/null +++ b/etherman/smartcontracts/abi/polygonzkevmbridge.abi @@ -0,0 +1,1004 @@ +[ + { + "inputs": [], + "stateMutability": "nonpayable", + "type": "constructor" + }, + { + "inputs": [], + "name": "AlreadyClaimed", + "type": "error" + }, + { + "inputs": [], + "name": "AmountDoesNotMatchMsgValue", + "type": "error" + }, + { + "inputs": [], + "name": "DestinationNetworkInvalid", + "type": "error" + }, + { + "inputs": [], + "name": "EtherTransferFailed", + "type": "error" + }, + { + "inputs": [], + "name": "FailedTokenWrappedDeployment", + "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": "BASE_INIT_BYTECODE_WRAPPED_TOKEN", + "outputs": [ + { + "internalType": "bytes", + "name": "", + "type": "bytes" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "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 00000000..f048bd69 --- /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/abi/proxy.abi b/etherman/smartcontracts/abi/proxy.abi new file mode 100644 index 00000000..e8caa6d3 --- /dev/null +++ b/etherman/smartcontracts/abi/proxy.abi @@ -0,0 +1,146 @@ +[ + { + "inputs": [ + { + "internalType": "address", + "name": "_logic", + "type": "address" + }, + { + "internalType": "address", + "name": "admin_", + "type": "address" + }, + { + "internalType": "bytes", + "name": "_data", + "type": "bytes" + } + ], + "stateMutability": "payable", + "type": "constructor" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "address", + "name": "previousAdmin", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "newAdmin", + "type": "address" + } + ], + "name": "AdminChanged", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "beacon", + "type": "address" + } + ], + "name": "BeaconUpgraded", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "implementation", + "type": "address" + } + ], + "name": "Upgraded", + "type": "event" + }, + { + "stateMutability": "payable", + "type": "fallback" + }, + { + "inputs": [], + "name": "admin", + "outputs": [ + { + "internalType": "address", + "name": "admin_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newAdmin", + "type": "address" + } + ], + "name": "changeAdmin", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "implementation", + "outputs": [ + { + "internalType": "address", + "name": "implementation_", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newImplementation", + "type": "address" + } + ], + "name": "upgradeTo", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newImplementation", + "type": "address" + }, + { + "internalType": "bytes", + "name": "data", + "type": "bytes" + } + ], + "name": "upgradeToAndCall", + "outputs": [], + "stateMutability": "payable", + "type": "function" + }, + { + "stateMutability": "payable", + "type": "receive" + } +] \ No newline at end of file diff --git a/etherman/smartcontracts/bin/etrogpolygonzkevm.bin b/etherman/smartcontracts/bin/etrogpolygonzkevm.bin new file mode 100644 index 00000000..48be9467 --- /dev/null +++ b/etherman/smartcontracts/bin/etrogpolygonzkevm.bin @@ -0,0 +1 @@ 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 \ 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 00000000..578904f6 --- /dev/null +++ b/etherman/smartcontracts/bin/mockpolygonrollupmanager.bin @@ -0,0 +1 @@ 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 \ 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 00000000..65911564 --- /dev/null +++ b/etherman/smartcontracts/bin/mockverifier.bin @@ -0,0 +1 @@ +608060405234801561001057600080fd5b50610158806100206000396000f3fe608060405234801561001057600080fd5b506004361061002b5760003560e01c80639121da8a14610030575b600080fd5b61004661003e366004610089565b600192915050565b604051901515815260200160405180910390f35b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b60008061032080848603121561009e57600080fd5b6103008401858111156100b057600080fd5b8493508561031f8601126100c357600080fd5b604051602080820182811067ffffffffffffffff821117156100e7576100e761005a565b6040529286019281888511156100fc57600080fd5b5b8484101561011457833581529281019281016100fd565b50949790965094505050505056fea264697066735822122066b50cbb730099c9f1f258fa949f9d4e1a1ef7636af905817cebb300b2be0d2664736f6c63430008140033 \ 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 00000000..ab66043c --- /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 00000000..37426f49 --- /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 00000000..36c75dfc --- /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 00000000..dcb03185 --- /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/polygondatacommittee.bin b/etherman/smartcontracts/bin/polygondatacommittee.bin new file mode 100644 index 00000000..39e1df2f --- /dev/null +++ b/etherman/smartcontracts/bin/polygondatacommittee.bin @@ -0,0 +1 @@ +608060405234801561001057600080fd5b50611646806100206000396000f3fe608060405234801561001057600080fd5b50600436106100c95760003560e01c8063715018a611610081578063dce1e2b61161005b578063dce1e2b614610178578063e4f1712014610180578063f2fde38b146101bf57600080fd5b8063715018a6146101405780638129fc1c146101485780638da5cb5b1461015057600080fd5b80635daf08ca116100b25780635daf08ca146100f6578063609d4544146101205780636beedd391461013757600080fd5b8063078fba2a146100ce5780633b51be4b146100e3575b600080fd5b6100e16100dc366004610fe9565b6101d2565b005b6100e16100f1366004611094565b6104d4565b6101096101043660046110e0565b61071f565b60405161011792919061115d565b60405180910390f35b61012960665481565b604051908152602001610117565b61012960655481565b6100e16107f1565b6100e1610805565b60335460405173ffffffffffffffffffffffffffffffffffffffff9091168152602001610117565b606754610129565b604080518082018252601981527f44617461417661696c6162696c697479436f6d6d697474656500000000000000602082015290516101179190611195565b6100e16101cd3660046111af565b61099c565b6101da610a50565b8285811015610215576040517f2e7dcd6e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b610220601482611214565b8214610258576040517f2ab6a12900000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b61026460676000610ef5565b6000805b8281101561047857600061027d601483611214565b9050600086828761028f60148361122b565b9261029c9392919061123e565b6102a591611268565b60601c90508888848181106102bc576102bc6112b0565b90506020028101906102ce91906112df565b9050600003610309576040517fb54b70e400000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8073ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff161061036e576040517fd53cfbe000000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b606760405180604001604052808b8b8781811061038d5761038d6112b0565b905060200281019061039f91906112df565b8080601f016020809104026020016040519081016040528093929190818152602001838380828437600092018290525093855250505073ffffffffffffffffffffffffffffffffffffffff851660209283015283546001810185559381522081519192600202019081906104139082611415565b5060209190910151600190910180547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff90921691909117905592508190506104708161152f565b915050610268565b508383604051610489929190611567565b6040519081900381206066819055606589905581527f831403fd381b3e6ac875d912ec2eee0e0203d0d29f7b3e0c96fc8f582d6db6579060200160405180910390a150505050505050565b60655460006104e4826041611214565b905080831080610508575060146104fb8285611577565b61050591906115b9565b15155b1561053f576040517f6b8eec4600000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60665461054e8483818861123e565b60405161055c929190611567565b60405180910390201461059b576040517f6b156b2800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60008060146105aa8487611577565b6105b491906115cd565b905060005b848110156107155760006105ce604183611214565b9050600061062b8a8a848b6105e460418361122b565b926105f19392919061123e565b8080601f016020809104026020016040519081016040528093929190818152602001838380828437600092019190915250610ad192505050565b90506000855b858110156106c7576000610646601483611214565b610650908a61122b565b905060008c828d61066260148361122b565b9261066f9392919061123e565b61067891611268565b60601c905073ffffffffffffffffffffffffffffffffffffffff851681036106b2576106a583600161122b565b98506001935050506106c7565b505080806106bf9061152f565b915050610631565b50806106ff576040517f8431721300000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b505050808061070d9061152f565b9150506105b9565b5050505050505050565b6067818154811061072f57600080fd5b906000526020600020906002020160009150905080600001805461075290611373565b80601f016020809104026020016040519081016040528092919081815260200182805461077e90611373565b80156107cb5780601f106107a0576101008083540402835291602001916107cb565b820191906000526020600020905b8154815290600101906020018083116107ae57829003601f168201915b5050506001909301549192505073ffffffffffffffffffffffffffffffffffffffff1682565b6107f9610a50565b6108036000610af7565b565b600054610100900460ff16158080156108255750600054600160ff909116105b8061083f5750303b15801561083f575060005460ff166001145b6108d0576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602e60248201527f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160448201527f647920696e697469616c697a656400000000000000000000000000000000000060648201526084015b60405180910390fd5b600080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00166001179055801561092e57600080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff166101001790555b610936610b6e565b801561099957600080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff169055604051600181527f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb38474024989060200160405180910390a15b50565b6109a4610a50565b73ffffffffffffffffffffffffffffffffffffffff8116610a47576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201527f646472657373000000000000000000000000000000000000000000000000000060648201526084016108c7565b61099981610af7565b60335473ffffffffffffffffffffffffffffffffffffffff163314610803576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657260448201526064016108c7565b6000806000610ae08585610c0e565b91509150610aed81610c53565b5090505b92915050565b6033805473ffffffffffffffffffffffffffffffffffffffff8381167fffffffffffffffffffffffff0000000000000000000000000000000000000000831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b600054610100900460ff16610c05576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602b60248201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960448201527f6e697469616c697a696e6700000000000000000000000000000000000000000060648201526084016108c7565b61080333610af7565b6000808251604103610c445760208301516040840151606085015160001a610c3887828585610e06565b94509450505050610c4c565b506000905060025b9250929050565b6000816004811115610c6757610c676115e1565b03610c6f5750565b6001816004811115610c8357610c836115e1565b03610cea576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601860248201527f45434453413a20696e76616c6964207369676e6174757265000000000000000060448201526064016108c7565b6002816004811115610cfe57610cfe6115e1565b03610d65576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601f60248201527f45434453413a20696e76616c6964207369676e6174757265206c656e6774680060448201526064016108c7565b6003816004811115610d7957610d796115e1565b03610999576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602260248201527f45434453413a20696e76616c6964207369676e6174757265202773272076616c60448201527f756500000000000000000000000000000000000000000000000000000000000060648201526084016108c7565b6000807f7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0831115610e3d5750600090506003610eec565b6040805160008082526020820180845289905260ff881692820192909252606081018690526080810185905260019060a0016020604051602081039080840390855afa158015610e91573d6000803e3d6000fd5b50506040517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0015191505073ffffffffffffffffffffffffffffffffffffffff8116610ee557600060019250925050610eec565b9150600090505b94509492505050565b508054600082556002029060005260206000209081019061099991905b80821115610f59576000610f268282610f5d565b506001810180547fffffffffffffffffffffffff0000000000000000000000000000000000000000169055600201610f12565b5090565b508054610f6990611373565b6000825580601f10610f79575050565b601f01602090049060005260206000209081019061099991905b80821115610f595760008155600101610f93565b60008083601f840112610fb957600080fd5b50813567ffffffffffffffff811115610fd157600080fd5b602083019150836020828501011115610c4c57600080fd5b60008060008060006060868803121561100157600080fd5b85359450602086013567ffffffffffffffff8082111561102057600080fd5b818801915088601f83011261103457600080fd5b81358181111561104357600080fd5b8960208260051b850101111561105857600080fd5b60208301965080955050604088013591508082111561107657600080fd5b5061108388828901610fa7565b969995985093965092949392505050565b6000806000604084860312156110a957600080fd5b83359250602084013567ffffffffffffffff8111156110c757600080fd5b6110d386828701610fa7565b9497909650939450505050565b6000602082840312156110f257600080fd5b5035919050565b6000815180845260005b8181101561111f57602081850181015186830182015201611103565b5060006020828601015260207fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0601f83011685010191505092915050565b60408152600061117060408301856110f9565b905073ffffffffffffffffffffffffffffffffffffffff831660208301529392505050565b6020815260006111a860208301846110f9565b9392505050565b6000602082840312156111c157600080fd5b813573ffffffffffffffffffffffffffffffffffffffff811681146111a857600080fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b8082028115828204841417610af157610af16111e5565b80820180821115610af157610af16111e5565b6000808585111561124e57600080fd5b8386111561125b57600080fd5b5050820193919092039150565b7fffffffffffffffffffffffffffffffffffffffff00000000000000000000000081358181169160148510156112a85780818660140360031b1b83161692505b505092915050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b60008083357fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe184360301811261131457600080fd5b83018035915067ffffffffffffffff82111561132f57600080fd5b602001915036819003821315610c4c57600080fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600181811c9082168061138757607f821691505b6020821081036113c0577f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b50919050565b601f82111561141057600081815260208120601f850160051c810160208610156113ed5750805b601f850160051c820191505b8181101561140c578281556001016113f9565b5050505b505050565b815167ffffffffffffffff81111561142f5761142f611344565b6114438161143d8454611373565b846113c6565b602080601f83116001811461149657600084156114605750858301515b7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600386901b1c1916600185901b17855561140c565b6000858152602081207fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe08616915b828110156114e3578886015182559484019460019091019084016114c4565b508582101561151f57878501517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600388901b60f8161c191681555b5050505050600190811b01905550565b60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8203611560576115606111e5565b5060010190565b8183823760009101908152919050565b81810381811115610af157610af16111e5565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601260045260246000fd5b6000826115c8576115c861158a565b500690565b6000826115dc576115dc61158a565b500490565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602160045260246000fdfea2646970667358221220e34b71e7c7c23d67a42aa345fc1c3d9c57287ac1c2a2024084974dcc23e4088864736f6c63430008140033 \ 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 00000000..999663d1 --- /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 00000000..00c05497 --- /dev/null +++ b/etherman/smartcontracts/bin/polygonzkevm.bin @@ -0,0 +1 @@ +6101006040523480156200001257600080fd5b506040516200520038038062005200833981016040819052620000359162000071565b6001600160a01b0393841660a052918316608052821660c0521660e052620000d9565b6001600160a01b03811681146200006e57600080fd5b50565b600080600080608085870312156200008857600080fd5b8451620000958162000058565b6020860151909450620000a88162000058565b6040860151909350620000bb8162000058565b6060860151909250620000ce8162000058565b939692955090935050565b60805160a05160c05160e051615014620001ec6000396000818161054d01528181610b5601528181610cc301528181610f0e015281816114f401528181611a6201528181611eb901528181611faf01528181612bb301528181612c3201528181612c5401528181612df701528181613005015281816130cd01528181613b7901528181613bf201528181613c140152613cbf0152600081816106ef01528181611107015281816111e10152818161218001528181612288015281816126da01526136b60152600081816107ab015281816113680152818161275c015281816132180152613738015260008181610803015281816108e201528181611f0201528181612d0201526131ec01526150146000f3fe608060405234801561001057600080fd5b506004361061031f5760003560e01c80637a5460c5116101a7578063c89e42df116100ee578063e46761c411610097578063eaeb077b11610071578063eaeb077b14610859578063f35dda471461086c578063f851a4401461087457600080fd5b8063e46761c4146107fe578063e57a0b4c14610825578063e7a7ed021461084557600080fd5b8063d7bc90ff116100c8578063d7bc90ff146107cd578063db5b0ed7146107d8578063def57e54146107eb57600080fd5b8063c89e42df14610773578063cfa8ed4714610786578063d02103ca146107a657600080fd5b8063a3c573eb11610150578063b0afe1541161012a578063b0afe15414610737578063c754c7ed14610743578063c7fffd4b1461076b57600080fd5b8063a3c573eb146106ea578063a652f26c14610711578063ada8f9191461072457600080fd5b806391cafe321161018157806391cafe32146106a95780639e001877146106bc5780639f26f840146106d757600080fd5b80637a5460c5146106525780637cd76b8b1461068e5780638c3d7301146106a157600080fd5b806342308fab1161026b578063542028d5116102145780636e05d2cd116101ee5780636e05d2cd146106235780636ff512cc1461062c578063712570221461063f57600080fd5b8063542028d5146105f3578063676870d2146105fb5780636b8616ce1461060357600080fd5b80634c21fef3116102455780634c21fef31461056f5780634e487706146105a457806352bdeb6d146105b757600080fd5b806342308fab14610507578063456052671461050f57806349b7b8021461054857600080fd5b80632acdc2b6116102cd5780633c351e10116102a75780633c351e10146104525780633cbc795b1461047257806340b5de6c146104af57600080fd5b80632acdc2b61461040a5780632c111c061461041f57806332c2d1531461043f57600080fd5b8063107bf28c116102fe578063107bf28c146103a357806311e892d4146103ab57806326782247146103c557600080fd5b8062d0295d14610324578063035089631461033f57806305835f371461035a575b600080fd5b61032c61089a565b6040519081526020015b60405180910390f35b610347602081565b60405161ffff9091168152602001610336565b6103966040518060400160405280600881526020017f80808401c9c3809400000000000000000000000000000000000000000000000081525081565b60405161033691906140d6565b6103966109a6565b6103b360f981565b60405160ff9091168152602001610336565b6001546103e59073ffffffffffffffffffffffffffffffffffffffff1681565b60405173ffffffffffffffffffffffffffffffffffffffff9091168152602001610336565b61041d610418366004614101565b610a34565b005b6008546103e59073ffffffffffffffffffffffffffffffffffffffff1681565b61041d61044d366004614171565b610b54565b6009546103e59073ffffffffffffffffffffffffffffffffffffffff1681565b60095461049a9074010000000000000000000000000000000000000000900463ffffffff1681565b60405163ffffffff9091168152602001610336565b6104d67fff0000000000000000000000000000000000000000000000000000000000000081565b6040517fff000000000000000000000000000000000000000000000000000000000000009091168152602001610336565b61032c602481565b60075461052f9068010000000000000000900467ffffffffffffffff1681565b60405167ffffffffffffffff9091168152602001610336565b6103e57f000000000000000000000000000000000000000000000000000000000000000081565b603c546105949074010000000000000000000000000000000000000000900460ff1681565b6040519015158152602001610336565b61041d6105b23660046141b3565b610c23565b6103966040518060400160405280600281526020017f80b800000000000000000000000000000000000000000000000000000000000081525081565b610396610e35565b610347601f81565b61032c6106113660046141b3565b60066020526000908152604090205481565b61032c60055481565b61041d61063a3660046141d0565b610e42565b61041d61064d366004614342565b610f0c565b6103966040518060400160405280600281526020017f80b900000000000000000000000000000000000000000000000000000000000081525081565b61041d61069c3660046141d0565b611730565b61041d6117fa565b61041d6106b73660046141d0565b6118cd565b6103e573a40d5f56745a118d0906a34e69aec8c0db1cb8fa81565b61041d6106e536600461443b565b6119e6565b6103e57f000000000000000000000000000000000000000000000000000000000000000081565b61039661071f36600461447d565b61207f565b61041d6107323660046141d0565b612464565b61032c6405ca1ab1e081565b60075461052f90700100000000000000000000000000000000900467ffffffffffffffff1681565b6103b360e481565b61041d6107813660046144f2565b61252e565b6002546103e59073ffffffffffffffffffffffffffffffffffffffff1681565b6103e57f000000000000000000000000000000000000000000000000000000000000000081565b61032c635ca1ab1e81565b61041d6107e6366004614569565b6125c1565b61041d6107f936600461463c565b612f26565b6103e57f000000000000000000000000000000000000000000000000000000000000000081565b603c546103e59073ffffffffffffffffffffffffffffffffffffffff1681565b60075461052f9067ffffffffffffffff1681565b61041d6108673660046146b9565b612f8e565b6103b3601b81565b6000546103e59062010000900473ffffffffffffffffffffffffffffffffffffffff1681565b6040517f70a08231000000000000000000000000000000000000000000000000000000008152306004820152600090819073ffffffffffffffffffffffffffffffffffffffff7f000000000000000000000000000000000000000000000000000000000000000016906370a0823190602401602060405180830381865afa158015610929573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061094d9190614705565b6007549091506000906109789067ffffffffffffffff6801000000000000000082048116911661474d565b67ffffffffffffffff169050806000036109955760009250505090565b61099f8183614775565b9250505090565b600480546109b3906147b0565b80601f01602080910402602001604051908101604052809291908181526020018280546109df906147b0565b8015610a2c5780601f10610a0157610100808354040283529160200191610a2c565b820191906000526020600020905b815481529060010190602001808311610a0f57829003601f168201915b505050505081565b60005462010000900473ffffffffffffffffffffffffffffffffffffffff163314610a8b576040517f4755657900000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b603c5474010000000000000000000000000000000000000000900460ff16151581151503610ae5576040517f5f0e7abe00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b603c80547fffffffffffffffffffffff00ffffffffffffffffffffffffffffffffffffffff1674010000000000000000000000000000000000000000831515021790556040517ff32a0473f809a720a4f8af1e50d353f1caf7452030626fdaac4273f5e6587f4190600090a150565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163314610bc3576040517fb9b3a2c800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8073ffffffffffffffffffffffffffffffffffffffff168367ffffffffffffffff167f9c72852172521097ba7e1482e6b44b351323df0155f97f4ea18fcec28e1f596684604051610c1691815260200190565b60405180910390a3505050565b60005462010000900473ffffffffffffffffffffffffffffffffffffffff163314610c7a576040517f4755657900000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b62093a8067ffffffffffffffff82161115610cc1576040517ff5e37f2f00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff166315064c966040518163ffffffff1660e01b8152600401602060405180830381865afa158015610d2c573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610d509190614803565b610db15760075467ffffffffffffffff700100000000000000000000000000000000909104811690821610610db1576040517ff5e37f2f00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600780547fffffffffffffffff0000000000000000ffffffffffffffffffffffffffffffff1670010000000000000000000000000000000067ffffffffffffffff8416908102919091179091556040519081527fa7eb6cb8a613eb4e8bddc1ac3d61ec6cf10898760f0b187bcca794c6ca6fa40b906020015b60405180910390a150565b600380546109b3906147b0565b60005462010000900473ffffffffffffffffffffffffffffffffffffffff163314610e99576040517f4755657900000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600280547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff83169081179091556040519081527ff54144f9611984021529f814a1cb6a41e22c58351510a0d9f7e822618abb9cc090602001610e2a565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163314610f7b576040517fb9b3a2c800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600054610100900460ff1615808015610f9b5750600054600160ff909116105b80610fb55750303b158015610fb5575060005460ff166001145b611046576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602e60248201527f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160448201527f647920696e697469616c697a656400000000000000000000000000000000000060648201526084015b60405180910390fd5b600080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0016600117905580156110a457600080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff166101001790555b606073ffffffffffffffffffffffffffffffffffffffff851615611309576040517fc00f14ab00000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff86811660048301527f0000000000000000000000000000000000000000000000000000000000000000169063c00f14ab90602401600060405180830381865afa15801561114e573d6000803e3d6000fd5b505050506040513d6000823e601f3d9081017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe01682016040526111949190810190614820565b6040517f318aee3d00000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff878116600483015291925060009182917f00000000000000000000000000000000000000000000000000000000000000009091169063318aee3d906024016040805180830381865afa158015611229573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061124d9190614897565b915091508163ffffffff166000146112c5576009805463ffffffff841674010000000000000000000000000000000000000000027fffffffffffffffff00000000000000000000000000000000000000000000000090911673ffffffffffffffffffffffffffffffffffffffff841617179055611306565b600980547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff89161790555b50505b60095460009061135190889073ffffffffffffffffffffffffffffffffffffffff81169074010000000000000000000000000000000000000000900463ffffffff168561207f565b9050600081805190602001209050600042905060007f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff16633ed691ef6040518163ffffffff1660e01b8152600401602060405180830381865afa1580156113d1573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906113f59190614705565b90506000808483858f6114096001436148d1565b60408051602081019790975286019490945260608086019390935260c09190911b7fffffffffffffffff000000000000000000000000000000000000000000000000166080850152901b7fffffffffffffffffffffffffffffffffffffffff00000000000000000000000016608883015240609c82015260bc01604080518083037fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe001815290829052805160209091012060058190557f9a908e73000000000000000000000000000000000000000000000000000000008252600160048301526024820181905291507f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1690639a908e73906044016020604051808303816000875af1158015611552573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061157691906148ea565b508c600060026101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508b600260006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508860039081611608919061494d565b506004611615898261494d565b508c600860006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555062069780600760106101000a81548167ffffffffffffffff021916908367ffffffffffffffff1602179055507f060116213bcbf54ca19fd649dc84b59ab2bbd200ab199770e4d923e222a28e7f85838e6040516116b693929190614a67565b60405180910390a1505050505050801561172757600080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff169055604051600181527f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb38474024989060200160405180910390a15b50505050505050565b60005462010000900473ffffffffffffffffffffffffffffffffffffffff163314611787576040517f4755657900000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b603c80547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff83169081179091556040519081527fd331bd4c4cd1afecb94a225184bded161ff3213624ba4fb58c4f30c5a861144a90602001610e2a565b60015473ffffffffffffffffffffffffffffffffffffffff16331461184b576040517fd1ec4b2300000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600154600080547fffffffffffffffffffff0000000000000000000000000000000000000000ffff1673ffffffffffffffffffffffffffffffffffffffff9092166201000081029290921790556040519081527f056dc487bbf0795d0bbb1b4f0af523a855503cff740bfb4d5475f7a90c091e8e9060200160405180910390a1565b60005462010000900473ffffffffffffffffffffffffffffffffffffffff163314611924576040517f4755657900000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60085473ffffffffffffffffffffffffffffffffffffffff16611973576040517fc89374d800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600880547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff83169081179091556040519081527f5fbd7dd171301c4a1611a84aac4ba86d119478560557755f7927595b082634fb90602001610e2a565b60085473ffffffffffffffffffffffffffffffffffffffff168015801590611a24575073ffffffffffffffffffffffffffffffffffffffff81163314155b15611a5b576040517f24eff8c300000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b4262093a807f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff166330c27dde6040518163ffffffff1660e01b8152600401602060405180830381865afa158015611acb573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611aef91906148ea565b611af99190614aa6565b67ffffffffffffffff161115611b3b576040517f3d49ed4c00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b816000819003611b77576040517fcb591a5f00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6103e8811115611bb3576040517fb59f753a00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60075467ffffffffffffffff80821691611bdb91849168010000000000000000900416614ac7565b1115611c13576040517fc630a00d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6007546005546801000000000000000090910467ffffffffffffffff169060005b83811015611eb3576000878783818110611c5057611c50614ada565b9050602002810190611c629190614b09565b611c6b90614b47565b905083611c7781614bb5565b825180516020918201208185015160408087015160608801519151959a50929550600094611ce4948794929101938452602084019290925260c01b7fffffffffffffffff000000000000000000000000000000000000000000000000166040830152604882015260680190565b604080517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0818403018152918152815160209283012067ffffffffffffffff8916600090815260069093529120549091508114611d6d576040517fce3d755e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b67ffffffffffffffff8616600090815260066020526040812055611d926001886148d1565b8403611e015742600760109054906101000a900467ffffffffffffffff168460400151611dbf9190614aa6565b67ffffffffffffffff161115611e01576040517fc44a082100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60208381015160408086015160608088015183519586018b90529285018790528481019390935260c01b7fffffffffffffffff0000000000000000000000000000000000000000000000001660808401523390911b7fffffffffffffffffffffffffffffffffffffffff000000000000000000000000166088830152609c82015260bc016040516020818303038152906040528051906020012094505050508080611eab90614bdc565b915050611c34565b50611f297f000000000000000000000000000000000000000000000000000000000000000084611ee161089a565b611eeb9190614c14565b73ffffffffffffffffffffffffffffffffffffffff7f0000000000000000000000000000000000000000000000000000000000000000169190613460565b60058190556007805467ffffffffffffffff841668010000000000000000027fffffffffffffffffffffffffffffffff0000000000000000ffffffffffffffff9091161790556040517f9a908e7300000000000000000000000000000000000000000000000000000000815260009073ffffffffffffffffffffffffffffffffffffffff7f00000000000000000000000000000000000000000000000000000000000000001690639a908e7390611ffb908790869060040167ffffffffffffffff929092168252602082015260400190565b6020604051808303816000875af115801561201a573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061203e91906148ea565b60405190915067ffffffffffffffff8216907f648a61dd2438f072f5a1960939abd30f37aea80d2e94c9792ad142d3e0a490a490600090a250505050505050565b6060600085858573a40d5f56745a118d0906a34e69aec8c0db1cb8fa6000876040516024016120b396959493929190614c2b565b604080517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe08184030181529190526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167ff811bff70000000000000000000000000000000000000000000000000000000017905283519091506060906000036122045760f9601f83516121489190614c8e565b6040518060400160405280600881526020017f80808401c9c380940000000000000000000000000000000000000000000000008152507f00000000000000000000000000000000000000000000000000000000000000006040518060400160405280600281526020017f80b800000000000000000000000000000000000000000000000000000000000081525060e4876040516020016121ee9796959493929190614ca9565b6040516020818303038152906040529050612308565b815161ffff1015612241576040517f248b8f8200000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b815160f9612250602083614c8e565b6040518060400160405280600881526020017f80808401c9c380940000000000000000000000000000000000000000000000008152507f00000000000000000000000000000000000000000000000000000000000000006040518060400160405280600281526020017f80b900000000000000000000000000000000000000000000000000000000000081525085886040516020016122f59796959493929190614d8c565b6040516020818303038152906040529150505b805160208083019190912060408051600080825293810180835292909252601b908201526405ca1ab1e06060820152635ca1ab1e608082015260019060a0016020604051602081039080840390855afa158015612369573d6000803e3d6000fd5b50506040517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0015191505073ffffffffffffffffffffffffffffffffffffffff81166123e1576040517fcd16196600000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6040516000906124279084906405ca1ab1e090635ca1ab1e90601b907fff0000000000000000000000000000000000000000000000000000000000000090602001614e6f565b604080517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe08184030181529190529450505050505b949350505050565b60005462010000900473ffffffffffffffffffffffffffffffffffffffff1633146124bb576040517f4755657900000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600180547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff83169081179091556040519081527fa5b56b7906fd0a20e3f35120dd8343db1e12e037a6c90111c7e42885e82a1ce690602001610e2a565b60005462010000900473ffffffffffffffffffffffffffffffffffffffff163314612585576040517f4755657900000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6003612591828261494d565b507f6b8f723a4c7a5335cafae8a598a0aa0301be1387c037dccc085b62add6448b2081604051610e2a91906140d6565b60025473ffffffffffffffffffffffffffffffffffffffff163314612612576040517f11e7be1500000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b85600081900361264e576040517fcb591a5f00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6103e881111561268a576040517fb59f753a00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b612695602442614ac7565b8667ffffffffffffffff1611156126d8576040517f0a00feb300000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff166379e2cf976040518163ffffffff1660e01b8152600401600060405180830381600087803b15801561274057600080fd5b505af1158015612754573d6000803e3d6000fd5b5050505060007f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff16635ca1e1656040518163ffffffff1660e01b8152600401602060405180830381865afa1580156127c5573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906127e99190614705565b60075460055491925068010000000000000000900467ffffffffffffffff1690816000805b86811015612b255760008e8e8381811061282a5761282a614ada565b9050608002018036038101906128409190614ecb565b604081015190915067ffffffffffffffff1615612a34578561286181614bb5565b965050600081600001518260200151836040015184606001516040516020016128c89493929190938452602084019290925260c01b7fffffffffffffffff000000000000000000000000000000000000000000000000166040830152604882015260680190565b604080517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0818403018152918152815160209283012067ffffffffffffffff8a16600090815260069093529120549091508114612951576040517fce3d755e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b858260000151836020015184604001518f86606001516040516020016129eb969594939291909586526020860194909452604085019290925260c01b7fffffffffffffffff000000000000000000000000000000000000000000000000166060808501919091521b7fffffffffffffffffffffffffffffffffffffffff000000000000000000000000166068830152607c820152609c0190565b604051602081830303815290604052805190602001209550600660008867ffffffffffffffff1667ffffffffffffffff1681526020019081526020016000206000905550612b12565b8051604051612a50918591602001918252602082015260400190565b604051602081830303815290604052805190602001209250848160000151888f8e6000801b604051602001612af9969594939291909586526020860194909452604085019290925260c01b7fffffffffffffffff000000000000000000000000000000000000000000000000166060808501919091521b7fffffffffffffffffffffffffffffffffffffffff000000000000000000000000166068830152607c820152609c0190565b6040516020818303038152906040528051906020012094505b5080612b1d81614bdc565b91505061280e565b5060075467ffffffffffffffff9081169085161115612b70576040517fc630a00d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60058390558567ffffffffffffffff85811690841614612c26576000612b96848761474d565b9050612bac67ffffffffffffffff8216836148d1565b9150612be57f00000000000000000000000000000000000000000000000000000000000000008267ffffffffffffffff16611ee161089a565b50600780547fffffffffffffffffffffffffffffffff0000000000000000ffffffffffffffff166801000000000000000067ffffffffffffffff8816021790555b8015612db557612d2a337f0000000000000000000000000000000000000000000000000000000000000000837f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1663477fa2706040518163ffffffff1660e01b8152600401602060405180830381865afa158015612cbd573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190612ce19190614705565b612ceb9190614c14565b73ffffffffffffffffffffffffffffffffffffffff7f000000000000000000000000000000000000000000000000000000000000000016929190613539565b603c546040517f3b51be4b00000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff90911690633b51be4b90612d849085908d908d90600401614f62565b60006040518083038186803b158015612d9c57600080fd5b505afa158015612db0573d6000803e3d6000fd5b505050505b6040517f9a908e7300000000000000000000000000000000000000000000000000000000815267ffffffffffffffff88166004820152602481018590526000907f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1690639a908e73906044016020604051808303816000875af1158015612e55573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190612e7991906148ea565b9050612e85888261474d565b67ffffffffffffffff168c67ffffffffffffffff1614612ed1576040517f1a070d9a00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8067ffffffffffffffff167f3e54d0825ed78523037d00a81759237eb436ce774bd546993ee67a1b67b6e76688604051612f0d91815260200190565b60405180910390a2505050505050505050505050505050565b603c5474010000000000000000000000000000000000000000900460ff16612f7a576040517f821935b400000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b612f87858585858561359d565b5050505050565b60085473ffffffffffffffffffffffffffffffffffffffff168015801590612fcc575073ffffffffffffffffffffffffffffffffffffffff81163314155b15613003576040517f24eff8c300000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff166315064c966040518163ffffffff1660e01b8152600401602060405180830381865afa15801561306e573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906130929190614803565b156130c9576040517f39258d1800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60007f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1663604691696040518163ffffffff1660e01b8152600401602060405180830381865afa158015613136573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061315a9190614705565b905082811115613196576040517f2354600f00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6113888411156131d2576040517fa29a6c7c00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b61321473ffffffffffffffffffffffffffffffffffffffff7f000000000000000000000000000000000000000000000000000000000000000016333084613539565b60007f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff16633ed691ef6040518163ffffffff1660e01b8152600401602060405180830381865afa158015613281573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906132a59190614705565b6007805491925067ffffffffffffffff9091169060006132c483614bb5565b91906101000a81548167ffffffffffffffff021916908367ffffffffffffffff1602179055505085856040516132fb929190614f7c565b60405190819003902081426133116001436148d1565b60408051602081019590955284019290925260c01b7fffffffffffffffff000000000000000000000000000000000000000000000000166060830152406068820152608801604080517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0818403018152918152815160209283012060075467ffffffffffffffff166000908152600690935291205532330361340957600754604080518381523360208201526060818301819052600090820152905167ffffffffffffffff909216917ff94bb37db835f1ab585ee00041849a09b12cd081d77fa15ca070757619cbc9319181900360800190a2613458565b60075460405167ffffffffffffffff909116907ff94bb37db835f1ab585ee00041849a09b12cd081d77fa15ca070757619cbc9319061344f90849033908b908b90614f8c565b60405180910390a25b505050505050565b60405173ffffffffffffffffffffffffffffffffffffffff83166024820152604481018290526135349084907fa9059cbb00000000000000000000000000000000000000000000000000000000906064015b604080517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe08184030181529190526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fffffffff0000000000000000000000000000000000000000000000000000000090931692909217909152613deb565b505050565b60405173ffffffffffffffffffffffffffffffffffffffff808516602483015283166044820152606481018290526135979085907f23b872dd00000000000000000000000000000000000000000000000000000000906084016134b2565b50505050565b60025473ffffffffffffffffffffffffffffffffffffffff1633146135ee576040517f11e7be1500000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b83600081900361362a576040517fcb591a5f00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6103e8811115613666576040517fb59f753a00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b613671602442614ac7565b8467ffffffffffffffff1611156136b4576040517f0a00feb300000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff166379e2cf976040518163ffffffff1660e01b8152600401600060405180830381600087803b15801561371c57600080fd5b505af1158015613730573d6000803e3d6000fd5b5050505060007f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff16635ca1e1656040518163ffffffff1660e01b8152600401602060405180830381865afa1580156137a1573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906137c59190614705565b60075460055491925068010000000000000000900467ffffffffffffffff16908160005b85811015613aeb5760008b8b8381811061380557613805614ada565b90506020028101906138179190614b09565b61382090614b47565b8051805160209091012060408201519192509067ffffffffffffffff1615613a05578561384c81614bb5565b9650506000818360200151846040015185606001516040516020016138af9493929190938452602084019290925260c01b7fffffffffffffffff000000000000000000000000000000000000000000000000166040830152604882015260680190565b604080517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0818403018152918152815160209283012067ffffffffffffffff8a16600090815260069093529120549091508114613938576040517fce3d755e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60208381015160408086015160608088015183519586018c90529285018790528481019390935260c01b7fffffffffffffffff000000000000000000000000000000000000000000000000166080840152908c901b7fffffffffffffffffffffffffffffffffffffffff000000000000000000000000166088830152609c82015260bc01604051602081830303815290604052805190602001209550600660008867ffffffffffffffff1667ffffffffffffffff1681526020019081526020016000206000905550613ad6565b8151516201d4c01015613a44576040517fa29a6c7c00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6040805160208101879052908101829052606080820189905260c08d901b7fffffffffffffffff0000000000000000000000000000000000000000000000001660808301528a901b7fffffffffffffffffffffffffffffffffffffffff0000000000000000000000001660888201526000609c82015260bc016040516020818303038152906040528051906020012094505b50508080613ae390614bdc565b9150506137e9565b5060075467ffffffffffffffff9081169084161115613b36576040517fc630a00d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60058290558467ffffffffffffffff84811690831614613bec576000613b5c838661474d565b9050613b7267ffffffffffffffff8216836148d1565b9150613bab7f00000000000000000000000000000000000000000000000000000000000000008267ffffffffffffffff16611ee161089a565b50600780547fffffffffffffffffffffffffffffffff0000000000000000ffffffffffffffff166801000000000000000067ffffffffffffffff8716021790555b613c7d337f0000000000000000000000000000000000000000000000000000000000000000837f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1663477fa2706040518163ffffffff1660e01b8152600401602060405180830381865afa158015612cbd573d6000803e3d6000fd5b6040517f9a908e7300000000000000000000000000000000000000000000000000000000815267ffffffffffffffff87166004820152602481018490526000907f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff1690639a908e73906044016020604051808303816000875af1158015613d1d573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190613d4191906148ea565b9050613d4d878261474d565b67ffffffffffffffff168967ffffffffffffffff1614613d99576040517f1a070d9a00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8067ffffffffffffffff167f3e54d0825ed78523037d00a81759237eb436ce774bd546993ee67a1b67b6e76687604051613dd591815260200190565b60405180910390a2505050505050505050505050565b6000613e4d826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff16613ef79092919063ffffffff16565b8051909150156135345780806020019051810190613e6b9190614803565b613534576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e60448201527f6f74207375636365656400000000000000000000000000000000000000000000606482015260840161103d565b606061245c8484600085856000808673ffffffffffffffffffffffffffffffffffffffff168587604051613f2b9190614fcc565b60006040518083038185875af1925050503d8060008114613f68576040519150601f19603f3d011682016040523d82523d6000602084013e613f6d565b606091505b5091509150613f7e87838387613f89565b979650505050505050565b6060831561401f5782516000036140185773ffffffffffffffffffffffffffffffffffffffff85163b614018576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000604482015260640161103d565b508161245c565b61245c83838151156140345781518083602001fd5b806040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161103d91906140d6565b60005b8381101561408357818101518382015260200161406b565b50506000910152565b600081518084526140a4816020860160208601614068565b601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0169290920160200192915050565b6020815260006140e9602083018461408c565b9392505050565b80151581146140fe57600080fd5b50565b60006020828403121561411357600080fd5b81356140e9816140f0565b67ffffffffffffffff811681146140fe57600080fd5b803561413f8161411e565b919050565b73ffffffffffffffffffffffffffffffffffffffff811681146140fe57600080fd5b803561413f81614144565b60008060006060848603121561418657600080fd5b83356141918161411e565b92506020840135915060408401356141a881614144565b809150509250925092565b6000602082840312156141c557600080fd5b81356140e98161411e565b6000602082840312156141e257600080fd5b81356140e981614144565b63ffffffff811681146140fe57600080fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b6040516080810167ffffffffffffffff81118282101715614251576142516141ff565b60405290565b604051601f82017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe016810167ffffffffffffffff8111828210171561429e5761429e6141ff565b604052919050565b600067ffffffffffffffff8211156142c0576142c06141ff565b50601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe01660200190565b600082601f8301126142fd57600080fd5b813561431061430b826142a6565b614257565b81815284602083860101111561432557600080fd5b816020850160208301376000918101602001919091529392505050565b60008060008060008060c0878903121561435b57600080fd5b863561436681614144565b9550602087013561437681614144565b94506040870135614386816141ed565b9350606087013561439681614144565b9250608087013567ffffffffffffffff808211156143b357600080fd5b6143bf8a838b016142ec565b935060a08901359150808211156143d557600080fd5b506143e289828a016142ec565b9150509295509295509295565b60008083601f84011261440157600080fd5b50813567ffffffffffffffff81111561441957600080fd5b6020830191508360208260051b850101111561443457600080fd5b9250929050565b6000806020838503121561444e57600080fd5b823567ffffffffffffffff81111561446557600080fd5b614471858286016143ef565b90969095509350505050565b6000806000806080858703121561449357600080fd5b843561449e816141ed565b935060208501356144ae81614144565b925060408501356144be816141ed565b9150606085013567ffffffffffffffff8111156144da57600080fd5b6144e6878288016142ec565b91505092959194509250565b60006020828403121561450457600080fd5b813567ffffffffffffffff81111561451b57600080fd5b61245c848285016142ec565b60008083601f84011261453957600080fd5b50813567ffffffffffffffff81111561455157600080fd5b60208301915083602082850101111561443457600080fd5b600080600080600080600060a0888a03121561458457600080fd5b873567ffffffffffffffff8082111561459c57600080fd5b818a0191508a601f8301126145b057600080fd5b8135818111156145bf57600080fd5b8b60208260071b85010111156145d457600080fd5b602083019950809850506145ea60208b01614134565b96506145f860408b01614134565b955061460660608b01614166565b945060808a013591508082111561461c57600080fd5b506146298a828b01614527565b989b979a50959850939692959293505050565b60008060008060006080868803121561465457600080fd5b853567ffffffffffffffff81111561466b57600080fd5b614677888289016143ef565b909650945050602086013561468b8161411e565b9250604086013561469b8161411e565b915060608601356146ab81614144565b809150509295509295909350565b6000806000604084860312156146ce57600080fd5b833567ffffffffffffffff8111156146e557600080fd5b6146f186828701614527565b909790965060209590950135949350505050565b60006020828403121561471757600080fd5b5051919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b67ffffffffffffffff82811682821603908082111561476e5761476e61471e565b5092915050565b6000826147ab577f4e487b7100000000000000000000000000000000000000000000000000000000600052601260045260246000fd5b500490565b600181811c908216806147c457607f821691505b6020821081036147fd577f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b50919050565b60006020828403121561481557600080fd5b81516140e9816140f0565b60006020828403121561483257600080fd5b815167ffffffffffffffff81111561484957600080fd5b8201601f8101841361485a57600080fd5b805161486861430b826142a6565b81815285602083850101111561487d57600080fd5b61488e826020830160208601614068565b95945050505050565b600080604083850312156148aa57600080fd5b82516148b5816141ed565b60208401519092506148c681614144565b809150509250929050565b818103818111156148e4576148e461471e565b92915050565b6000602082840312156148fc57600080fd5b81516140e98161411e565b601f82111561353457600081815260208120601f850160051c8101602086101561492e5750805b601f850160051c820191505b818110156134585782815560010161493a565b815167ffffffffffffffff811115614967576149676141ff565b61497b8161497584546147b0565b84614907565b602080601f8311600181146149ce57600084156149985750858301515b7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600386901b1c1916600185901b178555613458565b6000858152602081207fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe08616915b82811015614a1b578886015182559484019460019091019084016149fc565b5085821015614a5757878501517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff600388901b60f8161c191681555b5050505050600190811b01905550565b606081526000614a7a606083018661408c565b905083602083015273ffffffffffffffffffffffffffffffffffffffff83166040830152949350505050565b67ffffffffffffffff81811683821601908082111561476e5761476e61471e565b808201808211156148e4576148e461471e565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b600082357fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff81833603018112614b3d57600080fd5b9190910192915050565b600060808236031215614b5957600080fd5b614b6161422e565b823567ffffffffffffffff811115614b7857600080fd5b614b84368286016142ec565b825250602083013560208201526040830135614b9f8161411e565b6040820152606092830135928101929092525090565b600067ffffffffffffffff808316818103614bd257614bd261471e565b6001019392505050565b60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8203614c0d57614c0d61471e565b5060010190565b80820281158282048414176148e4576148e461471e565b600063ffffffff808916835273ffffffffffffffffffffffffffffffffffffffff8089166020850152818816604085015280871660608501528086166080850152505060c060a0830152614c8260c083018461408c565b98975050505050505050565b61ffff81811683821601908082111561476e5761476e61471e565b60007fff00000000000000000000000000000000000000000000000000000000000000808a60f81b1683527fffff0000000000000000000000000000000000000000000000000000000000008960f01b1660018401528751614d12816003860160208c01614068565b80840190507fffffffffffffffffffffffffffffffffffffffff0000000000000000000000008860601b1660038201528651614d55816017840160208b01614068565b808201915050818660f81b16601782015284519150614d7b826018830160208801614068565b016018019998505050505050505050565b7fff000000000000000000000000000000000000000000000000000000000000008860f81b16815260007fffff000000000000000000000000000000000000000000000000000000000000808960f01b1660018401528751614df5816003860160208c01614068565b80840190507fffffffffffffffffffffffffffffffffffffffff0000000000000000000000008860601b1660038201528651614e38816017840160208b01614068565b808201915050818660f01b16601782015284519150614e5e826019830160208801614068565b016019019998505050505050505050565b60008651614e81818460208b01614068565b9190910194855250602084019290925260f81b7fff000000000000000000000000000000000000000000000000000000000000009081166040840152166041820152604201919050565b600060808284031215614edd57600080fd5b614ee561422e565b82358152602083013560208201526040830135614f018161411e565b60408201526060928301359281019290925250919050565b8183528181602085013750600060208284010152600060207fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0601f840116840101905092915050565b83815260406020820152600061488e604083018486614f19565b8183823760009101908152919050565b84815273ffffffffffffffffffffffffffffffffffffffff84166020820152606060408201526000614fc2606083018486614f19565b9695505050505050565b60008251614b3d81846020870161406856fea264697066735822122012c6e0437be7f44797e64b6e94b288e36d741e2455c4f5eb852f0e1f6ab0cc5164736f6c63430008140033 diff --git a/etherman/smartcontracts/bin/polygonzkevmbridge.bin b/etherman/smartcontracts/bin/polygonzkevmbridge.bin new file mode 100644 index 00000000..b533d5e5 --- /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 00000000..2e0ca791 --- /dev/null +++ b/etherman/smartcontracts/bin/polygonzkevmglobalexitroot.bin @@ -0,0 +1 @@ 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 \ No newline at end of file diff --git a/etherman/smartcontracts/bin/proxy.bin b/etherman/smartcontracts/bin/proxy.bin new file mode 100644 index 00000000..e6de7ebb --- /dev/null +++ b/etherman/smartcontracts/bin/proxy.bin @@ -0,0 +1 @@ +608060405260405162000fa938038062000fa9833981016040819052620000269162000424565b828162000036828260006200004d565b50620000449050826200007f565b50505062000557565b6200005883620000f1565b600082511180620000665750805b156200007a5762000078838362000133565b505b505050565b7f7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f620000c160008051602062000f62833981519152546001600160a01b031690565b604080516001600160a01b03928316815291841660208301520160405180910390a1620000ee8162000162565b50565b620000fc8162000200565b6040516001600160a01b038216907fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b90600090a250565b60606200015b838360405180606001604052806027815260200162000f826027913962000297565b9392505050565b6001600160a01b038116620001cd5760405162461bcd60e51b815260206004820152602660248201527f455243313936373a206e65772061646d696e20697320746865207a65726f206160448201526564647265737360d01b60648201526084015b60405180910390fd5b8060008051602062000f628339815191525b80546001600160a01b0319166001600160a01b039290921691909117905550565b6001600160a01b0381163b6200026f5760405162461bcd60e51b815260206004820152602d60248201527f455243313936373a206e657720696d706c656d656e746174696f6e206973206e60448201526c1bdd08184818dbdb9d1c9858dd609a1b6064820152608401620001c4565b807f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc620001df565b6060600080856001600160a01b031685604051620002b6919062000504565b600060405180830381855af49150503d8060008114620002f3576040519150601f19603f3d011682016040523d82523d6000602084013e620002f8565b606091505b5090925090506200030c8683838762000316565b9695505050505050565b606083156200038a57825160000362000382576001600160a01b0385163b620003825760405162461bcd60e51b815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e74726163740000006044820152606401620001c4565b508162000396565b6200039683836200039e565b949350505050565b815115620003af5781518083602001fd5b8060405162461bcd60e51b8152600401620001c4919062000522565b80516001600160a01b0381168114620003e357600080fd5b919050565b634e487b7160e01b600052604160045260246000fd5b60005b838110156200041b57818101518382015260200162000401565b50506000910152565b6000806000606084860312156200043a57600080fd5b6200044584620003cb565b92506200045560208501620003cb565b60408501519092506001600160401b03808211156200047357600080fd5b818601915086601f8301126200048857600080fd5b8151818111156200049d576200049d620003e8565b604051601f8201601f19908116603f01168101908382118183101715620004c857620004c8620003e8565b81604052828152896020848701011115620004e257600080fd5b620004f5836020830160208801620003fe565b80955050505050509250925092565b6000825162000518818460208701620003fe565b9190910192915050565b602081526000825180602084015262000543816040850160208701620003fe565b601f01601f19169190910160400192915050565b6109fb80620005676000396000f3fe60806040526004361061005e5760003560e01c80635c60da1b116100435780635c60da1b146100a85780638f283970146100e6578063f851a440146101065761006d565b80633659cfe6146100755780634f1ef286146100955761006d565b3661006d5761006b61011b565b005b61006b61011b565b34801561008157600080fd5b5061006b61009036600461086f565b610135565b61006b6100a336600461088a565b61017f565b3480156100b457600080fd5b506100bd6101f3565b60405173ffffffffffffffffffffffffffffffffffffffff909116815260200160405180910390f35b3480156100f257600080fd5b5061006b61010136600461086f565b610231565b34801561011257600080fd5b506100bd61025e565b61012361028c565b61013361012e610363565b61036d565b565b61013d610391565b73ffffffffffffffffffffffffffffffffffffffff16330361017757610174816040518060200160405280600081525060006103d1565b50565b61017461011b565b610187610391565b73ffffffffffffffffffffffffffffffffffffffff1633036101eb576101e68383838080601f016020809104026020016040519081016040528093929190818152602001838380828437600092019190915250600192506103d1915050565b505050565b6101e661011b565b60006101fd610391565b73ffffffffffffffffffffffffffffffffffffffff16330361022657610221610363565b905090565b61022e61011b565b90565b610239610391565b73ffffffffffffffffffffffffffffffffffffffff16330361017757610174816103fc565b6000610268610391565b73ffffffffffffffffffffffffffffffffffffffff16330361022657610221610391565b610294610391565b73ffffffffffffffffffffffffffffffffffffffff163303610133576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152604260248201527f5472616e73706172656e745570677261646561626c6550726f78793a2061646d60448201527f696e2063616e6e6f742066616c6c6261636b20746f2070726f7879207461726760648201527f6574000000000000000000000000000000000000000000000000000000000000608482015260a4015b60405180910390fd5b600061022161045d565b3660008037600080366000845af43d6000803e80801561038c573d6000f35b3d6000fd5b60007fb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d61035b5473ffffffffffffffffffffffffffffffffffffffff16919050565b6103da83610485565b6000825111806103e75750805b156101e6576103f683836104d2565b50505050565b7f7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f610425610391565b6040805173ffffffffffffffffffffffffffffffffffffffff928316815291841660208301520160405180910390a1610174816104fe565b60007f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc6103b5565b61048e8161060a565b60405173ffffffffffffffffffffffffffffffffffffffff8216907fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b90600090a250565b60606104f7838360405180606001604052806027815260200161099f602791396106d5565b9392505050565b73ffffffffffffffffffffffffffffffffffffffff81166105a1576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602660248201527f455243313936373a206e65772061646d696e20697320746865207a65726f206160448201527f6464726573730000000000000000000000000000000000000000000000000000606482015260840161035a565b807fb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d61035b80547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff9290921691909117905550565b73ffffffffffffffffffffffffffffffffffffffff81163b6106ae576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602d60248201527f455243313936373a206e657720696d706c656d656e746174696f6e206973206e60448201527f6f74206120636f6e747261637400000000000000000000000000000000000000606482015260840161035a565b807f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc6105c4565b60606000808573ffffffffffffffffffffffffffffffffffffffff16856040516106ff9190610931565b600060405180830381855af49150503d806000811461073a576040519150601f19603f3d011682016040523d82523d6000602084013e61073f565b606091505b50915091506107508683838761075a565b9695505050505050565b606083156107f05782516000036107e95773ffffffffffffffffffffffffffffffffffffffff85163b6107e9576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000604482015260640161035a565b50816107fa565b6107fa8383610802565b949350505050565b8151156108125781518083602001fd5b806040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161035a919061094d565b803573ffffffffffffffffffffffffffffffffffffffff8116811461086a57600080fd5b919050565b60006020828403121561088157600080fd5b6104f782610846565b60008060006040848603121561089f57600080fd5b6108a884610846565b9250602084013567ffffffffffffffff808211156108c557600080fd5b818601915086601f8301126108d957600080fd5b8135818111156108e857600080fd5b8760208285010111156108fa57600080fd5b6020830194508093505050509250925092565b60005b83811015610928578181015183820152602001610910565b50506000910152565b6000825161094381846020870161090d565b9190910192915050565b602081526000825180602084015261096c81604085016020870161090d565b601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe016919091016040019291505056fe416464726573733a206c6f772d6c6576656c2064656c65676174652063616c6c206661696c6564a2646970667358221220701a0c26bdd76686e63fc3c65e4f28a20ba3ecc8a60246733c0627e679c9804e64736f6c63430008140033b53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103416464726573733a206c6f772d6c6576656c2064656c65676174652063616c6c206661696c6564 \ No newline at end of file diff --git a/etherman/smartcontracts/dataavailabilityprotocol/dataavailabilityprotocol.go b/etherman/smartcontracts/dataavailabilityprotocol/dataavailabilityprotocol.go new file mode 100644 index 00000000..b4e83ac8 --- /dev/null +++ b/etherman/smartcontracts/dataavailabilityprotocol/dataavailabilityprotocol.go @@ -0,0 +1,241 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package dataavailabilityprotocol + +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 +) + +// DataavailabilityprotocolMetaData contains all meta data concerning the Dataavailabilityprotocol contract. +var DataavailabilityprotocolMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[],\"name\":\"getProcotolName\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"hash\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"dataAvailabilityMessage\",\"type\":\"bytes\"}],\"name\":\"verifyMessage\",\"outputs\":[],\"stateMutability\":\"view\",\"type\":\"function\"}]", +} + +// DataavailabilityprotocolABI is the input ABI used to generate the binding from. +// Deprecated: Use DataavailabilityprotocolMetaData.ABI instead. +var DataavailabilityprotocolABI = DataavailabilityprotocolMetaData.ABI + +// Dataavailabilityprotocol is an auto generated Go binding around an Ethereum contract. +type Dataavailabilityprotocol struct { + DataavailabilityprotocolCaller // Read-only binding to the contract + DataavailabilityprotocolTransactor // Write-only binding to the contract + DataavailabilityprotocolFilterer // Log filterer for contract events +} + +// DataavailabilityprotocolCaller is an auto generated read-only Go binding around an Ethereum contract. +type DataavailabilityprotocolCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// DataavailabilityprotocolTransactor is an auto generated write-only Go binding around an Ethereum contract. +type DataavailabilityprotocolTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// DataavailabilityprotocolFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type DataavailabilityprotocolFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// DataavailabilityprotocolSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type DataavailabilityprotocolSession struct { + Contract *Dataavailabilityprotocol // 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 +} + +// DataavailabilityprotocolCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type DataavailabilityprotocolCallerSession struct { + Contract *DataavailabilityprotocolCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// DataavailabilityprotocolTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type DataavailabilityprotocolTransactorSession struct { + Contract *DataavailabilityprotocolTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// DataavailabilityprotocolRaw is an auto generated low-level Go binding around an Ethereum contract. +type DataavailabilityprotocolRaw struct { + Contract *Dataavailabilityprotocol // Generic contract binding to access the raw methods on +} + +// DataavailabilityprotocolCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type DataavailabilityprotocolCallerRaw struct { + Contract *DataavailabilityprotocolCaller // Generic read-only contract binding to access the raw methods on +} + +// DataavailabilityprotocolTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type DataavailabilityprotocolTransactorRaw struct { + Contract *DataavailabilityprotocolTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewDataavailabilityprotocol creates a new instance of Dataavailabilityprotocol, bound to a specific deployed contract. +func NewDataavailabilityprotocol(address common.Address, backend bind.ContractBackend) (*Dataavailabilityprotocol, error) { + contract, err := bindDataavailabilityprotocol(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &Dataavailabilityprotocol{DataavailabilityprotocolCaller: DataavailabilityprotocolCaller{contract: contract}, DataavailabilityprotocolTransactor: DataavailabilityprotocolTransactor{contract: contract}, DataavailabilityprotocolFilterer: DataavailabilityprotocolFilterer{contract: contract}}, nil +} + +// NewDataavailabilityprotocolCaller creates a new read-only instance of Dataavailabilityprotocol, bound to a specific deployed contract. +func NewDataavailabilityprotocolCaller(address common.Address, caller bind.ContractCaller) (*DataavailabilityprotocolCaller, error) { + contract, err := bindDataavailabilityprotocol(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &DataavailabilityprotocolCaller{contract: contract}, nil +} + +// NewDataavailabilityprotocolTransactor creates a new write-only instance of Dataavailabilityprotocol, bound to a specific deployed contract. +func NewDataavailabilityprotocolTransactor(address common.Address, transactor bind.ContractTransactor) (*DataavailabilityprotocolTransactor, error) { + contract, err := bindDataavailabilityprotocol(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &DataavailabilityprotocolTransactor{contract: contract}, nil +} + +// NewDataavailabilityprotocolFilterer creates a new log filterer instance of Dataavailabilityprotocol, bound to a specific deployed contract. +func NewDataavailabilityprotocolFilterer(address common.Address, filterer bind.ContractFilterer) (*DataavailabilityprotocolFilterer, error) { + contract, err := bindDataavailabilityprotocol(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &DataavailabilityprotocolFilterer{contract: contract}, nil +} + +// bindDataavailabilityprotocol binds a generic wrapper to an already deployed contract. +func bindDataavailabilityprotocol(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := DataavailabilityprotocolMetaData.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 (_Dataavailabilityprotocol *DataavailabilityprotocolRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Dataavailabilityprotocol.Contract.DataavailabilityprotocolCaller.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 (_Dataavailabilityprotocol *DataavailabilityprotocolRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Dataavailabilityprotocol.Contract.DataavailabilityprotocolTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Dataavailabilityprotocol *DataavailabilityprotocolRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Dataavailabilityprotocol.Contract.DataavailabilityprotocolTransactor.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 (_Dataavailabilityprotocol *DataavailabilityprotocolCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Dataavailabilityprotocol.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 (_Dataavailabilityprotocol *DataavailabilityprotocolTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Dataavailabilityprotocol.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Dataavailabilityprotocol *DataavailabilityprotocolTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Dataavailabilityprotocol.Contract.contract.Transact(opts, method, params...) +} + +// GetProcotolName is a free data retrieval call binding the contract method 0xe4f17120. +// +// Solidity: function getProcotolName() pure returns(string) +func (_Dataavailabilityprotocol *DataavailabilityprotocolCaller) GetProcotolName(opts *bind.CallOpts) (string, error) { + var out []interface{} + err := _Dataavailabilityprotocol.contract.Call(opts, &out, "getProcotolName") + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// GetProcotolName is a free data retrieval call binding the contract method 0xe4f17120. +// +// Solidity: function getProcotolName() pure returns(string) +func (_Dataavailabilityprotocol *DataavailabilityprotocolSession) GetProcotolName() (string, error) { + return _Dataavailabilityprotocol.Contract.GetProcotolName(&_Dataavailabilityprotocol.CallOpts) +} + +// GetProcotolName is a free data retrieval call binding the contract method 0xe4f17120. +// +// Solidity: function getProcotolName() pure returns(string) +func (_Dataavailabilityprotocol *DataavailabilityprotocolCallerSession) GetProcotolName() (string, error) { + return _Dataavailabilityprotocol.Contract.GetProcotolName(&_Dataavailabilityprotocol.CallOpts) +} + +// VerifyMessage is a free data retrieval call binding the contract method 0x3b51be4b. +// +// Solidity: function verifyMessage(bytes32 hash, bytes dataAvailabilityMessage) view returns() +func (_Dataavailabilityprotocol *DataavailabilityprotocolCaller) VerifyMessage(opts *bind.CallOpts, hash [32]byte, dataAvailabilityMessage []byte) error { + var out []interface{} + err := _Dataavailabilityprotocol.contract.Call(opts, &out, "verifyMessage", hash, dataAvailabilityMessage) + + if err != nil { + return err + } + + return err + +} + +// VerifyMessage is a free data retrieval call binding the contract method 0x3b51be4b. +// +// Solidity: function verifyMessage(bytes32 hash, bytes dataAvailabilityMessage) view returns() +func (_Dataavailabilityprotocol *DataavailabilityprotocolSession) VerifyMessage(hash [32]byte, dataAvailabilityMessage []byte) error { + return _Dataavailabilityprotocol.Contract.VerifyMessage(&_Dataavailabilityprotocol.CallOpts, hash, dataAvailabilityMessage) +} + +// VerifyMessage is a free data retrieval call binding the contract method 0x3b51be4b. +// +// Solidity: function verifyMessage(bytes32 hash, bytes dataAvailabilityMessage) view returns() +func (_Dataavailabilityprotocol *DataavailabilityprotocolCallerSession) VerifyMessage(hash [32]byte, dataAvailabilityMessage []byte) error { + return _Dataavailabilityprotocol.Contract.VerifyMessage(&_Dataavailabilityprotocol.CallOpts, hash, dataAvailabilityMessage) +} diff --git a/etherman/smartcontracts/etrogpolygonzkevm/etrogpolygonzkevm.go b/etherman/smartcontracts/etrogpolygonzkevm/etrogpolygonzkevm.go new file mode 100644 index 00000000..a3a6ed98 --- /dev/null +++ b/etherman/smartcontracts/etrogpolygonzkevm/etrogpolygonzkevm.go @@ -0,0 +1,3258 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package etrogpolygonzkevm + +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 +} + +// EtrogpolygonzkevmMetaData contains all meta data concerning the Etrogpolygonzkevm contract. +var EtrogpolygonzkevmMetaData = &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\":\"ForceBatchesDecentralized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ForceBatchesNotAllowedOnEmergencyState\",\"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\":\"HaltTimeoutNotExpiredAfterEmergencyState\",\"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\":[{\"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\":\"address\",\"name\":\"newForceBatchAddress\",\"type\":\"address\"}],\"name\":\"SetForceBatchAddress\",\"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\":false,\"internalType\":\"uint64\",\"name\":\"numBatch\",\"type\":\"uint64\"},{\"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\":\"UpdateEtrogSequence\",\"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\":\"SET_UP_ETROG_TX\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"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\":\"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\":\"forceBatchAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"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\":\"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\":[{\"internalType\":\"address\",\"name\":\"_admin\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_trustedSequencer\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"_trustedSequencerURL\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"_networkName\",\"type\":\"string\"},{\"internalType\":\"bytes32\",\"name\":\"_lastAccInputHash\",\"type\":\"bytes32\"}],\"name\":\"initializeUpgrade\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"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\":\"address\",\"name\":\"newForceBatchAddress\",\"type\":\"address\"}],\"name\":\"setForceBatchAddress\",\"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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", +} + +// EtrogpolygonzkevmABI is the input ABI used to generate the binding from. +// Deprecated: Use EtrogpolygonzkevmMetaData.ABI instead. +var EtrogpolygonzkevmABI = EtrogpolygonzkevmMetaData.ABI + +// EtrogpolygonzkevmBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use EtrogpolygonzkevmMetaData.Bin instead. +var EtrogpolygonzkevmBin = EtrogpolygonzkevmMetaData.Bin + +// DeployEtrogpolygonzkevm deploys a new Ethereum contract, binding an instance of Etrogpolygonzkevm to it. +func DeployEtrogpolygonzkevm(auth *bind.TransactOpts, backend bind.ContractBackend, _globalExitRootManager common.Address, _pol common.Address, _bridgeAddress common.Address, _rollupManager common.Address) (common.Address, *types.Transaction, *Etrogpolygonzkevm, error) { + parsed, err := EtrogpolygonzkevmMetaData.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(EtrogpolygonzkevmBin), backend, _globalExitRootManager, _pol, _bridgeAddress, _rollupManager) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &Etrogpolygonzkevm{EtrogpolygonzkevmCaller: EtrogpolygonzkevmCaller{contract: contract}, EtrogpolygonzkevmTransactor: EtrogpolygonzkevmTransactor{contract: contract}, EtrogpolygonzkevmFilterer: EtrogpolygonzkevmFilterer{contract: contract}}, nil +} + +// Etrogpolygonzkevm is an auto generated Go binding around an Ethereum contract. +type Etrogpolygonzkevm struct { + EtrogpolygonzkevmCaller // Read-only binding to the contract + EtrogpolygonzkevmTransactor // Write-only binding to the contract + EtrogpolygonzkevmFilterer // Log filterer for contract events +} + +// EtrogpolygonzkevmCaller is an auto generated read-only Go binding around an Ethereum contract. +type EtrogpolygonzkevmCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// EtrogpolygonzkevmTransactor is an auto generated write-only Go binding around an Ethereum contract. +type EtrogpolygonzkevmTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// EtrogpolygonzkevmFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type EtrogpolygonzkevmFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// EtrogpolygonzkevmSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type EtrogpolygonzkevmSession struct { + Contract *Etrogpolygonzkevm // 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 +} + +// EtrogpolygonzkevmCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type EtrogpolygonzkevmCallerSession struct { + Contract *EtrogpolygonzkevmCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// EtrogpolygonzkevmTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type EtrogpolygonzkevmTransactorSession struct { + Contract *EtrogpolygonzkevmTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// EtrogpolygonzkevmRaw is an auto generated low-level Go binding around an Ethereum contract. +type EtrogpolygonzkevmRaw struct { + Contract *Etrogpolygonzkevm // Generic contract binding to access the raw methods on +} + +// EtrogpolygonzkevmCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type EtrogpolygonzkevmCallerRaw struct { + Contract *EtrogpolygonzkevmCaller // Generic read-only contract binding to access the raw methods on +} + +// EtrogpolygonzkevmTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type EtrogpolygonzkevmTransactorRaw struct { + Contract *EtrogpolygonzkevmTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewEtrogpolygonzkevm creates a new instance of Etrogpolygonzkevm, bound to a specific deployed contract. +func NewEtrogpolygonzkevm(address common.Address, backend bind.ContractBackend) (*Etrogpolygonzkevm, error) { + contract, err := bindEtrogpolygonzkevm(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &Etrogpolygonzkevm{EtrogpolygonzkevmCaller: EtrogpolygonzkevmCaller{contract: contract}, EtrogpolygonzkevmTransactor: EtrogpolygonzkevmTransactor{contract: contract}, EtrogpolygonzkevmFilterer: EtrogpolygonzkevmFilterer{contract: contract}}, nil +} + +// NewEtrogpolygonzkevmCaller creates a new read-only instance of Etrogpolygonzkevm, bound to a specific deployed contract. +func NewEtrogpolygonzkevmCaller(address common.Address, caller bind.ContractCaller) (*EtrogpolygonzkevmCaller, error) { + contract, err := bindEtrogpolygonzkevm(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &EtrogpolygonzkevmCaller{contract: contract}, nil +} + +// NewEtrogpolygonzkevmTransactor creates a new write-only instance of Etrogpolygonzkevm, bound to a specific deployed contract. +func NewEtrogpolygonzkevmTransactor(address common.Address, transactor bind.ContractTransactor) (*EtrogpolygonzkevmTransactor, error) { + contract, err := bindEtrogpolygonzkevm(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &EtrogpolygonzkevmTransactor{contract: contract}, nil +} + +// NewEtrogpolygonzkevmFilterer creates a new log filterer instance of Etrogpolygonzkevm, bound to a specific deployed contract. +func NewEtrogpolygonzkevmFilterer(address common.Address, filterer bind.ContractFilterer) (*EtrogpolygonzkevmFilterer, error) { + contract, err := bindEtrogpolygonzkevm(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &EtrogpolygonzkevmFilterer{contract: contract}, nil +} + +// bindEtrogpolygonzkevm binds a generic wrapper to an already deployed contract. +func bindEtrogpolygonzkevm(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := EtrogpolygonzkevmMetaData.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Etrogpolygonzkevm.Contract.EtrogpolygonzkevmCaller.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Etrogpolygonzkevm.Contract.EtrogpolygonzkevmTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Etrogpolygonzkevm *EtrogpolygonzkevmRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Etrogpolygonzkevm.Contract.EtrogpolygonzkevmTransactor.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Etrogpolygonzkevm.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Etrogpolygonzkevm *EtrogpolygonzkevmTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmCaller) GLOBALEXITROOTMANAGERL2(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmSession) GLOBALEXITROOTMANAGERL2() (common.Address, error) { + return _Etrogpolygonzkevm.Contract.GLOBALEXITROOTMANAGERL2(&_Etrogpolygonzkevm.CallOpts) +} + +// GLOBALEXITROOTMANAGERL2 is a free data retrieval call binding the contract method 0x9e001877. +// +// Solidity: function GLOBAL_EXIT_ROOT_MANAGER_L2() view returns(address) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmCallerSession) GLOBALEXITROOTMANAGERL2() (common.Address, error) { + return _Etrogpolygonzkevm.Contract.GLOBALEXITROOTMANAGERL2(&_Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmCaller) INITIALIZETXBRIDGELISTLENLEN(opts *bind.CallOpts) (uint8, error) { + var out []interface{} + err := _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmSession) INITIALIZETXBRIDGELISTLENLEN() (uint8, error) { + return _Etrogpolygonzkevm.Contract.INITIALIZETXBRIDGELISTLENLEN(&_Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmCallerSession) INITIALIZETXBRIDGELISTLENLEN() (uint8, error) { + return _Etrogpolygonzkevm.Contract.INITIALIZETXBRIDGELISTLENLEN(&_Etrogpolygonzkevm.CallOpts) +} + +// INITIALIZETXBRIDGEPARAMS is a free data retrieval call binding the contract method 0x05835f37. +// +// Solidity: function INITIALIZE_TX_BRIDGE_PARAMS() view returns(bytes) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmCaller) INITIALIZETXBRIDGEPARAMS(opts *bind.CallOpts) ([]byte, error) { + var out []interface{} + err := _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmSession) INITIALIZETXBRIDGEPARAMS() ([]byte, error) { + return _Etrogpolygonzkevm.Contract.INITIALIZETXBRIDGEPARAMS(&_Etrogpolygonzkevm.CallOpts) +} + +// INITIALIZETXBRIDGEPARAMS is a free data retrieval call binding the contract method 0x05835f37. +// +// Solidity: function INITIALIZE_TX_BRIDGE_PARAMS() view returns(bytes) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmCallerSession) INITIALIZETXBRIDGEPARAMS() ([]byte, error) { + return _Etrogpolygonzkevm.Contract.INITIALIZETXBRIDGEPARAMS(&_Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmCaller) INITIALIZETXBRIDGEPARAMSAFTERBRIDGEADDRESS(opts *bind.CallOpts) ([]byte, error) { + var out []interface{} + err := _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmSession) INITIALIZETXBRIDGEPARAMSAFTERBRIDGEADDRESS() ([]byte, error) { + return _Etrogpolygonzkevm.Contract.INITIALIZETXBRIDGEPARAMSAFTERBRIDGEADDRESS(&_Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmCallerSession) INITIALIZETXBRIDGEPARAMSAFTERBRIDGEADDRESS() ([]byte, error) { + return _Etrogpolygonzkevm.Contract.INITIALIZETXBRIDGEPARAMSAFTERBRIDGEADDRESS(&_Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmCaller) INITIALIZETXBRIDGEPARAMSAFTERBRIDGEADDRESSEMPTYMETADATA(opts *bind.CallOpts) ([]byte, error) { + var out []interface{} + err := _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmSession) INITIALIZETXBRIDGEPARAMSAFTERBRIDGEADDRESSEMPTYMETADATA() ([]byte, error) { + return _Etrogpolygonzkevm.Contract.INITIALIZETXBRIDGEPARAMSAFTERBRIDGEADDRESSEMPTYMETADATA(&_Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmCallerSession) INITIALIZETXBRIDGEPARAMSAFTERBRIDGEADDRESSEMPTYMETADATA() ([]byte, error) { + return _Etrogpolygonzkevm.Contract.INITIALIZETXBRIDGEPARAMSAFTERBRIDGEADDRESSEMPTYMETADATA(&_Etrogpolygonzkevm.CallOpts) +} + +// INITIALIZETXCONSTANTBYTES is a free data retrieval call binding the contract method 0x03508963. +// +// Solidity: function INITIALIZE_TX_CONSTANT_BYTES() view returns(uint16) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmCaller) INITIALIZETXCONSTANTBYTES(opts *bind.CallOpts) (uint16, error) { + var out []interface{} + err := _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmSession) INITIALIZETXCONSTANTBYTES() (uint16, error) { + return _Etrogpolygonzkevm.Contract.INITIALIZETXCONSTANTBYTES(&_Etrogpolygonzkevm.CallOpts) +} + +// INITIALIZETXCONSTANTBYTES is a free data retrieval call binding the contract method 0x03508963. +// +// Solidity: function INITIALIZE_TX_CONSTANT_BYTES() view returns(uint16) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmCallerSession) INITIALIZETXCONSTANTBYTES() (uint16, error) { + return _Etrogpolygonzkevm.Contract.INITIALIZETXCONSTANTBYTES(&_Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmCaller) INITIALIZETXCONSTANTBYTESEMPTYMETADATA(opts *bind.CallOpts) (uint16, error) { + var out []interface{} + err := _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmSession) INITIALIZETXCONSTANTBYTESEMPTYMETADATA() (uint16, error) { + return _Etrogpolygonzkevm.Contract.INITIALIZETXCONSTANTBYTESEMPTYMETADATA(&_Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmCallerSession) INITIALIZETXCONSTANTBYTESEMPTYMETADATA() (uint16, error) { + return _Etrogpolygonzkevm.Contract.INITIALIZETXCONSTANTBYTESEMPTYMETADATA(&_Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmCaller) INITIALIZETXDATALENEMPTYMETADATA(opts *bind.CallOpts) (uint8, error) { + var out []interface{} + err := _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmSession) INITIALIZETXDATALENEMPTYMETADATA() (uint8, error) { + return _Etrogpolygonzkevm.Contract.INITIALIZETXDATALENEMPTYMETADATA(&_Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmCallerSession) INITIALIZETXDATALENEMPTYMETADATA() (uint8, error) { + return _Etrogpolygonzkevm.Contract.INITIALIZETXDATALENEMPTYMETADATA(&_Etrogpolygonzkevm.CallOpts) +} + +// INITIALIZETXEFFECTIVEPERCENTAGE is a free data retrieval call binding the contract method 0x40b5de6c. +// +// Solidity: function INITIALIZE_TX_EFFECTIVE_PERCENTAGE() view returns(bytes1) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmCaller) INITIALIZETXEFFECTIVEPERCENTAGE(opts *bind.CallOpts) ([1]byte, error) { + var out []interface{} + err := _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmSession) INITIALIZETXEFFECTIVEPERCENTAGE() ([1]byte, error) { + return _Etrogpolygonzkevm.Contract.INITIALIZETXEFFECTIVEPERCENTAGE(&_Etrogpolygonzkevm.CallOpts) +} + +// INITIALIZETXEFFECTIVEPERCENTAGE is a free data retrieval call binding the contract method 0x40b5de6c. +// +// Solidity: function INITIALIZE_TX_EFFECTIVE_PERCENTAGE() view returns(bytes1) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmCallerSession) INITIALIZETXEFFECTIVEPERCENTAGE() ([1]byte, error) { + return _Etrogpolygonzkevm.Contract.INITIALIZETXEFFECTIVEPERCENTAGE(&_Etrogpolygonzkevm.CallOpts) +} + +// SETUPETROGTX is a free data retrieval call binding the contract method 0xaf7f3e02. +// +// Solidity: function SET_UP_ETROG_TX() view returns(bytes) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmCaller) SETUPETROGTX(opts *bind.CallOpts) ([]byte, error) { + var out []interface{} + err := _Etrogpolygonzkevm.contract.Call(opts, &out, "SET_UP_ETROG_TX") + + if err != nil { + return *new([]byte), err + } + + out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte) + + return out0, err + +} + +// SETUPETROGTX is a free data retrieval call binding the contract method 0xaf7f3e02. +// +// Solidity: function SET_UP_ETROG_TX() view returns(bytes) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmSession) SETUPETROGTX() ([]byte, error) { + return _Etrogpolygonzkevm.Contract.SETUPETROGTX(&_Etrogpolygonzkevm.CallOpts) +} + +// SETUPETROGTX is a free data retrieval call binding the contract method 0xaf7f3e02. +// +// Solidity: function SET_UP_ETROG_TX() view returns(bytes) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmCallerSession) SETUPETROGTX() ([]byte, error) { + return _Etrogpolygonzkevm.Contract.SETUPETROGTX(&_Etrogpolygonzkevm.CallOpts) +} + +// SIGNATUREINITIALIZETXR is a free data retrieval call binding the contract method 0xb0afe154. +// +// Solidity: function SIGNATURE_INITIALIZE_TX_R() view returns(bytes32) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmCaller) SIGNATUREINITIALIZETXR(opts *bind.CallOpts) ([32]byte, error) { + var out []interface{} + err := _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmSession) SIGNATUREINITIALIZETXR() ([32]byte, error) { + return _Etrogpolygonzkevm.Contract.SIGNATUREINITIALIZETXR(&_Etrogpolygonzkevm.CallOpts) +} + +// SIGNATUREINITIALIZETXR is a free data retrieval call binding the contract method 0xb0afe154. +// +// Solidity: function SIGNATURE_INITIALIZE_TX_R() view returns(bytes32) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmCallerSession) SIGNATUREINITIALIZETXR() ([32]byte, error) { + return _Etrogpolygonzkevm.Contract.SIGNATUREINITIALIZETXR(&_Etrogpolygonzkevm.CallOpts) +} + +// SIGNATUREINITIALIZETXS is a free data retrieval call binding the contract method 0xd7bc90ff. +// +// Solidity: function SIGNATURE_INITIALIZE_TX_S() view returns(bytes32) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmCaller) SIGNATUREINITIALIZETXS(opts *bind.CallOpts) ([32]byte, error) { + var out []interface{} + err := _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmSession) SIGNATUREINITIALIZETXS() ([32]byte, error) { + return _Etrogpolygonzkevm.Contract.SIGNATUREINITIALIZETXS(&_Etrogpolygonzkevm.CallOpts) +} + +// SIGNATUREINITIALIZETXS is a free data retrieval call binding the contract method 0xd7bc90ff. +// +// Solidity: function SIGNATURE_INITIALIZE_TX_S() view returns(bytes32) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmCallerSession) SIGNATUREINITIALIZETXS() ([32]byte, error) { + return _Etrogpolygonzkevm.Contract.SIGNATUREINITIALIZETXS(&_Etrogpolygonzkevm.CallOpts) +} + +// SIGNATUREINITIALIZETXV is a free data retrieval call binding the contract method 0xf35dda47. +// +// Solidity: function SIGNATURE_INITIALIZE_TX_V() view returns(uint8) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmCaller) SIGNATUREINITIALIZETXV(opts *bind.CallOpts) (uint8, error) { + var out []interface{} + err := _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmSession) SIGNATUREINITIALIZETXV() (uint8, error) { + return _Etrogpolygonzkevm.Contract.SIGNATUREINITIALIZETXV(&_Etrogpolygonzkevm.CallOpts) +} + +// SIGNATUREINITIALIZETXV is a free data retrieval call binding the contract method 0xf35dda47. +// +// Solidity: function SIGNATURE_INITIALIZE_TX_V() view returns(uint8) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmCallerSession) SIGNATUREINITIALIZETXV() (uint8, error) { + return _Etrogpolygonzkevm.Contract.SIGNATUREINITIALIZETXV(&_Etrogpolygonzkevm.CallOpts) +} + +// Admin is a free data retrieval call binding the contract method 0xf851a440. +// +// Solidity: function admin() view returns(address) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmCaller) Admin(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmSession) Admin() (common.Address, error) { + return _Etrogpolygonzkevm.Contract.Admin(&_Etrogpolygonzkevm.CallOpts) +} + +// Admin is a free data retrieval call binding the contract method 0xf851a440. +// +// Solidity: function admin() view returns(address) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmCallerSession) Admin() (common.Address, error) { + return _Etrogpolygonzkevm.Contract.Admin(&_Etrogpolygonzkevm.CallOpts) +} + +// BridgeAddress is a free data retrieval call binding the contract method 0xa3c573eb. +// +// Solidity: function bridgeAddress() view returns(address) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmCaller) BridgeAddress(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmSession) BridgeAddress() (common.Address, error) { + return _Etrogpolygonzkevm.Contract.BridgeAddress(&_Etrogpolygonzkevm.CallOpts) +} + +// BridgeAddress is a free data retrieval call binding the contract method 0xa3c573eb. +// +// Solidity: function bridgeAddress() view returns(address) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmCallerSession) BridgeAddress() (common.Address, error) { + return _Etrogpolygonzkevm.Contract.BridgeAddress(&_Etrogpolygonzkevm.CallOpts) +} + +// CalculatePolPerForceBatch is a free data retrieval call binding the contract method 0x00d0295d. +// +// Solidity: function calculatePolPerForceBatch() view returns(uint256) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmCaller) CalculatePolPerForceBatch(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmSession) CalculatePolPerForceBatch() (*big.Int, error) { + return _Etrogpolygonzkevm.Contract.CalculatePolPerForceBatch(&_Etrogpolygonzkevm.CallOpts) +} + +// CalculatePolPerForceBatch is a free data retrieval call binding the contract method 0x00d0295d. +// +// Solidity: function calculatePolPerForceBatch() view returns(uint256) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmCallerSession) CalculatePolPerForceBatch() (*big.Int, error) { + return _Etrogpolygonzkevm.Contract.CalculatePolPerForceBatch(&_Etrogpolygonzkevm.CallOpts) +} + +// ForceBatchAddress is a free data retrieval call binding the contract method 0x2c111c06. +// +// Solidity: function forceBatchAddress() view returns(address) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmCaller) ForceBatchAddress(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Etrogpolygonzkevm.contract.Call(opts, &out, "forceBatchAddress") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// ForceBatchAddress is a free data retrieval call binding the contract method 0x2c111c06. +// +// Solidity: function forceBatchAddress() view returns(address) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmSession) ForceBatchAddress() (common.Address, error) { + return _Etrogpolygonzkevm.Contract.ForceBatchAddress(&_Etrogpolygonzkevm.CallOpts) +} + +// ForceBatchAddress is a free data retrieval call binding the contract method 0x2c111c06. +// +// Solidity: function forceBatchAddress() view returns(address) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmCallerSession) ForceBatchAddress() (common.Address, error) { + return _Etrogpolygonzkevm.Contract.ForceBatchAddress(&_Etrogpolygonzkevm.CallOpts) +} + +// ForceBatchTimeout is a free data retrieval call binding the contract method 0xc754c7ed. +// +// Solidity: function forceBatchTimeout() view returns(uint64) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmCaller) ForceBatchTimeout(opts *bind.CallOpts) (uint64, error) { + var out []interface{} + err := _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmSession) ForceBatchTimeout() (uint64, error) { + return _Etrogpolygonzkevm.Contract.ForceBatchTimeout(&_Etrogpolygonzkevm.CallOpts) +} + +// ForceBatchTimeout is a free data retrieval call binding the contract method 0xc754c7ed. +// +// Solidity: function forceBatchTimeout() view returns(uint64) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmCallerSession) ForceBatchTimeout() (uint64, error) { + return _Etrogpolygonzkevm.Contract.ForceBatchTimeout(&_Etrogpolygonzkevm.CallOpts) +} + +// ForcedBatches is a free data retrieval call binding the contract method 0x6b8616ce. +// +// Solidity: function forcedBatches(uint64 ) view returns(bytes32) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmCaller) ForcedBatches(opts *bind.CallOpts, arg0 uint64) ([32]byte, error) { + var out []interface{} + err := _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmSession) ForcedBatches(arg0 uint64) ([32]byte, error) { + return _Etrogpolygonzkevm.Contract.ForcedBatches(&_Etrogpolygonzkevm.CallOpts, arg0) +} + +// ForcedBatches is a free data retrieval call binding the contract method 0x6b8616ce. +// +// Solidity: function forcedBatches(uint64 ) view returns(bytes32) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmCallerSession) ForcedBatches(arg0 uint64) ([32]byte, error) { + return _Etrogpolygonzkevm.Contract.ForcedBatches(&_Etrogpolygonzkevm.CallOpts, arg0) +} + +// GasTokenAddress is a free data retrieval call binding the contract method 0x3c351e10. +// +// Solidity: function gasTokenAddress() view returns(address) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmCaller) GasTokenAddress(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmSession) GasTokenAddress() (common.Address, error) { + return _Etrogpolygonzkevm.Contract.GasTokenAddress(&_Etrogpolygonzkevm.CallOpts) +} + +// GasTokenAddress is a free data retrieval call binding the contract method 0x3c351e10. +// +// Solidity: function gasTokenAddress() view returns(address) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmCallerSession) GasTokenAddress() (common.Address, error) { + return _Etrogpolygonzkevm.Contract.GasTokenAddress(&_Etrogpolygonzkevm.CallOpts) +} + +// GasTokenNetwork is a free data retrieval call binding the contract method 0x3cbc795b. +// +// Solidity: function gasTokenNetwork() view returns(uint32) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmCaller) GasTokenNetwork(opts *bind.CallOpts) (uint32, error) { + var out []interface{} + err := _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmSession) GasTokenNetwork() (uint32, error) { + return _Etrogpolygonzkevm.Contract.GasTokenNetwork(&_Etrogpolygonzkevm.CallOpts) +} + +// GasTokenNetwork is a free data retrieval call binding the contract method 0x3cbc795b. +// +// Solidity: function gasTokenNetwork() view returns(uint32) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmCallerSession) GasTokenNetwork() (uint32, error) { + return _Etrogpolygonzkevm.Contract.GasTokenNetwork(&_Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmCaller) GenerateInitializeTransaction(opts *bind.CallOpts, networkID uint32, _gasTokenAddress common.Address, _gasTokenNetwork uint32, _gasTokenMetadata []byte) ([]byte, error) { + var out []interface{} + err := _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmSession) GenerateInitializeTransaction(networkID uint32, _gasTokenAddress common.Address, _gasTokenNetwork uint32, _gasTokenMetadata []byte) ([]byte, error) { + return _Etrogpolygonzkevm.Contract.GenerateInitializeTransaction(&_Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmCallerSession) GenerateInitializeTransaction(networkID uint32, _gasTokenAddress common.Address, _gasTokenNetwork uint32, _gasTokenMetadata []byte) ([]byte, error) { + return _Etrogpolygonzkevm.Contract.GenerateInitializeTransaction(&_Etrogpolygonzkevm.CallOpts, networkID, _gasTokenAddress, _gasTokenNetwork, _gasTokenMetadata) +} + +// GlobalExitRootManager is a free data retrieval call binding the contract method 0xd02103ca. +// +// Solidity: function globalExitRootManager() view returns(address) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmCaller) GlobalExitRootManager(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmSession) GlobalExitRootManager() (common.Address, error) { + return _Etrogpolygonzkevm.Contract.GlobalExitRootManager(&_Etrogpolygonzkevm.CallOpts) +} + +// GlobalExitRootManager is a free data retrieval call binding the contract method 0xd02103ca. +// +// Solidity: function globalExitRootManager() view returns(address) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmCallerSession) GlobalExitRootManager() (common.Address, error) { + return _Etrogpolygonzkevm.Contract.GlobalExitRootManager(&_Etrogpolygonzkevm.CallOpts) +} + +// LastAccInputHash is a free data retrieval call binding the contract method 0x6e05d2cd. +// +// Solidity: function lastAccInputHash() view returns(bytes32) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmCaller) LastAccInputHash(opts *bind.CallOpts) ([32]byte, error) { + var out []interface{} + err := _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmSession) LastAccInputHash() ([32]byte, error) { + return _Etrogpolygonzkevm.Contract.LastAccInputHash(&_Etrogpolygonzkevm.CallOpts) +} + +// LastAccInputHash is a free data retrieval call binding the contract method 0x6e05d2cd. +// +// Solidity: function lastAccInputHash() view returns(bytes32) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmCallerSession) LastAccInputHash() ([32]byte, error) { + return _Etrogpolygonzkevm.Contract.LastAccInputHash(&_Etrogpolygonzkevm.CallOpts) +} + +// LastForceBatch is a free data retrieval call binding the contract method 0xe7a7ed02. +// +// Solidity: function lastForceBatch() view returns(uint64) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmCaller) LastForceBatch(opts *bind.CallOpts) (uint64, error) { + var out []interface{} + err := _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmSession) LastForceBatch() (uint64, error) { + return _Etrogpolygonzkevm.Contract.LastForceBatch(&_Etrogpolygonzkevm.CallOpts) +} + +// LastForceBatch is a free data retrieval call binding the contract method 0xe7a7ed02. +// +// Solidity: function lastForceBatch() view returns(uint64) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmCallerSession) LastForceBatch() (uint64, error) { + return _Etrogpolygonzkevm.Contract.LastForceBatch(&_Etrogpolygonzkevm.CallOpts) +} + +// LastForceBatchSequenced is a free data retrieval call binding the contract method 0x45605267. +// +// Solidity: function lastForceBatchSequenced() view returns(uint64) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmCaller) LastForceBatchSequenced(opts *bind.CallOpts) (uint64, error) { + var out []interface{} + err := _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmSession) LastForceBatchSequenced() (uint64, error) { + return _Etrogpolygonzkevm.Contract.LastForceBatchSequenced(&_Etrogpolygonzkevm.CallOpts) +} + +// LastForceBatchSequenced is a free data retrieval call binding the contract method 0x45605267. +// +// Solidity: function lastForceBatchSequenced() view returns(uint64) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmCallerSession) LastForceBatchSequenced() (uint64, error) { + return _Etrogpolygonzkevm.Contract.LastForceBatchSequenced(&_Etrogpolygonzkevm.CallOpts) +} + +// NetworkName is a free data retrieval call binding the contract method 0x107bf28c. +// +// Solidity: function networkName() view returns(string) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmCaller) NetworkName(opts *bind.CallOpts) (string, error) { + var out []interface{} + err := _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmSession) NetworkName() (string, error) { + return _Etrogpolygonzkevm.Contract.NetworkName(&_Etrogpolygonzkevm.CallOpts) +} + +// NetworkName is a free data retrieval call binding the contract method 0x107bf28c. +// +// Solidity: function networkName() view returns(string) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmCallerSession) NetworkName() (string, error) { + return _Etrogpolygonzkevm.Contract.NetworkName(&_Etrogpolygonzkevm.CallOpts) +} + +// PendingAdmin is a free data retrieval call binding the contract method 0x26782247. +// +// Solidity: function pendingAdmin() view returns(address) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmCaller) PendingAdmin(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmSession) PendingAdmin() (common.Address, error) { + return _Etrogpolygonzkevm.Contract.PendingAdmin(&_Etrogpolygonzkevm.CallOpts) +} + +// PendingAdmin is a free data retrieval call binding the contract method 0x26782247. +// +// Solidity: function pendingAdmin() view returns(address) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmCallerSession) PendingAdmin() (common.Address, error) { + return _Etrogpolygonzkevm.Contract.PendingAdmin(&_Etrogpolygonzkevm.CallOpts) +} + +// Pol is a free data retrieval call binding the contract method 0xe46761c4. +// +// Solidity: function pol() view returns(address) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmCaller) Pol(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmSession) Pol() (common.Address, error) { + return _Etrogpolygonzkevm.Contract.Pol(&_Etrogpolygonzkevm.CallOpts) +} + +// Pol is a free data retrieval call binding the contract method 0xe46761c4. +// +// Solidity: function pol() view returns(address) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmCallerSession) Pol() (common.Address, error) { + return _Etrogpolygonzkevm.Contract.Pol(&_Etrogpolygonzkevm.CallOpts) +} + +// RollupManager is a free data retrieval call binding the contract method 0x49b7b802. +// +// Solidity: function rollupManager() view returns(address) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmCaller) RollupManager(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmSession) RollupManager() (common.Address, error) { + return _Etrogpolygonzkevm.Contract.RollupManager(&_Etrogpolygonzkevm.CallOpts) +} + +// RollupManager is a free data retrieval call binding the contract method 0x49b7b802. +// +// Solidity: function rollupManager() view returns(address) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmCallerSession) RollupManager() (common.Address, error) { + return _Etrogpolygonzkevm.Contract.RollupManager(&_Etrogpolygonzkevm.CallOpts) +} + +// TrustedSequencer is a free data retrieval call binding the contract method 0xcfa8ed47. +// +// Solidity: function trustedSequencer() view returns(address) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmCaller) TrustedSequencer(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmSession) TrustedSequencer() (common.Address, error) { + return _Etrogpolygonzkevm.Contract.TrustedSequencer(&_Etrogpolygonzkevm.CallOpts) +} + +// TrustedSequencer is a free data retrieval call binding the contract method 0xcfa8ed47. +// +// Solidity: function trustedSequencer() view returns(address) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmCallerSession) TrustedSequencer() (common.Address, error) { + return _Etrogpolygonzkevm.Contract.TrustedSequencer(&_Etrogpolygonzkevm.CallOpts) +} + +// TrustedSequencerURL is a free data retrieval call binding the contract method 0x542028d5. +// +// Solidity: function trustedSequencerURL() view returns(string) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmCaller) TrustedSequencerURL(opts *bind.CallOpts) (string, error) { + var out []interface{} + err := _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmSession) TrustedSequencerURL() (string, error) { + return _Etrogpolygonzkevm.Contract.TrustedSequencerURL(&_Etrogpolygonzkevm.CallOpts) +} + +// TrustedSequencerURL is a free data retrieval call binding the contract method 0x542028d5. +// +// Solidity: function trustedSequencerURL() view returns(string) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmCallerSession) TrustedSequencerURL() (string, error) { + return _Etrogpolygonzkevm.Contract.TrustedSequencerURL(&_Etrogpolygonzkevm.CallOpts) +} + +// AcceptAdminRole is a paid mutator transaction binding the contract method 0x8c3d7301. +// +// Solidity: function acceptAdminRole() returns() +func (_Etrogpolygonzkevm *EtrogpolygonzkevmTransactor) AcceptAdminRole(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Etrogpolygonzkevm.contract.Transact(opts, "acceptAdminRole") +} + +// AcceptAdminRole is a paid mutator transaction binding the contract method 0x8c3d7301. +// +// Solidity: function acceptAdminRole() returns() +func (_Etrogpolygonzkevm *EtrogpolygonzkevmSession) AcceptAdminRole() (*types.Transaction, error) { + return _Etrogpolygonzkevm.Contract.AcceptAdminRole(&_Etrogpolygonzkevm.TransactOpts) +} + +// AcceptAdminRole is a paid mutator transaction binding the contract method 0x8c3d7301. +// +// Solidity: function acceptAdminRole() returns() +func (_Etrogpolygonzkevm *EtrogpolygonzkevmTransactorSession) AcceptAdminRole() (*types.Transaction, error) { + return _Etrogpolygonzkevm.Contract.AcceptAdminRole(&_Etrogpolygonzkevm.TransactOpts) +} + +// ForceBatch is a paid mutator transaction binding the contract method 0xeaeb077b. +// +// Solidity: function forceBatch(bytes transactions, uint256 polAmount) returns() +func (_Etrogpolygonzkevm *EtrogpolygonzkevmTransactor) ForceBatch(opts *bind.TransactOpts, transactions []byte, polAmount *big.Int) (*types.Transaction, error) { + return _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmSession) ForceBatch(transactions []byte, polAmount *big.Int) (*types.Transaction, error) { + return _Etrogpolygonzkevm.Contract.ForceBatch(&_Etrogpolygonzkevm.TransactOpts, transactions, polAmount) +} + +// ForceBatch is a paid mutator transaction binding the contract method 0xeaeb077b. +// +// Solidity: function forceBatch(bytes transactions, uint256 polAmount) returns() +func (_Etrogpolygonzkevm *EtrogpolygonzkevmTransactorSession) ForceBatch(transactions []byte, polAmount *big.Int) (*types.Transaction, error) { + return _Etrogpolygonzkevm.Contract.ForceBatch(&_Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmTransactor) Initialize(opts *bind.TransactOpts, _admin common.Address, sequencer common.Address, networkID uint32, _gasTokenAddress common.Address, sequencerURL string, _networkName string) (*types.Transaction, error) { + return _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmSession) Initialize(_admin common.Address, sequencer common.Address, networkID uint32, _gasTokenAddress common.Address, sequencerURL string, _networkName string) (*types.Transaction, error) { + return _Etrogpolygonzkevm.Contract.Initialize(&_Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmTransactorSession) Initialize(_admin common.Address, sequencer common.Address, networkID uint32, _gasTokenAddress common.Address, sequencerURL string, _networkName string) (*types.Transaction, error) { + return _Etrogpolygonzkevm.Contract.Initialize(&_Etrogpolygonzkevm.TransactOpts, _admin, sequencer, networkID, _gasTokenAddress, sequencerURL, _networkName) +} + +// InitializeUpgrade is a paid mutator transaction binding the contract method 0x5d6717a5. +// +// Solidity: function initializeUpgrade(address _admin, address _trustedSequencer, string _trustedSequencerURL, string _networkName, bytes32 _lastAccInputHash) returns() +func (_Etrogpolygonzkevm *EtrogpolygonzkevmTransactor) InitializeUpgrade(opts *bind.TransactOpts, _admin common.Address, _trustedSequencer common.Address, _trustedSequencerURL string, _networkName string, _lastAccInputHash [32]byte) (*types.Transaction, error) { + return _Etrogpolygonzkevm.contract.Transact(opts, "initializeUpgrade", _admin, _trustedSequencer, _trustedSequencerURL, _networkName, _lastAccInputHash) +} + +// InitializeUpgrade is a paid mutator transaction binding the contract method 0x5d6717a5. +// +// Solidity: function initializeUpgrade(address _admin, address _trustedSequencer, string _trustedSequencerURL, string _networkName, bytes32 _lastAccInputHash) returns() +func (_Etrogpolygonzkevm *EtrogpolygonzkevmSession) InitializeUpgrade(_admin common.Address, _trustedSequencer common.Address, _trustedSequencerURL string, _networkName string, _lastAccInputHash [32]byte) (*types.Transaction, error) { + return _Etrogpolygonzkevm.Contract.InitializeUpgrade(&_Etrogpolygonzkevm.TransactOpts, _admin, _trustedSequencer, _trustedSequencerURL, _networkName, _lastAccInputHash) +} + +// InitializeUpgrade is a paid mutator transaction binding the contract method 0x5d6717a5. +// +// Solidity: function initializeUpgrade(address _admin, address _trustedSequencer, string _trustedSequencerURL, string _networkName, bytes32 _lastAccInputHash) returns() +func (_Etrogpolygonzkevm *EtrogpolygonzkevmTransactorSession) InitializeUpgrade(_admin common.Address, _trustedSequencer common.Address, _trustedSequencerURL string, _networkName string, _lastAccInputHash [32]byte) (*types.Transaction, error) { + return _Etrogpolygonzkevm.Contract.InitializeUpgrade(&_Etrogpolygonzkevm.TransactOpts, _admin, _trustedSequencer, _trustedSequencerURL, _networkName, _lastAccInputHash) +} + +// OnVerifyBatches is a paid mutator transaction binding the contract method 0x32c2d153. +// +// Solidity: function onVerifyBatches(uint64 lastVerifiedBatch, bytes32 newStateRoot, address aggregator) returns() +func (_Etrogpolygonzkevm *EtrogpolygonzkevmTransactor) OnVerifyBatches(opts *bind.TransactOpts, lastVerifiedBatch uint64, newStateRoot [32]byte, aggregator common.Address) (*types.Transaction, error) { + return _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmSession) OnVerifyBatches(lastVerifiedBatch uint64, newStateRoot [32]byte, aggregator common.Address) (*types.Transaction, error) { + return _Etrogpolygonzkevm.Contract.OnVerifyBatches(&_Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmTransactorSession) OnVerifyBatches(lastVerifiedBatch uint64, newStateRoot [32]byte, aggregator common.Address) (*types.Transaction, error) { + return _Etrogpolygonzkevm.Contract.OnVerifyBatches(&_Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmTransactor) SequenceBatches(opts *bind.TransactOpts, batches []PolygonRollupBaseEtrogBatchData, l2Coinbase common.Address) (*types.Transaction, error) { + return _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmSession) SequenceBatches(batches []PolygonRollupBaseEtrogBatchData, l2Coinbase common.Address) (*types.Transaction, error) { + return _Etrogpolygonzkevm.Contract.SequenceBatches(&_Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmTransactorSession) SequenceBatches(batches []PolygonRollupBaseEtrogBatchData, l2Coinbase common.Address) (*types.Transaction, error) { + return _Etrogpolygonzkevm.Contract.SequenceBatches(&_Etrogpolygonzkevm.TransactOpts, batches, l2Coinbase) +} + +// SequenceForceBatches is a paid mutator transaction binding the contract method 0x9f26f840. +// +// Solidity: function sequenceForceBatches((bytes,bytes32,uint64,bytes32)[] batches) returns() +func (_Etrogpolygonzkevm *EtrogpolygonzkevmTransactor) SequenceForceBatches(opts *bind.TransactOpts, batches []PolygonRollupBaseEtrogBatchData) (*types.Transaction, error) { + return _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmSession) SequenceForceBatches(batches []PolygonRollupBaseEtrogBatchData) (*types.Transaction, error) { + return _Etrogpolygonzkevm.Contract.SequenceForceBatches(&_Etrogpolygonzkevm.TransactOpts, batches) +} + +// SequenceForceBatches is a paid mutator transaction binding the contract method 0x9f26f840. +// +// Solidity: function sequenceForceBatches((bytes,bytes32,uint64,bytes32)[] batches) returns() +func (_Etrogpolygonzkevm *EtrogpolygonzkevmTransactorSession) SequenceForceBatches(batches []PolygonRollupBaseEtrogBatchData) (*types.Transaction, error) { + return _Etrogpolygonzkevm.Contract.SequenceForceBatches(&_Etrogpolygonzkevm.TransactOpts, batches) +} + +// SetForceBatchAddress is a paid mutator transaction binding the contract method 0x91cafe32. +// +// Solidity: function setForceBatchAddress(address newForceBatchAddress) returns() +func (_Etrogpolygonzkevm *EtrogpolygonzkevmTransactor) SetForceBatchAddress(opts *bind.TransactOpts, newForceBatchAddress common.Address) (*types.Transaction, error) { + return _Etrogpolygonzkevm.contract.Transact(opts, "setForceBatchAddress", newForceBatchAddress) +} + +// SetForceBatchAddress is a paid mutator transaction binding the contract method 0x91cafe32. +// +// Solidity: function setForceBatchAddress(address newForceBatchAddress) returns() +func (_Etrogpolygonzkevm *EtrogpolygonzkevmSession) SetForceBatchAddress(newForceBatchAddress common.Address) (*types.Transaction, error) { + return _Etrogpolygonzkevm.Contract.SetForceBatchAddress(&_Etrogpolygonzkevm.TransactOpts, newForceBatchAddress) +} + +// SetForceBatchAddress is a paid mutator transaction binding the contract method 0x91cafe32. +// +// Solidity: function setForceBatchAddress(address newForceBatchAddress) returns() +func (_Etrogpolygonzkevm *EtrogpolygonzkevmTransactorSession) SetForceBatchAddress(newForceBatchAddress common.Address) (*types.Transaction, error) { + return _Etrogpolygonzkevm.Contract.SetForceBatchAddress(&_Etrogpolygonzkevm.TransactOpts, newForceBatchAddress) +} + +// SetForceBatchTimeout is a paid mutator transaction binding the contract method 0x4e487706. +// +// Solidity: function setForceBatchTimeout(uint64 newforceBatchTimeout) returns() +func (_Etrogpolygonzkevm *EtrogpolygonzkevmTransactor) SetForceBatchTimeout(opts *bind.TransactOpts, newforceBatchTimeout uint64) (*types.Transaction, error) { + return _Etrogpolygonzkevm.contract.Transact(opts, "setForceBatchTimeout", newforceBatchTimeout) +} + +// SetForceBatchTimeout is a paid mutator transaction binding the contract method 0x4e487706. +// +// Solidity: function setForceBatchTimeout(uint64 newforceBatchTimeout) returns() +func (_Etrogpolygonzkevm *EtrogpolygonzkevmSession) SetForceBatchTimeout(newforceBatchTimeout uint64) (*types.Transaction, error) { + return _Etrogpolygonzkevm.Contract.SetForceBatchTimeout(&_Etrogpolygonzkevm.TransactOpts, newforceBatchTimeout) +} + +// SetForceBatchTimeout is a paid mutator transaction binding the contract method 0x4e487706. +// +// Solidity: function setForceBatchTimeout(uint64 newforceBatchTimeout) returns() +func (_Etrogpolygonzkevm *EtrogpolygonzkevmTransactorSession) SetForceBatchTimeout(newforceBatchTimeout uint64) (*types.Transaction, error) { + return _Etrogpolygonzkevm.Contract.SetForceBatchTimeout(&_Etrogpolygonzkevm.TransactOpts, newforceBatchTimeout) +} + +// SetTrustedSequencer is a paid mutator transaction binding the contract method 0x6ff512cc. +// +// Solidity: function setTrustedSequencer(address newTrustedSequencer) returns() +func (_Etrogpolygonzkevm *EtrogpolygonzkevmTransactor) SetTrustedSequencer(opts *bind.TransactOpts, newTrustedSequencer common.Address) (*types.Transaction, error) { + return _Etrogpolygonzkevm.contract.Transact(opts, "setTrustedSequencer", newTrustedSequencer) +} + +// SetTrustedSequencer is a paid mutator transaction binding the contract method 0x6ff512cc. +// +// Solidity: function setTrustedSequencer(address newTrustedSequencer) returns() +func (_Etrogpolygonzkevm *EtrogpolygonzkevmSession) SetTrustedSequencer(newTrustedSequencer common.Address) (*types.Transaction, error) { + return _Etrogpolygonzkevm.Contract.SetTrustedSequencer(&_Etrogpolygonzkevm.TransactOpts, newTrustedSequencer) +} + +// SetTrustedSequencer is a paid mutator transaction binding the contract method 0x6ff512cc. +// +// Solidity: function setTrustedSequencer(address newTrustedSequencer) returns() +func (_Etrogpolygonzkevm *EtrogpolygonzkevmTransactorSession) SetTrustedSequencer(newTrustedSequencer common.Address) (*types.Transaction, error) { + return _Etrogpolygonzkevm.Contract.SetTrustedSequencer(&_Etrogpolygonzkevm.TransactOpts, newTrustedSequencer) +} + +// SetTrustedSequencerURL is a paid mutator transaction binding the contract method 0xc89e42df. +// +// Solidity: function setTrustedSequencerURL(string newTrustedSequencerURL) returns() +func (_Etrogpolygonzkevm *EtrogpolygonzkevmTransactor) SetTrustedSequencerURL(opts *bind.TransactOpts, newTrustedSequencerURL string) (*types.Transaction, error) { + return _Etrogpolygonzkevm.contract.Transact(opts, "setTrustedSequencerURL", newTrustedSequencerURL) +} + +// SetTrustedSequencerURL is a paid mutator transaction binding the contract method 0xc89e42df. +// +// Solidity: function setTrustedSequencerURL(string newTrustedSequencerURL) returns() +func (_Etrogpolygonzkevm *EtrogpolygonzkevmSession) SetTrustedSequencerURL(newTrustedSequencerURL string) (*types.Transaction, error) { + return _Etrogpolygonzkevm.Contract.SetTrustedSequencerURL(&_Etrogpolygonzkevm.TransactOpts, newTrustedSequencerURL) +} + +// SetTrustedSequencerURL is a paid mutator transaction binding the contract method 0xc89e42df. +// +// Solidity: function setTrustedSequencerURL(string newTrustedSequencerURL) returns() +func (_Etrogpolygonzkevm *EtrogpolygonzkevmTransactorSession) SetTrustedSequencerURL(newTrustedSequencerURL string) (*types.Transaction, error) { + return _Etrogpolygonzkevm.Contract.SetTrustedSequencerURL(&_Etrogpolygonzkevm.TransactOpts, newTrustedSequencerURL) +} + +// TransferAdminRole is a paid mutator transaction binding the contract method 0xada8f919. +// +// Solidity: function transferAdminRole(address newPendingAdmin) returns() +func (_Etrogpolygonzkevm *EtrogpolygonzkevmTransactor) TransferAdminRole(opts *bind.TransactOpts, newPendingAdmin common.Address) (*types.Transaction, error) { + return _Etrogpolygonzkevm.contract.Transact(opts, "transferAdminRole", newPendingAdmin) +} + +// TransferAdminRole is a paid mutator transaction binding the contract method 0xada8f919. +// +// Solidity: function transferAdminRole(address newPendingAdmin) returns() +func (_Etrogpolygonzkevm *EtrogpolygonzkevmSession) TransferAdminRole(newPendingAdmin common.Address) (*types.Transaction, error) { + return _Etrogpolygonzkevm.Contract.TransferAdminRole(&_Etrogpolygonzkevm.TransactOpts, newPendingAdmin) +} + +// TransferAdminRole is a paid mutator transaction binding the contract method 0xada8f919. +// +// Solidity: function transferAdminRole(address newPendingAdmin) returns() +func (_Etrogpolygonzkevm *EtrogpolygonzkevmTransactorSession) TransferAdminRole(newPendingAdmin common.Address) (*types.Transaction, error) { + return _Etrogpolygonzkevm.Contract.TransferAdminRole(&_Etrogpolygonzkevm.TransactOpts, newPendingAdmin) +} + +// EtrogpolygonzkevmAcceptAdminRoleIterator is returned from FilterAcceptAdminRole and is used to iterate over the raw logs and unpacked data for AcceptAdminRole events raised by the Etrogpolygonzkevm contract. +type EtrogpolygonzkevmAcceptAdminRoleIterator struct { + Event *EtrogpolygonzkevmAcceptAdminRole // 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 *EtrogpolygonzkevmAcceptAdminRoleIterator) 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(EtrogpolygonzkevmAcceptAdminRole) + 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(EtrogpolygonzkevmAcceptAdminRole) + 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 *EtrogpolygonzkevmAcceptAdminRoleIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *EtrogpolygonzkevmAcceptAdminRoleIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// EtrogpolygonzkevmAcceptAdminRole represents a AcceptAdminRole event raised by the Etrogpolygonzkevm contract. +type EtrogpolygonzkevmAcceptAdminRole 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 (_Etrogpolygonzkevm *EtrogpolygonzkevmFilterer) FilterAcceptAdminRole(opts *bind.FilterOpts) (*EtrogpolygonzkevmAcceptAdminRoleIterator, error) { + + logs, sub, err := _Etrogpolygonzkevm.contract.FilterLogs(opts, "AcceptAdminRole") + if err != nil { + return nil, err + } + return &EtrogpolygonzkevmAcceptAdminRoleIterator{contract: _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmFilterer) WatchAcceptAdminRole(opts *bind.WatchOpts, sink chan<- *EtrogpolygonzkevmAcceptAdminRole) (event.Subscription, error) { + + logs, sub, err := _Etrogpolygonzkevm.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(EtrogpolygonzkevmAcceptAdminRole) + if err := _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmFilterer) ParseAcceptAdminRole(log types.Log) (*EtrogpolygonzkevmAcceptAdminRole, error) { + event := new(EtrogpolygonzkevmAcceptAdminRole) + if err := _Etrogpolygonzkevm.contract.UnpackLog(event, "AcceptAdminRole", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// EtrogpolygonzkevmForceBatchIterator is returned from FilterForceBatch and is used to iterate over the raw logs and unpacked data for ForceBatch events raised by the Etrogpolygonzkevm contract. +type EtrogpolygonzkevmForceBatchIterator struct { + Event *EtrogpolygonzkevmForceBatch // 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 *EtrogpolygonzkevmForceBatchIterator) 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(EtrogpolygonzkevmForceBatch) + 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(EtrogpolygonzkevmForceBatch) + 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 *EtrogpolygonzkevmForceBatchIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *EtrogpolygonzkevmForceBatchIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// EtrogpolygonzkevmForceBatch represents a ForceBatch event raised by the Etrogpolygonzkevm contract. +type EtrogpolygonzkevmForceBatch 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 (_Etrogpolygonzkevm *EtrogpolygonzkevmFilterer) FilterForceBatch(opts *bind.FilterOpts, forceBatchNum []uint64) (*EtrogpolygonzkevmForceBatchIterator, error) { + + var forceBatchNumRule []interface{} + for _, forceBatchNumItem := range forceBatchNum { + forceBatchNumRule = append(forceBatchNumRule, forceBatchNumItem) + } + + logs, sub, err := _Etrogpolygonzkevm.contract.FilterLogs(opts, "ForceBatch", forceBatchNumRule) + if err != nil { + return nil, err + } + return &EtrogpolygonzkevmForceBatchIterator{contract: _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmFilterer) WatchForceBatch(opts *bind.WatchOpts, sink chan<- *EtrogpolygonzkevmForceBatch, forceBatchNum []uint64) (event.Subscription, error) { + + var forceBatchNumRule []interface{} + for _, forceBatchNumItem := range forceBatchNum { + forceBatchNumRule = append(forceBatchNumRule, forceBatchNumItem) + } + + logs, sub, err := _Etrogpolygonzkevm.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(EtrogpolygonzkevmForceBatch) + if err := _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmFilterer) ParseForceBatch(log types.Log) (*EtrogpolygonzkevmForceBatch, error) { + event := new(EtrogpolygonzkevmForceBatch) + if err := _Etrogpolygonzkevm.contract.UnpackLog(event, "ForceBatch", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// EtrogpolygonzkevmInitialSequenceBatchesIterator is returned from FilterInitialSequenceBatches and is used to iterate over the raw logs and unpacked data for InitialSequenceBatches events raised by the Etrogpolygonzkevm contract. +type EtrogpolygonzkevmInitialSequenceBatchesIterator struct { + Event *EtrogpolygonzkevmInitialSequenceBatches // 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 *EtrogpolygonzkevmInitialSequenceBatchesIterator) 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(EtrogpolygonzkevmInitialSequenceBatches) + 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(EtrogpolygonzkevmInitialSequenceBatches) + 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 *EtrogpolygonzkevmInitialSequenceBatchesIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *EtrogpolygonzkevmInitialSequenceBatchesIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// EtrogpolygonzkevmInitialSequenceBatches represents a InitialSequenceBatches event raised by the Etrogpolygonzkevm contract. +type EtrogpolygonzkevmInitialSequenceBatches 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 (_Etrogpolygonzkevm *EtrogpolygonzkevmFilterer) FilterInitialSequenceBatches(opts *bind.FilterOpts) (*EtrogpolygonzkevmInitialSequenceBatchesIterator, error) { + + logs, sub, err := _Etrogpolygonzkevm.contract.FilterLogs(opts, "InitialSequenceBatches") + if err != nil { + return nil, err + } + return &EtrogpolygonzkevmInitialSequenceBatchesIterator{contract: _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmFilterer) WatchInitialSequenceBatches(opts *bind.WatchOpts, sink chan<- *EtrogpolygonzkevmInitialSequenceBatches) (event.Subscription, error) { + + logs, sub, err := _Etrogpolygonzkevm.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(EtrogpolygonzkevmInitialSequenceBatches) + if err := _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmFilterer) ParseInitialSequenceBatches(log types.Log) (*EtrogpolygonzkevmInitialSequenceBatches, error) { + event := new(EtrogpolygonzkevmInitialSequenceBatches) + if err := _Etrogpolygonzkevm.contract.UnpackLog(event, "InitialSequenceBatches", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// EtrogpolygonzkevmInitializedIterator is returned from FilterInitialized and is used to iterate over the raw logs and unpacked data for Initialized events raised by the Etrogpolygonzkevm contract. +type EtrogpolygonzkevmInitializedIterator struct { + Event *EtrogpolygonzkevmInitialized // 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 *EtrogpolygonzkevmInitializedIterator) 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(EtrogpolygonzkevmInitialized) + 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(EtrogpolygonzkevmInitialized) + 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 *EtrogpolygonzkevmInitializedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *EtrogpolygonzkevmInitializedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// EtrogpolygonzkevmInitialized represents a Initialized event raised by the Etrogpolygonzkevm contract. +type EtrogpolygonzkevmInitialized 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 (_Etrogpolygonzkevm *EtrogpolygonzkevmFilterer) FilterInitialized(opts *bind.FilterOpts) (*EtrogpolygonzkevmInitializedIterator, error) { + + logs, sub, err := _Etrogpolygonzkevm.contract.FilterLogs(opts, "Initialized") + if err != nil { + return nil, err + } + return &EtrogpolygonzkevmInitializedIterator{contract: _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *EtrogpolygonzkevmInitialized) (event.Subscription, error) { + + logs, sub, err := _Etrogpolygonzkevm.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(EtrogpolygonzkevmInitialized) + if err := _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmFilterer) ParseInitialized(log types.Log) (*EtrogpolygonzkevmInitialized, error) { + event := new(EtrogpolygonzkevmInitialized) + if err := _Etrogpolygonzkevm.contract.UnpackLog(event, "Initialized", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// EtrogpolygonzkevmSequenceBatchesIterator is returned from FilterSequenceBatches and is used to iterate over the raw logs and unpacked data for SequenceBatches events raised by the Etrogpolygonzkevm contract. +type EtrogpolygonzkevmSequenceBatchesIterator struct { + Event *EtrogpolygonzkevmSequenceBatches // 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 *EtrogpolygonzkevmSequenceBatchesIterator) 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(EtrogpolygonzkevmSequenceBatches) + 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(EtrogpolygonzkevmSequenceBatches) + 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 *EtrogpolygonzkevmSequenceBatchesIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *EtrogpolygonzkevmSequenceBatchesIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// EtrogpolygonzkevmSequenceBatches represents a SequenceBatches event raised by the Etrogpolygonzkevm contract. +type EtrogpolygonzkevmSequenceBatches 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 (_Etrogpolygonzkevm *EtrogpolygonzkevmFilterer) FilterSequenceBatches(opts *bind.FilterOpts, numBatch []uint64) (*EtrogpolygonzkevmSequenceBatchesIterator, error) { + + var numBatchRule []interface{} + for _, numBatchItem := range numBatch { + numBatchRule = append(numBatchRule, numBatchItem) + } + + logs, sub, err := _Etrogpolygonzkevm.contract.FilterLogs(opts, "SequenceBatches", numBatchRule) + if err != nil { + return nil, err + } + return &EtrogpolygonzkevmSequenceBatchesIterator{contract: _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmFilterer) WatchSequenceBatches(opts *bind.WatchOpts, sink chan<- *EtrogpolygonzkevmSequenceBatches, numBatch []uint64) (event.Subscription, error) { + + var numBatchRule []interface{} + for _, numBatchItem := range numBatch { + numBatchRule = append(numBatchRule, numBatchItem) + } + + logs, sub, err := _Etrogpolygonzkevm.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(EtrogpolygonzkevmSequenceBatches) + if err := _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmFilterer) ParseSequenceBatches(log types.Log) (*EtrogpolygonzkevmSequenceBatches, error) { + event := new(EtrogpolygonzkevmSequenceBatches) + if err := _Etrogpolygonzkevm.contract.UnpackLog(event, "SequenceBatches", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// EtrogpolygonzkevmSequenceForceBatchesIterator is returned from FilterSequenceForceBatches and is used to iterate over the raw logs and unpacked data for SequenceForceBatches events raised by the Etrogpolygonzkevm contract. +type EtrogpolygonzkevmSequenceForceBatchesIterator struct { + Event *EtrogpolygonzkevmSequenceForceBatches // 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 *EtrogpolygonzkevmSequenceForceBatchesIterator) 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(EtrogpolygonzkevmSequenceForceBatches) + 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(EtrogpolygonzkevmSequenceForceBatches) + 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 *EtrogpolygonzkevmSequenceForceBatchesIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *EtrogpolygonzkevmSequenceForceBatchesIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// EtrogpolygonzkevmSequenceForceBatches represents a SequenceForceBatches event raised by the Etrogpolygonzkevm contract. +type EtrogpolygonzkevmSequenceForceBatches 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 (_Etrogpolygonzkevm *EtrogpolygonzkevmFilterer) FilterSequenceForceBatches(opts *bind.FilterOpts, numBatch []uint64) (*EtrogpolygonzkevmSequenceForceBatchesIterator, error) { + + var numBatchRule []interface{} + for _, numBatchItem := range numBatch { + numBatchRule = append(numBatchRule, numBatchItem) + } + + logs, sub, err := _Etrogpolygonzkevm.contract.FilterLogs(opts, "SequenceForceBatches", numBatchRule) + if err != nil { + return nil, err + } + return &EtrogpolygonzkevmSequenceForceBatchesIterator{contract: _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmFilterer) WatchSequenceForceBatches(opts *bind.WatchOpts, sink chan<- *EtrogpolygonzkevmSequenceForceBatches, numBatch []uint64) (event.Subscription, error) { + + var numBatchRule []interface{} + for _, numBatchItem := range numBatch { + numBatchRule = append(numBatchRule, numBatchItem) + } + + logs, sub, err := _Etrogpolygonzkevm.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(EtrogpolygonzkevmSequenceForceBatches) + if err := _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmFilterer) ParseSequenceForceBatches(log types.Log) (*EtrogpolygonzkevmSequenceForceBatches, error) { + event := new(EtrogpolygonzkevmSequenceForceBatches) + if err := _Etrogpolygonzkevm.contract.UnpackLog(event, "SequenceForceBatches", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// EtrogpolygonzkevmSetForceBatchAddressIterator is returned from FilterSetForceBatchAddress and is used to iterate over the raw logs and unpacked data for SetForceBatchAddress events raised by the Etrogpolygonzkevm contract. +type EtrogpolygonzkevmSetForceBatchAddressIterator struct { + Event *EtrogpolygonzkevmSetForceBatchAddress // 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 *EtrogpolygonzkevmSetForceBatchAddressIterator) 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(EtrogpolygonzkevmSetForceBatchAddress) + 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(EtrogpolygonzkevmSetForceBatchAddress) + 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 *EtrogpolygonzkevmSetForceBatchAddressIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *EtrogpolygonzkevmSetForceBatchAddressIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// EtrogpolygonzkevmSetForceBatchAddress represents a SetForceBatchAddress event raised by the Etrogpolygonzkevm contract. +type EtrogpolygonzkevmSetForceBatchAddress struct { + NewForceBatchAddress common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterSetForceBatchAddress is a free log retrieval operation binding the contract event 0x5fbd7dd171301c4a1611a84aac4ba86d119478560557755f7927595b082634fb. +// +// Solidity: event SetForceBatchAddress(address newForceBatchAddress) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmFilterer) FilterSetForceBatchAddress(opts *bind.FilterOpts) (*EtrogpolygonzkevmSetForceBatchAddressIterator, error) { + + logs, sub, err := _Etrogpolygonzkevm.contract.FilterLogs(opts, "SetForceBatchAddress") + if err != nil { + return nil, err + } + return &EtrogpolygonzkevmSetForceBatchAddressIterator{contract: _Etrogpolygonzkevm.contract, event: "SetForceBatchAddress", logs: logs, sub: sub}, nil +} + +// WatchSetForceBatchAddress is a free log subscription operation binding the contract event 0x5fbd7dd171301c4a1611a84aac4ba86d119478560557755f7927595b082634fb. +// +// Solidity: event SetForceBatchAddress(address newForceBatchAddress) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmFilterer) WatchSetForceBatchAddress(opts *bind.WatchOpts, sink chan<- *EtrogpolygonzkevmSetForceBatchAddress) (event.Subscription, error) { + + logs, sub, err := _Etrogpolygonzkevm.contract.WatchLogs(opts, "SetForceBatchAddress") + 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(EtrogpolygonzkevmSetForceBatchAddress) + if err := _Etrogpolygonzkevm.contract.UnpackLog(event, "SetForceBatchAddress", 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 +} + +// ParseSetForceBatchAddress is a log parse operation binding the contract event 0x5fbd7dd171301c4a1611a84aac4ba86d119478560557755f7927595b082634fb. +// +// Solidity: event SetForceBatchAddress(address newForceBatchAddress) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmFilterer) ParseSetForceBatchAddress(log types.Log) (*EtrogpolygonzkevmSetForceBatchAddress, error) { + event := new(EtrogpolygonzkevmSetForceBatchAddress) + if err := _Etrogpolygonzkevm.contract.UnpackLog(event, "SetForceBatchAddress", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// EtrogpolygonzkevmSetForceBatchTimeoutIterator is returned from FilterSetForceBatchTimeout and is used to iterate over the raw logs and unpacked data for SetForceBatchTimeout events raised by the Etrogpolygonzkevm contract. +type EtrogpolygonzkevmSetForceBatchTimeoutIterator struct { + Event *EtrogpolygonzkevmSetForceBatchTimeout // 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 *EtrogpolygonzkevmSetForceBatchTimeoutIterator) 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(EtrogpolygonzkevmSetForceBatchTimeout) + 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(EtrogpolygonzkevmSetForceBatchTimeout) + 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 *EtrogpolygonzkevmSetForceBatchTimeoutIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *EtrogpolygonzkevmSetForceBatchTimeoutIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// EtrogpolygonzkevmSetForceBatchTimeout represents a SetForceBatchTimeout event raised by the Etrogpolygonzkevm contract. +type EtrogpolygonzkevmSetForceBatchTimeout 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 (_Etrogpolygonzkevm *EtrogpolygonzkevmFilterer) FilterSetForceBatchTimeout(opts *bind.FilterOpts) (*EtrogpolygonzkevmSetForceBatchTimeoutIterator, error) { + + logs, sub, err := _Etrogpolygonzkevm.contract.FilterLogs(opts, "SetForceBatchTimeout") + if err != nil { + return nil, err + } + return &EtrogpolygonzkevmSetForceBatchTimeoutIterator{contract: _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmFilterer) WatchSetForceBatchTimeout(opts *bind.WatchOpts, sink chan<- *EtrogpolygonzkevmSetForceBatchTimeout) (event.Subscription, error) { + + logs, sub, err := _Etrogpolygonzkevm.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(EtrogpolygonzkevmSetForceBatchTimeout) + if err := _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmFilterer) ParseSetForceBatchTimeout(log types.Log) (*EtrogpolygonzkevmSetForceBatchTimeout, error) { + event := new(EtrogpolygonzkevmSetForceBatchTimeout) + if err := _Etrogpolygonzkevm.contract.UnpackLog(event, "SetForceBatchTimeout", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// EtrogpolygonzkevmSetTrustedSequencerIterator is returned from FilterSetTrustedSequencer and is used to iterate over the raw logs and unpacked data for SetTrustedSequencer events raised by the Etrogpolygonzkevm contract. +type EtrogpolygonzkevmSetTrustedSequencerIterator struct { + Event *EtrogpolygonzkevmSetTrustedSequencer // 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 *EtrogpolygonzkevmSetTrustedSequencerIterator) 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(EtrogpolygonzkevmSetTrustedSequencer) + 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(EtrogpolygonzkevmSetTrustedSequencer) + 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 *EtrogpolygonzkevmSetTrustedSequencerIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *EtrogpolygonzkevmSetTrustedSequencerIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// EtrogpolygonzkevmSetTrustedSequencer represents a SetTrustedSequencer event raised by the Etrogpolygonzkevm contract. +type EtrogpolygonzkevmSetTrustedSequencer 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 (_Etrogpolygonzkevm *EtrogpolygonzkevmFilterer) FilterSetTrustedSequencer(opts *bind.FilterOpts) (*EtrogpolygonzkevmSetTrustedSequencerIterator, error) { + + logs, sub, err := _Etrogpolygonzkevm.contract.FilterLogs(opts, "SetTrustedSequencer") + if err != nil { + return nil, err + } + return &EtrogpolygonzkevmSetTrustedSequencerIterator{contract: _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmFilterer) WatchSetTrustedSequencer(opts *bind.WatchOpts, sink chan<- *EtrogpolygonzkevmSetTrustedSequencer) (event.Subscription, error) { + + logs, sub, err := _Etrogpolygonzkevm.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(EtrogpolygonzkevmSetTrustedSequencer) + if err := _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmFilterer) ParseSetTrustedSequencer(log types.Log) (*EtrogpolygonzkevmSetTrustedSequencer, error) { + event := new(EtrogpolygonzkevmSetTrustedSequencer) + if err := _Etrogpolygonzkevm.contract.UnpackLog(event, "SetTrustedSequencer", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// EtrogpolygonzkevmSetTrustedSequencerURLIterator is returned from FilterSetTrustedSequencerURL and is used to iterate over the raw logs and unpacked data for SetTrustedSequencerURL events raised by the Etrogpolygonzkevm contract. +type EtrogpolygonzkevmSetTrustedSequencerURLIterator struct { + Event *EtrogpolygonzkevmSetTrustedSequencerURL // 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 *EtrogpolygonzkevmSetTrustedSequencerURLIterator) 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(EtrogpolygonzkevmSetTrustedSequencerURL) + 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(EtrogpolygonzkevmSetTrustedSequencerURL) + 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 *EtrogpolygonzkevmSetTrustedSequencerURLIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *EtrogpolygonzkevmSetTrustedSequencerURLIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// EtrogpolygonzkevmSetTrustedSequencerURL represents a SetTrustedSequencerURL event raised by the Etrogpolygonzkevm contract. +type EtrogpolygonzkevmSetTrustedSequencerURL 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 (_Etrogpolygonzkevm *EtrogpolygonzkevmFilterer) FilterSetTrustedSequencerURL(opts *bind.FilterOpts) (*EtrogpolygonzkevmSetTrustedSequencerURLIterator, error) { + + logs, sub, err := _Etrogpolygonzkevm.contract.FilterLogs(opts, "SetTrustedSequencerURL") + if err != nil { + return nil, err + } + return &EtrogpolygonzkevmSetTrustedSequencerURLIterator{contract: _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmFilterer) WatchSetTrustedSequencerURL(opts *bind.WatchOpts, sink chan<- *EtrogpolygonzkevmSetTrustedSequencerURL) (event.Subscription, error) { + + logs, sub, err := _Etrogpolygonzkevm.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(EtrogpolygonzkevmSetTrustedSequencerURL) + if err := _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmFilterer) ParseSetTrustedSequencerURL(log types.Log) (*EtrogpolygonzkevmSetTrustedSequencerURL, error) { + event := new(EtrogpolygonzkevmSetTrustedSequencerURL) + if err := _Etrogpolygonzkevm.contract.UnpackLog(event, "SetTrustedSequencerURL", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// EtrogpolygonzkevmTransferAdminRoleIterator is returned from FilterTransferAdminRole and is used to iterate over the raw logs and unpacked data for TransferAdminRole events raised by the Etrogpolygonzkevm contract. +type EtrogpolygonzkevmTransferAdminRoleIterator struct { + Event *EtrogpolygonzkevmTransferAdminRole // 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 *EtrogpolygonzkevmTransferAdminRoleIterator) 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(EtrogpolygonzkevmTransferAdminRole) + 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(EtrogpolygonzkevmTransferAdminRole) + 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 *EtrogpolygonzkevmTransferAdminRoleIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *EtrogpolygonzkevmTransferAdminRoleIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// EtrogpolygonzkevmTransferAdminRole represents a TransferAdminRole event raised by the Etrogpolygonzkevm contract. +type EtrogpolygonzkevmTransferAdminRole 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 (_Etrogpolygonzkevm *EtrogpolygonzkevmFilterer) FilterTransferAdminRole(opts *bind.FilterOpts) (*EtrogpolygonzkevmTransferAdminRoleIterator, error) { + + logs, sub, err := _Etrogpolygonzkevm.contract.FilterLogs(opts, "TransferAdminRole") + if err != nil { + return nil, err + } + return &EtrogpolygonzkevmTransferAdminRoleIterator{contract: _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmFilterer) WatchTransferAdminRole(opts *bind.WatchOpts, sink chan<- *EtrogpolygonzkevmTransferAdminRole) (event.Subscription, error) { + + logs, sub, err := _Etrogpolygonzkevm.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(EtrogpolygonzkevmTransferAdminRole) + if err := _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmFilterer) ParseTransferAdminRole(log types.Log) (*EtrogpolygonzkevmTransferAdminRole, error) { + event := new(EtrogpolygonzkevmTransferAdminRole) + if err := _Etrogpolygonzkevm.contract.UnpackLog(event, "TransferAdminRole", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// EtrogpolygonzkevmUpdateEtrogSequenceIterator is returned from FilterUpdateEtrogSequence and is used to iterate over the raw logs and unpacked data for UpdateEtrogSequence events raised by the Etrogpolygonzkevm contract. +type EtrogpolygonzkevmUpdateEtrogSequenceIterator struct { + Event *EtrogpolygonzkevmUpdateEtrogSequence // 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 *EtrogpolygonzkevmUpdateEtrogSequenceIterator) 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(EtrogpolygonzkevmUpdateEtrogSequence) + 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(EtrogpolygonzkevmUpdateEtrogSequence) + 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 *EtrogpolygonzkevmUpdateEtrogSequenceIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *EtrogpolygonzkevmUpdateEtrogSequenceIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// EtrogpolygonzkevmUpdateEtrogSequence represents a UpdateEtrogSequence event raised by the Etrogpolygonzkevm contract. +type EtrogpolygonzkevmUpdateEtrogSequence struct { + NumBatch uint64 + Transactions []byte + LastGlobalExitRoot [32]byte + Sequencer common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterUpdateEtrogSequence is a free log retrieval operation binding the contract event 0xd2c80353fc15ef62c6affc7cd6b7ab5b42c43290c50be3372e55ae552cecd19c. +// +// Solidity: event UpdateEtrogSequence(uint64 numBatch, bytes transactions, bytes32 lastGlobalExitRoot, address sequencer) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmFilterer) FilterUpdateEtrogSequence(opts *bind.FilterOpts) (*EtrogpolygonzkevmUpdateEtrogSequenceIterator, error) { + + logs, sub, err := _Etrogpolygonzkevm.contract.FilterLogs(opts, "UpdateEtrogSequence") + if err != nil { + return nil, err + } + return &EtrogpolygonzkevmUpdateEtrogSequenceIterator{contract: _Etrogpolygonzkevm.contract, event: "UpdateEtrogSequence", logs: logs, sub: sub}, nil +} + +// WatchUpdateEtrogSequence is a free log subscription operation binding the contract event 0xd2c80353fc15ef62c6affc7cd6b7ab5b42c43290c50be3372e55ae552cecd19c. +// +// Solidity: event UpdateEtrogSequence(uint64 numBatch, bytes transactions, bytes32 lastGlobalExitRoot, address sequencer) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmFilterer) WatchUpdateEtrogSequence(opts *bind.WatchOpts, sink chan<- *EtrogpolygonzkevmUpdateEtrogSequence) (event.Subscription, error) { + + logs, sub, err := _Etrogpolygonzkevm.contract.WatchLogs(opts, "UpdateEtrogSequence") + 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(EtrogpolygonzkevmUpdateEtrogSequence) + if err := _Etrogpolygonzkevm.contract.UnpackLog(event, "UpdateEtrogSequence", 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 +} + +// ParseUpdateEtrogSequence is a log parse operation binding the contract event 0xd2c80353fc15ef62c6affc7cd6b7ab5b42c43290c50be3372e55ae552cecd19c. +// +// Solidity: event UpdateEtrogSequence(uint64 numBatch, bytes transactions, bytes32 lastGlobalExitRoot, address sequencer) +func (_Etrogpolygonzkevm *EtrogpolygonzkevmFilterer) ParseUpdateEtrogSequence(log types.Log) (*EtrogpolygonzkevmUpdateEtrogSequence, error) { + event := new(EtrogpolygonzkevmUpdateEtrogSequence) + if err := _Etrogpolygonzkevm.contract.UnpackLog(event, "UpdateEtrogSequence", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// EtrogpolygonzkevmVerifyBatchesIterator is returned from FilterVerifyBatches and is used to iterate over the raw logs and unpacked data for VerifyBatches events raised by the Etrogpolygonzkevm contract. +type EtrogpolygonzkevmVerifyBatchesIterator struct { + Event *EtrogpolygonzkevmVerifyBatches // 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 *EtrogpolygonzkevmVerifyBatchesIterator) 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(EtrogpolygonzkevmVerifyBatches) + 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(EtrogpolygonzkevmVerifyBatches) + 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 *EtrogpolygonzkevmVerifyBatchesIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *EtrogpolygonzkevmVerifyBatchesIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// EtrogpolygonzkevmVerifyBatches represents a VerifyBatches event raised by the Etrogpolygonzkevm contract. +type EtrogpolygonzkevmVerifyBatches 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 (_Etrogpolygonzkevm *EtrogpolygonzkevmFilterer) FilterVerifyBatches(opts *bind.FilterOpts, numBatch []uint64, aggregator []common.Address) (*EtrogpolygonzkevmVerifyBatchesIterator, 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 := _Etrogpolygonzkevm.contract.FilterLogs(opts, "VerifyBatches", numBatchRule, aggregatorRule) + if err != nil { + return nil, err + } + return &EtrogpolygonzkevmVerifyBatchesIterator{contract: _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmFilterer) WatchVerifyBatches(opts *bind.WatchOpts, sink chan<- *EtrogpolygonzkevmVerifyBatches, 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 := _Etrogpolygonzkevm.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(EtrogpolygonzkevmVerifyBatches) + if err := _Etrogpolygonzkevm.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 (_Etrogpolygonzkevm *EtrogpolygonzkevmFilterer) ParseVerifyBatches(log types.Log) (*EtrogpolygonzkevmVerifyBatches, error) { + event := new(EtrogpolygonzkevmVerifyBatches) + if err := _Etrogpolygonzkevm.contract.UnpackLog(event, "VerifyBatches", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/etherman/smartcontracts/mockpolygonrollupmanager/mockpolygonrollupmanager.go b/etherman/smartcontracts/mockpolygonrollupmanager/mockpolygonrollupmanager.go new file mode 100644 index 00000000..f01d76ae --- /dev/null +++ b/etherman/smartcontracts/mockpolygonrollupmanager/mockpolygonrollupmanager.go @@ -0,0 +1,5058 @@ +// 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\":\"contractIPolygonZkEVMGlobalExitRootV2\",\"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\":\"RollupAddressAlreadyExist\",\"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\":\"contractIPolygonZkEVMGlobalExitRootV2\",\"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\":\"contractPolygonZkEVMExistentEtrog\",\"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\":\"lastDeactivatedEmergencyStateTimestamp\",\"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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", +} + +// 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) +} + +// LastDeactivatedEmergencyStateTimestamp is a free data retrieval call binding the contract method 0x30c27dde. +// +// Solidity: function lastDeactivatedEmergencyStateTimestamp() view returns(uint64) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCaller) LastDeactivatedEmergencyStateTimestamp(opts *bind.CallOpts) (uint64, error) { + var out []interface{} + err := _Mockpolygonrollupmanager.contract.Call(opts, &out, "lastDeactivatedEmergencyStateTimestamp") + + if err != nil { + return *new(uint64), err + } + + out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64) + + return out0, err + +} + +// LastDeactivatedEmergencyStateTimestamp is a free data retrieval call binding the contract method 0x30c27dde. +// +// Solidity: function lastDeactivatedEmergencyStateTimestamp() view returns(uint64) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerSession) LastDeactivatedEmergencyStateTimestamp() (uint64, error) { + return _Mockpolygonrollupmanager.Contract.LastDeactivatedEmergencyStateTimestamp(&_Mockpolygonrollupmanager.CallOpts) +} + +// LastDeactivatedEmergencyStateTimestamp is a free data retrieval call binding the contract method 0x30c27dde. +// +// Solidity: function lastDeactivatedEmergencyStateTimestamp() view returns(uint64) +func (_Mockpolygonrollupmanager *MockpolygonrollupmanagerCallerSession) LastDeactivatedEmergencyStateTimestamp() (uint64, error) { + return _Mockpolygonrollupmanager.Contract.LastDeactivatedEmergencyStateTimestamp(&_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) +} + +// 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 00000000..18c20426 --- /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: "0x608060405234801561001057600080fd5b50610158806100206000396000f3fe608060405234801561001057600080fd5b506004361061002b5760003560e01c80639121da8a14610030575b600080fd5b61004661003e366004610089565b600192915050565b604051901515815260200160405180910390f35b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b60008061032080848603121561009e57600080fd5b6103008401858111156100b057600080fd5b8493508561031f8601126100c357600080fd5b604051602080820182811067ffffffffffffffff821117156100e7576100e761005a565b6040529286019281888511156100fc57600080fd5b5b8484101561011457833581529281019281016100fd565b50949790965094505050505056fea264697066735822122066b50cbb730099c9f1f258fa949f9d4e1a1ef7636af905817cebb300b2be0d2664736f6c63430008140033", +} + +// 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 00000000..3750d00d --- /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 00000000..da71cf65 --- /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: "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", +} + +// 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 00000000..2ee62351 --- /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 00000000..37290334 --- /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/polygondatacommittee/polygondatacommittee.go b/etherman/smartcontracts/polygondatacommittee/polygondatacommittee.go new file mode 100644 index 00000000..d2e7d5e9 --- /dev/null +++ b/etherman/smartcontracts/polygondatacommittee/polygondatacommittee.go @@ -0,0 +1,937 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package polygondatacommittee + +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 +) + +// PolygondatacommitteeMetaData contains all meta data concerning the Polygondatacommittee contract. +var PolygondatacommitteeMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[],\"name\":\"CommitteeAddressDoesntExist\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"EmptyURLNotAllowed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TooManyRequiredSignatures\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"UnexpectedAddrsAndSignaturesSize\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"UnexpectedAddrsBytesLength\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"UnexpectedCommitteeHash\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WrongAddrOrder\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"committeeHash\",\"type\":\"bytes32\"}],\"name\":\"CommitteeUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"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\"},{\"inputs\":[],\"name\":\"committeeHash\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getAmountOfMembers\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getProcotolName\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"members\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"url\",\"type\":\"string\"},{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"requiredAmountOfSignatures\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_requiredAmountOfSignatures\",\"type\":\"uint256\"},{\"internalType\":\"string[]\",\"name\":\"urls\",\"type\":\"string[]\"},{\"internalType\":\"bytes\",\"name\":\"addrsBytes\",\"type\":\"bytes\"}],\"name\":\"setupCommittee\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"signedHash\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"signaturesAndAddrs\",\"type\":\"bytes\"}],\"name\":\"verifyMessage\",\"outputs\":[],\"stateMutability\":\"view\",\"type\":\"function\"}]", + Bin: "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", +} + +// PolygondatacommitteeABI is the input ABI used to generate the binding from. +// Deprecated: Use PolygondatacommitteeMetaData.ABI instead. +var PolygondatacommitteeABI = PolygondatacommitteeMetaData.ABI + +// PolygondatacommitteeBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use PolygondatacommitteeMetaData.Bin instead. +var PolygondatacommitteeBin = PolygondatacommitteeMetaData.Bin + +// DeployPolygondatacommittee deploys a new Ethereum contract, binding an instance of Polygondatacommittee to it. +func DeployPolygondatacommittee(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Polygondatacommittee, error) { + parsed, err := PolygondatacommitteeMetaData.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(PolygondatacommitteeBin), backend) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &Polygondatacommittee{PolygondatacommitteeCaller: PolygondatacommitteeCaller{contract: contract}, PolygondatacommitteeTransactor: PolygondatacommitteeTransactor{contract: contract}, PolygondatacommitteeFilterer: PolygondatacommitteeFilterer{contract: contract}}, nil +} + +// Polygondatacommittee is an auto generated Go binding around an Ethereum contract. +type Polygondatacommittee struct { + PolygondatacommitteeCaller // Read-only binding to the contract + PolygondatacommitteeTransactor // Write-only binding to the contract + PolygondatacommitteeFilterer // Log filterer for contract events +} + +// PolygondatacommitteeCaller is an auto generated read-only Go binding around an Ethereum contract. +type PolygondatacommitteeCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// PolygondatacommitteeTransactor is an auto generated write-only Go binding around an Ethereum contract. +type PolygondatacommitteeTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// PolygondatacommitteeFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type PolygondatacommitteeFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// PolygondatacommitteeSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type PolygondatacommitteeSession struct { + Contract *Polygondatacommittee // 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 +} + +// PolygondatacommitteeCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type PolygondatacommitteeCallerSession struct { + Contract *PolygondatacommitteeCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// PolygondatacommitteeTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type PolygondatacommitteeTransactorSession struct { + Contract *PolygondatacommitteeTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// PolygondatacommitteeRaw is an auto generated low-level Go binding around an Ethereum contract. +type PolygondatacommitteeRaw struct { + Contract *Polygondatacommittee // Generic contract binding to access the raw methods on +} + +// PolygondatacommitteeCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type PolygondatacommitteeCallerRaw struct { + Contract *PolygondatacommitteeCaller // Generic read-only contract binding to access the raw methods on +} + +// PolygondatacommitteeTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type PolygondatacommitteeTransactorRaw struct { + Contract *PolygondatacommitteeTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewPolygondatacommittee creates a new instance of Polygondatacommittee, bound to a specific deployed contract. +func NewPolygondatacommittee(address common.Address, backend bind.ContractBackend) (*Polygondatacommittee, error) { + contract, err := bindPolygondatacommittee(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &Polygondatacommittee{PolygondatacommitteeCaller: PolygondatacommitteeCaller{contract: contract}, PolygondatacommitteeTransactor: PolygondatacommitteeTransactor{contract: contract}, PolygondatacommitteeFilterer: PolygondatacommitteeFilterer{contract: contract}}, nil +} + +// NewPolygondatacommitteeCaller creates a new read-only instance of Polygondatacommittee, bound to a specific deployed contract. +func NewPolygondatacommitteeCaller(address common.Address, caller bind.ContractCaller) (*PolygondatacommitteeCaller, error) { + contract, err := bindPolygondatacommittee(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &PolygondatacommitteeCaller{contract: contract}, nil +} + +// NewPolygondatacommitteeTransactor creates a new write-only instance of Polygondatacommittee, bound to a specific deployed contract. +func NewPolygondatacommitteeTransactor(address common.Address, transactor bind.ContractTransactor) (*PolygondatacommitteeTransactor, error) { + contract, err := bindPolygondatacommittee(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &PolygondatacommitteeTransactor{contract: contract}, nil +} + +// NewPolygondatacommitteeFilterer creates a new log filterer instance of Polygondatacommittee, bound to a specific deployed contract. +func NewPolygondatacommitteeFilterer(address common.Address, filterer bind.ContractFilterer) (*PolygondatacommitteeFilterer, error) { + contract, err := bindPolygondatacommittee(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &PolygondatacommitteeFilterer{contract: contract}, nil +} + +// bindPolygondatacommittee binds a generic wrapper to an already deployed contract. +func bindPolygondatacommittee(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := PolygondatacommitteeMetaData.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 (_Polygondatacommittee *PolygondatacommitteeRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Polygondatacommittee.Contract.PolygondatacommitteeCaller.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 (_Polygondatacommittee *PolygondatacommitteeRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Polygondatacommittee.Contract.PolygondatacommitteeTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Polygondatacommittee *PolygondatacommitteeRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Polygondatacommittee.Contract.PolygondatacommitteeTransactor.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 (_Polygondatacommittee *PolygondatacommitteeCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Polygondatacommittee.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 (_Polygondatacommittee *PolygondatacommitteeTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Polygondatacommittee.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Polygondatacommittee *PolygondatacommitteeTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Polygondatacommittee.Contract.contract.Transact(opts, method, params...) +} + +// CommitteeHash is a free data retrieval call binding the contract method 0x609d4544. +// +// Solidity: function committeeHash() view returns(bytes32) +func (_Polygondatacommittee *PolygondatacommitteeCaller) CommitteeHash(opts *bind.CallOpts) ([32]byte, error) { + var out []interface{} + err := _Polygondatacommittee.contract.Call(opts, &out, "committeeHash") + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// CommitteeHash is a free data retrieval call binding the contract method 0x609d4544. +// +// Solidity: function committeeHash() view returns(bytes32) +func (_Polygondatacommittee *PolygondatacommitteeSession) CommitteeHash() ([32]byte, error) { + return _Polygondatacommittee.Contract.CommitteeHash(&_Polygondatacommittee.CallOpts) +} + +// CommitteeHash is a free data retrieval call binding the contract method 0x609d4544. +// +// Solidity: function committeeHash() view returns(bytes32) +func (_Polygondatacommittee *PolygondatacommitteeCallerSession) CommitteeHash() ([32]byte, error) { + return _Polygondatacommittee.Contract.CommitteeHash(&_Polygondatacommittee.CallOpts) +} + +// GetAmountOfMembers is a free data retrieval call binding the contract method 0xdce1e2b6. +// +// Solidity: function getAmountOfMembers() view returns(uint256) +func (_Polygondatacommittee *PolygondatacommitteeCaller) GetAmountOfMembers(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _Polygondatacommittee.contract.Call(opts, &out, "getAmountOfMembers") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// GetAmountOfMembers is a free data retrieval call binding the contract method 0xdce1e2b6. +// +// Solidity: function getAmountOfMembers() view returns(uint256) +func (_Polygondatacommittee *PolygondatacommitteeSession) GetAmountOfMembers() (*big.Int, error) { + return _Polygondatacommittee.Contract.GetAmountOfMembers(&_Polygondatacommittee.CallOpts) +} + +// GetAmountOfMembers is a free data retrieval call binding the contract method 0xdce1e2b6. +// +// Solidity: function getAmountOfMembers() view returns(uint256) +func (_Polygondatacommittee *PolygondatacommitteeCallerSession) GetAmountOfMembers() (*big.Int, error) { + return _Polygondatacommittee.Contract.GetAmountOfMembers(&_Polygondatacommittee.CallOpts) +} + +// GetProcotolName is a free data retrieval call binding the contract method 0xe4f17120. +// +// Solidity: function getProcotolName() pure returns(string) +func (_Polygondatacommittee *PolygondatacommitteeCaller) GetProcotolName(opts *bind.CallOpts) (string, error) { + var out []interface{} + err := _Polygondatacommittee.contract.Call(opts, &out, "getProcotolName") + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// GetProcotolName is a free data retrieval call binding the contract method 0xe4f17120. +// +// Solidity: function getProcotolName() pure returns(string) +func (_Polygondatacommittee *PolygondatacommitteeSession) GetProcotolName() (string, error) { + return _Polygondatacommittee.Contract.GetProcotolName(&_Polygondatacommittee.CallOpts) +} + +// GetProcotolName is a free data retrieval call binding the contract method 0xe4f17120. +// +// Solidity: function getProcotolName() pure returns(string) +func (_Polygondatacommittee *PolygondatacommitteeCallerSession) GetProcotolName() (string, error) { + return _Polygondatacommittee.Contract.GetProcotolName(&_Polygondatacommittee.CallOpts) +} + +// Members is a free data retrieval call binding the contract method 0x5daf08ca. +// +// Solidity: function members(uint256 ) view returns(string url, address addr) +func (_Polygondatacommittee *PolygondatacommitteeCaller) Members(opts *bind.CallOpts, arg0 *big.Int) (struct { + Url string + Addr common.Address +}, error) { + var out []interface{} + err := _Polygondatacommittee.contract.Call(opts, &out, "members", arg0) + + outstruct := new(struct { + Url string + Addr common.Address + }) + if err != nil { + return *outstruct, err + } + + outstruct.Url = *abi.ConvertType(out[0], new(string)).(*string) + outstruct.Addr = *abi.ConvertType(out[1], new(common.Address)).(*common.Address) + + return *outstruct, err + +} + +// Members is a free data retrieval call binding the contract method 0x5daf08ca. +// +// Solidity: function members(uint256 ) view returns(string url, address addr) +func (_Polygondatacommittee *PolygondatacommitteeSession) Members(arg0 *big.Int) (struct { + Url string + Addr common.Address +}, error) { + return _Polygondatacommittee.Contract.Members(&_Polygondatacommittee.CallOpts, arg0) +} + +// Members is a free data retrieval call binding the contract method 0x5daf08ca. +// +// Solidity: function members(uint256 ) view returns(string url, address addr) +func (_Polygondatacommittee *PolygondatacommitteeCallerSession) Members(arg0 *big.Int) (struct { + Url string + Addr common.Address +}, error) { + return _Polygondatacommittee.Contract.Members(&_Polygondatacommittee.CallOpts, arg0) +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_Polygondatacommittee *PolygondatacommitteeCaller) Owner(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Polygondatacommittee.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 (_Polygondatacommittee *PolygondatacommitteeSession) Owner() (common.Address, error) { + return _Polygondatacommittee.Contract.Owner(&_Polygondatacommittee.CallOpts) +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_Polygondatacommittee *PolygondatacommitteeCallerSession) Owner() (common.Address, error) { + return _Polygondatacommittee.Contract.Owner(&_Polygondatacommittee.CallOpts) +} + +// RequiredAmountOfSignatures is a free data retrieval call binding the contract method 0x6beedd39. +// +// Solidity: function requiredAmountOfSignatures() view returns(uint256) +func (_Polygondatacommittee *PolygondatacommitteeCaller) RequiredAmountOfSignatures(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _Polygondatacommittee.contract.Call(opts, &out, "requiredAmountOfSignatures") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// RequiredAmountOfSignatures is a free data retrieval call binding the contract method 0x6beedd39. +// +// Solidity: function requiredAmountOfSignatures() view returns(uint256) +func (_Polygondatacommittee *PolygondatacommitteeSession) RequiredAmountOfSignatures() (*big.Int, error) { + return _Polygondatacommittee.Contract.RequiredAmountOfSignatures(&_Polygondatacommittee.CallOpts) +} + +// RequiredAmountOfSignatures is a free data retrieval call binding the contract method 0x6beedd39. +// +// Solidity: function requiredAmountOfSignatures() view returns(uint256) +func (_Polygondatacommittee *PolygondatacommitteeCallerSession) RequiredAmountOfSignatures() (*big.Int, error) { + return _Polygondatacommittee.Contract.RequiredAmountOfSignatures(&_Polygondatacommittee.CallOpts) +} + +// VerifyMessage is a free data retrieval call binding the contract method 0x3b51be4b. +// +// Solidity: function verifyMessage(bytes32 signedHash, bytes signaturesAndAddrs) view returns() +func (_Polygondatacommittee *PolygondatacommitteeCaller) VerifyMessage(opts *bind.CallOpts, signedHash [32]byte, signaturesAndAddrs []byte) error { + var out []interface{} + err := _Polygondatacommittee.contract.Call(opts, &out, "verifyMessage", signedHash, signaturesAndAddrs) + + if err != nil { + return err + } + + return err + +} + +// VerifyMessage is a free data retrieval call binding the contract method 0x3b51be4b. +// +// Solidity: function verifyMessage(bytes32 signedHash, bytes signaturesAndAddrs) view returns() +func (_Polygondatacommittee *PolygondatacommitteeSession) VerifyMessage(signedHash [32]byte, signaturesAndAddrs []byte) error { + return _Polygondatacommittee.Contract.VerifyMessage(&_Polygondatacommittee.CallOpts, signedHash, signaturesAndAddrs) +} + +// VerifyMessage is a free data retrieval call binding the contract method 0x3b51be4b. +// +// Solidity: function verifyMessage(bytes32 signedHash, bytes signaturesAndAddrs) view returns() +func (_Polygondatacommittee *PolygondatacommitteeCallerSession) VerifyMessage(signedHash [32]byte, signaturesAndAddrs []byte) error { + return _Polygondatacommittee.Contract.VerifyMessage(&_Polygondatacommittee.CallOpts, signedHash, signaturesAndAddrs) +} + +// Initialize is a paid mutator transaction binding the contract method 0x8129fc1c. +// +// Solidity: function initialize() returns() +func (_Polygondatacommittee *PolygondatacommitteeTransactor) Initialize(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Polygondatacommittee.contract.Transact(opts, "initialize") +} + +// Initialize is a paid mutator transaction binding the contract method 0x8129fc1c. +// +// Solidity: function initialize() returns() +func (_Polygondatacommittee *PolygondatacommitteeSession) Initialize() (*types.Transaction, error) { + return _Polygondatacommittee.Contract.Initialize(&_Polygondatacommittee.TransactOpts) +} + +// Initialize is a paid mutator transaction binding the contract method 0x8129fc1c. +// +// Solidity: function initialize() returns() +func (_Polygondatacommittee *PolygondatacommitteeTransactorSession) Initialize() (*types.Transaction, error) { + return _Polygondatacommittee.Contract.Initialize(&_Polygondatacommittee.TransactOpts) +} + +// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. +// +// Solidity: function renounceOwnership() returns() +func (_Polygondatacommittee *PolygondatacommitteeTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Polygondatacommittee.contract.Transact(opts, "renounceOwnership") +} + +// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. +// +// Solidity: function renounceOwnership() returns() +func (_Polygondatacommittee *PolygondatacommitteeSession) RenounceOwnership() (*types.Transaction, error) { + return _Polygondatacommittee.Contract.RenounceOwnership(&_Polygondatacommittee.TransactOpts) +} + +// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. +// +// Solidity: function renounceOwnership() returns() +func (_Polygondatacommittee *PolygondatacommitteeTransactorSession) RenounceOwnership() (*types.Transaction, error) { + return _Polygondatacommittee.Contract.RenounceOwnership(&_Polygondatacommittee.TransactOpts) +} + +// SetupCommittee is a paid mutator transaction binding the contract method 0x078fba2a. +// +// Solidity: function setupCommittee(uint256 _requiredAmountOfSignatures, string[] urls, bytes addrsBytes) returns() +func (_Polygondatacommittee *PolygondatacommitteeTransactor) SetupCommittee(opts *bind.TransactOpts, _requiredAmountOfSignatures *big.Int, urls []string, addrsBytes []byte) (*types.Transaction, error) { + return _Polygondatacommittee.contract.Transact(opts, "setupCommittee", _requiredAmountOfSignatures, urls, addrsBytes) +} + +// SetupCommittee is a paid mutator transaction binding the contract method 0x078fba2a. +// +// Solidity: function setupCommittee(uint256 _requiredAmountOfSignatures, string[] urls, bytes addrsBytes) returns() +func (_Polygondatacommittee *PolygondatacommitteeSession) SetupCommittee(_requiredAmountOfSignatures *big.Int, urls []string, addrsBytes []byte) (*types.Transaction, error) { + return _Polygondatacommittee.Contract.SetupCommittee(&_Polygondatacommittee.TransactOpts, _requiredAmountOfSignatures, urls, addrsBytes) +} + +// SetupCommittee is a paid mutator transaction binding the contract method 0x078fba2a. +// +// Solidity: function setupCommittee(uint256 _requiredAmountOfSignatures, string[] urls, bytes addrsBytes) returns() +func (_Polygondatacommittee *PolygondatacommitteeTransactorSession) SetupCommittee(_requiredAmountOfSignatures *big.Int, urls []string, addrsBytes []byte) (*types.Transaction, error) { + return _Polygondatacommittee.Contract.SetupCommittee(&_Polygondatacommittee.TransactOpts, _requiredAmountOfSignatures, urls, addrsBytes) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_Polygondatacommittee *PolygondatacommitteeTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { + return _Polygondatacommittee.contract.Transact(opts, "transferOwnership", newOwner) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_Polygondatacommittee *PolygondatacommitteeSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _Polygondatacommittee.Contract.TransferOwnership(&_Polygondatacommittee.TransactOpts, newOwner) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_Polygondatacommittee *PolygondatacommitteeTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _Polygondatacommittee.Contract.TransferOwnership(&_Polygondatacommittee.TransactOpts, newOwner) +} + +// PolygondatacommitteeCommitteeUpdatedIterator is returned from FilterCommitteeUpdated and is used to iterate over the raw logs and unpacked data for CommitteeUpdated events raised by the Polygondatacommittee contract. +type PolygondatacommitteeCommitteeUpdatedIterator struct { + Event *PolygondatacommitteeCommitteeUpdated // 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 *PolygondatacommitteeCommitteeUpdatedIterator) 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(PolygondatacommitteeCommitteeUpdated) + 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(PolygondatacommitteeCommitteeUpdated) + 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 *PolygondatacommitteeCommitteeUpdatedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolygondatacommitteeCommitteeUpdatedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolygondatacommitteeCommitteeUpdated represents a CommitteeUpdated event raised by the Polygondatacommittee contract. +type PolygondatacommitteeCommitteeUpdated struct { + CommitteeHash [32]byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterCommitteeUpdated is a free log retrieval operation binding the contract event 0x831403fd381b3e6ac875d912ec2eee0e0203d0d29f7b3e0c96fc8f582d6db657. +// +// Solidity: event CommitteeUpdated(bytes32 committeeHash) +func (_Polygondatacommittee *PolygondatacommitteeFilterer) FilterCommitteeUpdated(opts *bind.FilterOpts) (*PolygondatacommitteeCommitteeUpdatedIterator, error) { + + logs, sub, err := _Polygondatacommittee.contract.FilterLogs(opts, "CommitteeUpdated") + if err != nil { + return nil, err + } + return &PolygondatacommitteeCommitteeUpdatedIterator{contract: _Polygondatacommittee.contract, event: "CommitteeUpdated", logs: logs, sub: sub}, nil +} + +// WatchCommitteeUpdated is a free log subscription operation binding the contract event 0x831403fd381b3e6ac875d912ec2eee0e0203d0d29f7b3e0c96fc8f582d6db657. +// +// Solidity: event CommitteeUpdated(bytes32 committeeHash) +func (_Polygondatacommittee *PolygondatacommitteeFilterer) WatchCommitteeUpdated(opts *bind.WatchOpts, sink chan<- *PolygondatacommitteeCommitteeUpdated) (event.Subscription, error) { + + logs, sub, err := _Polygondatacommittee.contract.WatchLogs(opts, "CommitteeUpdated") + 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(PolygondatacommitteeCommitteeUpdated) + if err := _Polygondatacommittee.contract.UnpackLog(event, "CommitteeUpdated", 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 +} + +// ParseCommitteeUpdated is a log parse operation binding the contract event 0x831403fd381b3e6ac875d912ec2eee0e0203d0d29f7b3e0c96fc8f582d6db657. +// +// Solidity: event CommitteeUpdated(bytes32 committeeHash) +func (_Polygondatacommittee *PolygondatacommitteeFilterer) ParseCommitteeUpdated(log types.Log) (*PolygondatacommitteeCommitteeUpdated, error) { + event := new(PolygondatacommitteeCommitteeUpdated) + if err := _Polygondatacommittee.contract.UnpackLog(event, "CommitteeUpdated", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PolygondatacommitteeInitializedIterator is returned from FilterInitialized and is used to iterate over the raw logs and unpacked data for Initialized events raised by the Polygondatacommittee contract. +type PolygondatacommitteeInitializedIterator struct { + Event *PolygondatacommitteeInitialized // 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 *PolygondatacommitteeInitializedIterator) 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(PolygondatacommitteeInitialized) + 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(PolygondatacommitteeInitialized) + 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 *PolygondatacommitteeInitializedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolygondatacommitteeInitializedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolygondatacommitteeInitialized represents a Initialized event raised by the Polygondatacommittee contract. +type PolygondatacommitteeInitialized 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 (_Polygondatacommittee *PolygondatacommitteeFilterer) FilterInitialized(opts *bind.FilterOpts) (*PolygondatacommitteeInitializedIterator, error) { + + logs, sub, err := _Polygondatacommittee.contract.FilterLogs(opts, "Initialized") + if err != nil { + return nil, err + } + return &PolygondatacommitteeInitializedIterator{contract: _Polygondatacommittee.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 (_Polygondatacommittee *PolygondatacommitteeFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *PolygondatacommitteeInitialized) (event.Subscription, error) { + + logs, sub, err := _Polygondatacommittee.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(PolygondatacommitteeInitialized) + if err := _Polygondatacommittee.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 (_Polygondatacommittee *PolygondatacommitteeFilterer) ParseInitialized(log types.Log) (*PolygondatacommitteeInitialized, error) { + event := new(PolygondatacommitteeInitialized) + if err := _Polygondatacommittee.contract.UnpackLog(event, "Initialized", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PolygondatacommitteeOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the Polygondatacommittee contract. +type PolygondatacommitteeOwnershipTransferredIterator struct { + Event *PolygondatacommitteeOwnershipTransferred // 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 *PolygondatacommitteeOwnershipTransferredIterator) 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(PolygondatacommitteeOwnershipTransferred) + 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(PolygondatacommitteeOwnershipTransferred) + 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 *PolygondatacommitteeOwnershipTransferredIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolygondatacommitteeOwnershipTransferredIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolygondatacommitteeOwnershipTransferred represents a OwnershipTransferred event raised by the Polygondatacommittee contract. +type PolygondatacommitteeOwnershipTransferred 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 (_Polygondatacommittee *PolygondatacommitteeFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*PolygondatacommitteeOwnershipTransferredIterator, 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 := _Polygondatacommittee.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) + if err != nil { + return nil, err + } + return &PolygondatacommitteeOwnershipTransferredIterator{contract: _Polygondatacommittee.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 (_Polygondatacommittee *PolygondatacommitteeFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *PolygondatacommitteeOwnershipTransferred, 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 := _Polygondatacommittee.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(PolygondatacommitteeOwnershipTransferred) + if err := _Polygondatacommittee.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 (_Polygondatacommittee *PolygondatacommitteeFilterer) ParseOwnershipTransferred(log types.Log) (*PolygondatacommitteeOwnershipTransferred, error) { + event := new(PolygondatacommitteeOwnershipTransferred) + if err := _Polygondatacommittee.contract.UnpackLog(event, "OwnershipTransferred", 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 00000000..5080bf48 --- /dev/null +++ b/etherman/smartcontracts/polygonrollupmanager/polygonrollupmanager.go @@ -0,0 +1,5058 @@ +// 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\":\"contractIPolygonZkEVMGlobalExitRootV2\",\"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\":\"RollupAddressAlreadyExist\",\"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\":\"contractIPolygonZkEVMGlobalExitRootV2\",\"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\":\"contractPolygonZkEVMExistentEtrog\",\"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\":\"lastDeactivatedEmergencyStateTimestamp\",\"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) +} + +// LastDeactivatedEmergencyStateTimestamp is a free data retrieval call binding the contract method 0x30c27dde. +// +// Solidity: function lastDeactivatedEmergencyStateTimestamp() view returns(uint64) +func (_Polygonrollupmanager *PolygonrollupmanagerCaller) LastDeactivatedEmergencyStateTimestamp(opts *bind.CallOpts) (uint64, error) { + var out []interface{} + err := _Polygonrollupmanager.contract.Call(opts, &out, "lastDeactivatedEmergencyStateTimestamp") + + if err != nil { + return *new(uint64), err + } + + out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64) + + return out0, err + +} + +// LastDeactivatedEmergencyStateTimestamp is a free data retrieval call binding the contract method 0x30c27dde. +// +// Solidity: function lastDeactivatedEmergencyStateTimestamp() view returns(uint64) +func (_Polygonrollupmanager *PolygonrollupmanagerSession) LastDeactivatedEmergencyStateTimestamp() (uint64, error) { + return _Polygonrollupmanager.Contract.LastDeactivatedEmergencyStateTimestamp(&_Polygonrollupmanager.CallOpts) +} + +// LastDeactivatedEmergencyStateTimestamp is a free data retrieval call binding the contract method 0x30c27dde. +// +// Solidity: function lastDeactivatedEmergencyStateTimestamp() view returns(uint64) +func (_Polygonrollupmanager *PolygonrollupmanagerCallerSession) LastDeactivatedEmergencyStateTimestamp() (uint64, error) { + return _Polygonrollupmanager.Contract.LastDeactivatedEmergencyStateTimestamp(&_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 00000000..cd98363c --- /dev/null +++ b/etherman/smartcontracts/polygonzkevm/polygonzkevm.go @@ -0,0 +1,3500 @@ +// 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 +} + +// PolygonValidiumEtrogValidiumBatchData is an auto generated low-level Go binding around an user-defined struct. +type PolygonValidiumEtrogValidiumBatchData struct { + TransactionsHash [32]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\":\"ForceBatchesDecentralized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ForceBatchesNotAllowedOnEmergencyState\",\"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\":\"HaltTimeoutNotExpiredAfterEmergencyState\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"HugeTokenMetadataNotSupported\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InitNumBatchAboveLastVerifiedBatch\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InitNumBatchDoesNotMatchPendingState\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InitSequencedBatchDoesNotMatch\",\"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\":\"MaxTimestampSequenceInvalid\",\"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\":\"SequenceWithDataAvailabilityNotAllowed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SequenceZeroBatches\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SequencedTimestampBelowForcedTimestamp\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SequencedTimestampInvalid\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"StoredRootMustBeDifferentThanNewRoot\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SwitchToSameValue\",\"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\":[{\"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\":\"address\",\"name\":\"newDataAvailabilityProtocol\",\"type\":\"address\"}],\"name\":\"SetDataAvailabilityProtocol\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newForceBatchAddress\",\"type\":\"address\"}],\"name\":\"SetForceBatchAddress\",\"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\":[],\"name\":\"SwitchSequenceWithDataAvailability\",\"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\":\"TIMESTAMP_RANGE\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"acceptAdminRole\",\"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\":[],\"name\":\"dataAvailabilityProtocol\",\"outputs\":[{\"internalType\":\"contractIDataAvailabilityProtocol\",\"name\":\"\",\"type\":\"address\"}],\"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\":\"forceBatchAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"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\":\"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\":\"isSequenceWithDataAvailabilityAllowed\",\"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\":\"uint64\",\"name\":\"maxSequenceTimestamp\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"initSequencedBatch\",\"type\":\"uint64\"},{\"internalType\":\"address\",\"name\":\"l2Coinbase\",\"type\":\"address\"}],\"name\":\"sequenceBatches\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"transactionsHash\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"forcedGlobalExitRoot\",\"type\":\"bytes32\"},{\"internalType\":\"uint64\",\"name\":\"forcedTimestamp\",\"type\":\"uint64\"},{\"internalType\":\"bytes32\",\"name\":\"forcedBlockHashL1\",\"type\":\"bytes32\"}],\"internalType\":\"structPolygonValidiumEtrog.ValidiumBatchData[]\",\"name\":\"batches\",\"type\":\"tuple[]\"},{\"internalType\":\"uint64\",\"name\":\"maxSequenceTimestamp\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"initSequencedBatch\",\"type\":\"uint64\"},{\"internalType\":\"address\",\"name\":\"l2Coinbase\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"dataAvailabilityMessage\",\"type\":\"bytes\"}],\"name\":\"sequenceBatchesValidium\",\"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\":\"contractIDataAvailabilityProtocol\",\"name\":\"newDataAvailabilityProtocol\",\"type\":\"address\"}],\"name\":\"setDataAvailabilityProtocol\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newForceBatchAddress\",\"type\":\"address\"}],\"name\":\"setForceBatchAddress\",\"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\":\"bool\",\"name\":\"newIsSequenceWithDataAvailabilityAllowed\",\"type\":\"bool\"}],\"name\":\"switchSequenceWithDataAvailability\",\"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) +} + +// TIMESTAMPRANGE is a free data retrieval call binding the contract method 0x42308fab. +// +// Solidity: function TIMESTAMP_RANGE() view returns(uint256) +func (_Polygonzkevm *PolygonzkevmCaller) TIMESTAMPRANGE(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _Polygonzkevm.contract.Call(opts, &out, "TIMESTAMP_RANGE") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// TIMESTAMPRANGE is a free data retrieval call binding the contract method 0x42308fab. +// +// Solidity: function TIMESTAMP_RANGE() view returns(uint256) +func (_Polygonzkevm *PolygonzkevmSession) TIMESTAMPRANGE() (*big.Int, error) { + return _Polygonzkevm.Contract.TIMESTAMPRANGE(&_Polygonzkevm.CallOpts) +} + +// TIMESTAMPRANGE is a free data retrieval call binding the contract method 0x42308fab. +// +// Solidity: function TIMESTAMP_RANGE() view returns(uint256) +func (_Polygonzkevm *PolygonzkevmCallerSession) TIMESTAMPRANGE() (*big.Int, error) { + return _Polygonzkevm.Contract.TIMESTAMPRANGE(&_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) +} + +// DataAvailabilityProtocol is a free data retrieval call binding the contract method 0xe57a0b4c. +// +// Solidity: function dataAvailabilityProtocol() view returns(address) +func (_Polygonzkevm *PolygonzkevmCaller) DataAvailabilityProtocol(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Polygonzkevm.contract.Call(opts, &out, "dataAvailabilityProtocol") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// DataAvailabilityProtocol is a free data retrieval call binding the contract method 0xe57a0b4c. +// +// Solidity: function dataAvailabilityProtocol() view returns(address) +func (_Polygonzkevm *PolygonzkevmSession) DataAvailabilityProtocol() (common.Address, error) { + return _Polygonzkevm.Contract.DataAvailabilityProtocol(&_Polygonzkevm.CallOpts) +} + +// DataAvailabilityProtocol is a free data retrieval call binding the contract method 0xe57a0b4c. +// +// Solidity: function dataAvailabilityProtocol() view returns(address) +func (_Polygonzkevm *PolygonzkevmCallerSession) DataAvailabilityProtocol() (common.Address, error) { + return _Polygonzkevm.Contract.DataAvailabilityProtocol(&_Polygonzkevm.CallOpts) +} + +// ForceBatchAddress is a free data retrieval call binding the contract method 0x2c111c06. +// +// Solidity: function forceBatchAddress() view returns(address) +func (_Polygonzkevm *PolygonzkevmCaller) ForceBatchAddress(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Polygonzkevm.contract.Call(opts, &out, "forceBatchAddress") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// ForceBatchAddress is a free data retrieval call binding the contract method 0x2c111c06. +// +// Solidity: function forceBatchAddress() view returns(address) +func (_Polygonzkevm *PolygonzkevmSession) ForceBatchAddress() (common.Address, error) { + return _Polygonzkevm.Contract.ForceBatchAddress(&_Polygonzkevm.CallOpts) +} + +// ForceBatchAddress is a free data retrieval call binding the contract method 0x2c111c06. +// +// Solidity: function forceBatchAddress() view returns(address) +func (_Polygonzkevm *PolygonzkevmCallerSession) ForceBatchAddress() (common.Address, error) { + return _Polygonzkevm.Contract.ForceBatchAddress(&_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) +} + +// 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) +} + +// IsSequenceWithDataAvailabilityAllowed is a free data retrieval call binding the contract method 0x4c21fef3. +// +// Solidity: function isSequenceWithDataAvailabilityAllowed() view returns(bool) +func (_Polygonzkevm *PolygonzkevmCaller) IsSequenceWithDataAvailabilityAllowed(opts *bind.CallOpts) (bool, error) { + var out []interface{} + err := _Polygonzkevm.contract.Call(opts, &out, "isSequenceWithDataAvailabilityAllowed") + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// IsSequenceWithDataAvailabilityAllowed is a free data retrieval call binding the contract method 0x4c21fef3. +// +// Solidity: function isSequenceWithDataAvailabilityAllowed() view returns(bool) +func (_Polygonzkevm *PolygonzkevmSession) IsSequenceWithDataAvailabilityAllowed() (bool, error) { + return _Polygonzkevm.Contract.IsSequenceWithDataAvailabilityAllowed(&_Polygonzkevm.CallOpts) +} + +// IsSequenceWithDataAvailabilityAllowed is a free data retrieval call binding the contract method 0x4c21fef3. +// +// Solidity: function isSequenceWithDataAvailabilityAllowed() view returns(bool) +func (_Polygonzkevm *PolygonzkevmCallerSession) IsSequenceWithDataAvailabilityAllowed() (bool, error) { + return _Polygonzkevm.Contract.IsSequenceWithDataAvailabilityAllowed(&_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) +} + +// 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 0xdef57e54. +// +// Solidity: function sequenceBatches((bytes,bytes32,uint64,bytes32)[] batches, uint64 maxSequenceTimestamp, uint64 initSequencedBatch, address l2Coinbase) returns() +func (_Polygonzkevm *PolygonzkevmTransactor) SequenceBatches(opts *bind.TransactOpts, batches []PolygonRollupBaseEtrogBatchData, maxSequenceTimestamp uint64, initSequencedBatch uint64, l2Coinbase common.Address) (*types.Transaction, error) { + return _Polygonzkevm.contract.Transact(opts, "sequenceBatches", batches, maxSequenceTimestamp, initSequencedBatch, l2Coinbase) +} + +// SequenceBatches is a paid mutator transaction binding the contract method 0xdef57e54. +// +// Solidity: function sequenceBatches((bytes,bytes32,uint64,bytes32)[] batches, uint64 maxSequenceTimestamp, uint64 initSequencedBatch, address l2Coinbase) returns() +func (_Polygonzkevm *PolygonzkevmSession) SequenceBatches(batches []PolygonRollupBaseEtrogBatchData, maxSequenceTimestamp uint64, initSequencedBatch uint64, l2Coinbase common.Address) (*types.Transaction, error) { + return _Polygonzkevm.Contract.SequenceBatches(&_Polygonzkevm.TransactOpts, batches, maxSequenceTimestamp, initSequencedBatch, l2Coinbase) +} + +// SequenceBatches is a paid mutator transaction binding the contract method 0xdef57e54. +// +// Solidity: function sequenceBatches((bytes,bytes32,uint64,bytes32)[] batches, uint64 maxSequenceTimestamp, uint64 initSequencedBatch, address l2Coinbase) returns() +func (_Polygonzkevm *PolygonzkevmTransactorSession) SequenceBatches(batches []PolygonRollupBaseEtrogBatchData, maxSequenceTimestamp uint64, initSequencedBatch uint64, l2Coinbase common.Address) (*types.Transaction, error) { + return _Polygonzkevm.Contract.SequenceBatches(&_Polygonzkevm.TransactOpts, batches, maxSequenceTimestamp, initSequencedBatch, l2Coinbase) +} + +// SequenceBatchesValidium is a paid mutator transaction binding the contract method 0xdb5b0ed7. +// +// Solidity: function sequenceBatchesValidium((bytes32,bytes32,uint64,bytes32)[] batches, uint64 maxSequenceTimestamp, uint64 initSequencedBatch, address l2Coinbase, bytes dataAvailabilityMessage) returns() +func (_Polygonzkevm *PolygonzkevmTransactor) SequenceBatchesValidium(opts *bind.TransactOpts, batches []PolygonValidiumEtrogValidiumBatchData, maxSequenceTimestamp uint64, initSequencedBatch uint64, l2Coinbase common.Address, dataAvailabilityMessage []byte) (*types.Transaction, error) { + return _Polygonzkevm.contract.Transact(opts, "sequenceBatchesValidium", batches, maxSequenceTimestamp, initSequencedBatch, l2Coinbase, dataAvailabilityMessage) +} + +// SequenceBatchesValidium is a paid mutator transaction binding the contract method 0xdb5b0ed7. +// +// Solidity: function sequenceBatchesValidium((bytes32,bytes32,uint64,bytes32)[] batches, uint64 maxSequenceTimestamp, uint64 initSequencedBatch, address l2Coinbase, bytes dataAvailabilityMessage) returns() +func (_Polygonzkevm *PolygonzkevmSession) SequenceBatchesValidium(batches []PolygonValidiumEtrogValidiumBatchData, maxSequenceTimestamp uint64, initSequencedBatch uint64, l2Coinbase common.Address, dataAvailabilityMessage []byte) (*types.Transaction, error) { + return _Polygonzkevm.Contract.SequenceBatchesValidium(&_Polygonzkevm.TransactOpts, batches, maxSequenceTimestamp, initSequencedBatch, l2Coinbase, dataAvailabilityMessage) +} + +// SequenceBatchesValidium is a paid mutator transaction binding the contract method 0xdb5b0ed7. +// +// Solidity: function sequenceBatchesValidium((bytes32,bytes32,uint64,bytes32)[] batches, uint64 maxSequenceTimestamp, uint64 initSequencedBatch, address l2Coinbase, bytes dataAvailabilityMessage) returns() +func (_Polygonzkevm *PolygonzkevmTransactorSession) SequenceBatchesValidium(batches []PolygonValidiumEtrogValidiumBatchData, maxSequenceTimestamp uint64, initSequencedBatch uint64, l2Coinbase common.Address, dataAvailabilityMessage []byte) (*types.Transaction, error) { + return _Polygonzkevm.Contract.SequenceBatchesValidium(&_Polygonzkevm.TransactOpts, batches, maxSequenceTimestamp, initSequencedBatch, l2Coinbase, dataAvailabilityMessage) +} + +// 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) +} + +// SetDataAvailabilityProtocol is a paid mutator transaction binding the contract method 0x7cd76b8b. +// +// Solidity: function setDataAvailabilityProtocol(address newDataAvailabilityProtocol) returns() +func (_Polygonzkevm *PolygonzkevmTransactor) SetDataAvailabilityProtocol(opts *bind.TransactOpts, newDataAvailabilityProtocol common.Address) (*types.Transaction, error) { + return _Polygonzkevm.contract.Transact(opts, "setDataAvailabilityProtocol", newDataAvailabilityProtocol) +} + +// SetDataAvailabilityProtocol is a paid mutator transaction binding the contract method 0x7cd76b8b. +// +// Solidity: function setDataAvailabilityProtocol(address newDataAvailabilityProtocol) returns() +func (_Polygonzkevm *PolygonzkevmSession) SetDataAvailabilityProtocol(newDataAvailabilityProtocol common.Address) (*types.Transaction, error) { + return _Polygonzkevm.Contract.SetDataAvailabilityProtocol(&_Polygonzkevm.TransactOpts, newDataAvailabilityProtocol) +} + +// SetDataAvailabilityProtocol is a paid mutator transaction binding the contract method 0x7cd76b8b. +// +// Solidity: function setDataAvailabilityProtocol(address newDataAvailabilityProtocol) returns() +func (_Polygonzkevm *PolygonzkevmTransactorSession) SetDataAvailabilityProtocol(newDataAvailabilityProtocol common.Address) (*types.Transaction, error) { + return _Polygonzkevm.Contract.SetDataAvailabilityProtocol(&_Polygonzkevm.TransactOpts, newDataAvailabilityProtocol) +} + +// SetForceBatchAddress is a paid mutator transaction binding the contract method 0x91cafe32. +// +// Solidity: function setForceBatchAddress(address newForceBatchAddress) returns() +func (_Polygonzkevm *PolygonzkevmTransactor) SetForceBatchAddress(opts *bind.TransactOpts, newForceBatchAddress common.Address) (*types.Transaction, error) { + return _Polygonzkevm.contract.Transact(opts, "setForceBatchAddress", newForceBatchAddress) +} + +// SetForceBatchAddress is a paid mutator transaction binding the contract method 0x91cafe32. +// +// Solidity: function setForceBatchAddress(address newForceBatchAddress) returns() +func (_Polygonzkevm *PolygonzkevmSession) SetForceBatchAddress(newForceBatchAddress common.Address) (*types.Transaction, error) { + return _Polygonzkevm.Contract.SetForceBatchAddress(&_Polygonzkevm.TransactOpts, newForceBatchAddress) +} + +// SetForceBatchAddress is a paid mutator transaction binding the contract method 0x91cafe32. +// +// Solidity: function setForceBatchAddress(address newForceBatchAddress) returns() +func (_Polygonzkevm *PolygonzkevmTransactorSession) SetForceBatchAddress(newForceBatchAddress common.Address) (*types.Transaction, error) { + return _Polygonzkevm.Contract.SetForceBatchAddress(&_Polygonzkevm.TransactOpts, newForceBatchAddress) +} + +// 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) +} + +// SwitchSequenceWithDataAvailability is a paid mutator transaction binding the contract method 0x2acdc2b6. +// +// Solidity: function switchSequenceWithDataAvailability(bool newIsSequenceWithDataAvailabilityAllowed) returns() +func (_Polygonzkevm *PolygonzkevmTransactor) SwitchSequenceWithDataAvailability(opts *bind.TransactOpts, newIsSequenceWithDataAvailabilityAllowed bool) (*types.Transaction, error) { + return _Polygonzkevm.contract.Transact(opts, "switchSequenceWithDataAvailability", newIsSequenceWithDataAvailabilityAllowed) +} + +// SwitchSequenceWithDataAvailability is a paid mutator transaction binding the contract method 0x2acdc2b6. +// +// Solidity: function switchSequenceWithDataAvailability(bool newIsSequenceWithDataAvailabilityAllowed) returns() +func (_Polygonzkevm *PolygonzkevmSession) SwitchSequenceWithDataAvailability(newIsSequenceWithDataAvailabilityAllowed bool) (*types.Transaction, error) { + return _Polygonzkevm.Contract.SwitchSequenceWithDataAvailability(&_Polygonzkevm.TransactOpts, newIsSequenceWithDataAvailabilityAllowed) +} + +// SwitchSequenceWithDataAvailability is a paid mutator transaction binding the contract method 0x2acdc2b6. +// +// Solidity: function switchSequenceWithDataAvailability(bool newIsSequenceWithDataAvailabilityAllowed) returns() +func (_Polygonzkevm *PolygonzkevmTransactorSession) SwitchSequenceWithDataAvailability(newIsSequenceWithDataAvailabilityAllowed bool) (*types.Transaction, error) { + return _Polygonzkevm.Contract.SwitchSequenceWithDataAvailability(&_Polygonzkevm.TransactOpts, newIsSequenceWithDataAvailabilityAllowed) +} + +// 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 +} + +// 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 +} + +// PolygonzkevmSetDataAvailabilityProtocolIterator is returned from FilterSetDataAvailabilityProtocol and is used to iterate over the raw logs and unpacked data for SetDataAvailabilityProtocol events raised by the Polygonzkevm contract. +type PolygonzkevmSetDataAvailabilityProtocolIterator struct { + Event *PolygonzkevmSetDataAvailabilityProtocol // 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 *PolygonzkevmSetDataAvailabilityProtocolIterator) 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(PolygonzkevmSetDataAvailabilityProtocol) + 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(PolygonzkevmSetDataAvailabilityProtocol) + 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 *PolygonzkevmSetDataAvailabilityProtocolIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolygonzkevmSetDataAvailabilityProtocolIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolygonzkevmSetDataAvailabilityProtocol represents a SetDataAvailabilityProtocol event raised by the Polygonzkevm contract. +type PolygonzkevmSetDataAvailabilityProtocol struct { + NewDataAvailabilityProtocol common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterSetDataAvailabilityProtocol is a free log retrieval operation binding the contract event 0xd331bd4c4cd1afecb94a225184bded161ff3213624ba4fb58c4f30c5a861144a. +// +// Solidity: event SetDataAvailabilityProtocol(address newDataAvailabilityProtocol) +func (_Polygonzkevm *PolygonzkevmFilterer) FilterSetDataAvailabilityProtocol(opts *bind.FilterOpts) (*PolygonzkevmSetDataAvailabilityProtocolIterator, error) { + + logs, sub, err := _Polygonzkevm.contract.FilterLogs(opts, "SetDataAvailabilityProtocol") + if err != nil { + return nil, err + } + return &PolygonzkevmSetDataAvailabilityProtocolIterator{contract: _Polygonzkevm.contract, event: "SetDataAvailabilityProtocol", logs: logs, sub: sub}, nil +} + +// WatchSetDataAvailabilityProtocol is a free log subscription operation binding the contract event 0xd331bd4c4cd1afecb94a225184bded161ff3213624ba4fb58c4f30c5a861144a. +// +// Solidity: event SetDataAvailabilityProtocol(address newDataAvailabilityProtocol) +func (_Polygonzkevm *PolygonzkevmFilterer) WatchSetDataAvailabilityProtocol(opts *bind.WatchOpts, sink chan<- *PolygonzkevmSetDataAvailabilityProtocol) (event.Subscription, error) { + + logs, sub, err := _Polygonzkevm.contract.WatchLogs(opts, "SetDataAvailabilityProtocol") + 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(PolygonzkevmSetDataAvailabilityProtocol) + if err := _Polygonzkevm.contract.UnpackLog(event, "SetDataAvailabilityProtocol", 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 +} + +// ParseSetDataAvailabilityProtocol is a log parse operation binding the contract event 0xd331bd4c4cd1afecb94a225184bded161ff3213624ba4fb58c4f30c5a861144a. +// +// Solidity: event SetDataAvailabilityProtocol(address newDataAvailabilityProtocol) +func (_Polygonzkevm *PolygonzkevmFilterer) ParseSetDataAvailabilityProtocol(log types.Log) (*PolygonzkevmSetDataAvailabilityProtocol, error) { + event := new(PolygonzkevmSetDataAvailabilityProtocol) + if err := _Polygonzkevm.contract.UnpackLog(event, "SetDataAvailabilityProtocol", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// PolygonzkevmSetForceBatchAddressIterator is returned from FilterSetForceBatchAddress and is used to iterate over the raw logs and unpacked data for SetForceBatchAddress events raised by the Polygonzkevm contract. +type PolygonzkevmSetForceBatchAddressIterator struct { + Event *PolygonzkevmSetForceBatchAddress // 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 *PolygonzkevmSetForceBatchAddressIterator) 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(PolygonzkevmSetForceBatchAddress) + 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(PolygonzkevmSetForceBatchAddress) + 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 *PolygonzkevmSetForceBatchAddressIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolygonzkevmSetForceBatchAddressIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolygonzkevmSetForceBatchAddress represents a SetForceBatchAddress event raised by the Polygonzkevm contract. +type PolygonzkevmSetForceBatchAddress struct { + NewForceBatchAddress common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterSetForceBatchAddress is a free log retrieval operation binding the contract event 0x5fbd7dd171301c4a1611a84aac4ba86d119478560557755f7927595b082634fb. +// +// Solidity: event SetForceBatchAddress(address newForceBatchAddress) +func (_Polygonzkevm *PolygonzkevmFilterer) FilterSetForceBatchAddress(opts *bind.FilterOpts) (*PolygonzkevmSetForceBatchAddressIterator, error) { + + logs, sub, err := _Polygonzkevm.contract.FilterLogs(opts, "SetForceBatchAddress") + if err != nil { + return nil, err + } + return &PolygonzkevmSetForceBatchAddressIterator{contract: _Polygonzkevm.contract, event: "SetForceBatchAddress", logs: logs, sub: sub}, nil +} + +// WatchSetForceBatchAddress is a free log subscription operation binding the contract event 0x5fbd7dd171301c4a1611a84aac4ba86d119478560557755f7927595b082634fb. +// +// Solidity: event SetForceBatchAddress(address newForceBatchAddress) +func (_Polygonzkevm *PolygonzkevmFilterer) WatchSetForceBatchAddress(opts *bind.WatchOpts, sink chan<- *PolygonzkevmSetForceBatchAddress) (event.Subscription, error) { + + logs, sub, err := _Polygonzkevm.contract.WatchLogs(opts, "SetForceBatchAddress") + 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(PolygonzkevmSetForceBatchAddress) + if err := _Polygonzkevm.contract.UnpackLog(event, "SetForceBatchAddress", 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 +} + +// ParseSetForceBatchAddress is a log parse operation binding the contract event 0x5fbd7dd171301c4a1611a84aac4ba86d119478560557755f7927595b082634fb. +// +// Solidity: event SetForceBatchAddress(address newForceBatchAddress) +func (_Polygonzkevm *PolygonzkevmFilterer) ParseSetForceBatchAddress(log types.Log) (*PolygonzkevmSetForceBatchAddress, error) { + event := new(PolygonzkevmSetForceBatchAddress) + if err := _Polygonzkevm.contract.UnpackLog(event, "SetForceBatchAddress", 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 +} + +// PolygonzkevmSwitchSequenceWithDataAvailabilityIterator is returned from FilterSwitchSequenceWithDataAvailability and is used to iterate over the raw logs and unpacked data for SwitchSequenceWithDataAvailability events raised by the Polygonzkevm contract. +type PolygonzkevmSwitchSequenceWithDataAvailabilityIterator struct { + Event *PolygonzkevmSwitchSequenceWithDataAvailability // 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 *PolygonzkevmSwitchSequenceWithDataAvailabilityIterator) 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(PolygonzkevmSwitchSequenceWithDataAvailability) + 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(PolygonzkevmSwitchSequenceWithDataAvailability) + 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 *PolygonzkevmSwitchSequenceWithDataAvailabilityIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PolygonzkevmSwitchSequenceWithDataAvailabilityIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PolygonzkevmSwitchSequenceWithDataAvailability represents a SwitchSequenceWithDataAvailability event raised by the Polygonzkevm contract. +type PolygonzkevmSwitchSequenceWithDataAvailability struct { + Raw types.Log // Blockchain specific contextual infos +} + +// FilterSwitchSequenceWithDataAvailability is a free log retrieval operation binding the contract event 0xf32a0473f809a720a4f8af1e50d353f1caf7452030626fdaac4273f5e6587f41. +// +// Solidity: event SwitchSequenceWithDataAvailability() +func (_Polygonzkevm *PolygonzkevmFilterer) FilterSwitchSequenceWithDataAvailability(opts *bind.FilterOpts) (*PolygonzkevmSwitchSequenceWithDataAvailabilityIterator, error) { + + logs, sub, err := _Polygonzkevm.contract.FilterLogs(opts, "SwitchSequenceWithDataAvailability") + if err != nil { + return nil, err + } + return &PolygonzkevmSwitchSequenceWithDataAvailabilityIterator{contract: _Polygonzkevm.contract, event: "SwitchSequenceWithDataAvailability", logs: logs, sub: sub}, nil +} + +// WatchSwitchSequenceWithDataAvailability is a free log subscription operation binding the contract event 0xf32a0473f809a720a4f8af1e50d353f1caf7452030626fdaac4273f5e6587f41. +// +// Solidity: event SwitchSequenceWithDataAvailability() +func (_Polygonzkevm *PolygonzkevmFilterer) WatchSwitchSequenceWithDataAvailability(opts *bind.WatchOpts, sink chan<- *PolygonzkevmSwitchSequenceWithDataAvailability) (event.Subscription, error) { + + logs, sub, err := _Polygonzkevm.contract.WatchLogs(opts, "SwitchSequenceWithDataAvailability") + 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(PolygonzkevmSwitchSequenceWithDataAvailability) + if err := _Polygonzkevm.contract.UnpackLog(event, "SwitchSequenceWithDataAvailability", 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 +} + +// ParseSwitchSequenceWithDataAvailability is a log parse operation binding the contract event 0xf32a0473f809a720a4f8af1e50d353f1caf7452030626fdaac4273f5e6587f41. +// +// Solidity: event SwitchSequenceWithDataAvailability() +func (_Polygonzkevm *PolygonzkevmFilterer) ParseSwitchSequenceWithDataAvailability(log types.Log) (*PolygonzkevmSwitchSequenceWithDataAvailability, error) { + event := new(PolygonzkevmSwitchSequenceWithDataAvailability) + if err := _Polygonzkevm.contract.UnpackLog(event, "SwitchSequenceWithDataAvailability", 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 00000000..bc68037e --- /dev/null +++ b/etherman/smartcontracts/polygonzkevmbridge/polygonzkevmbridge.go @@ -0,0 +1,1935 @@ +// 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\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"AlreadyClaimed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"AmountDoesNotMatchMsgValue\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DestinationNetworkInvalid\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"EtherTransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FailedTokenWrappedDeployment\",\"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\":\"BASE_INIT_BYTECODE_WRAPPED_TOKEN\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"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...) +} + +// BASEINITBYTECODEWRAPPEDTOKEN is a free data retrieval call binding the contract method 0x83c43a55. +// +// Solidity: function BASE_INIT_BYTECODE_WRAPPED_TOKEN() view returns(bytes) +func (_Polygonzkevmbridge *PolygonzkevmbridgeCaller) BASEINITBYTECODEWRAPPEDTOKEN(opts *bind.CallOpts) ([]byte, error) { + var out []interface{} + err := _Polygonzkevmbridge.contract.Call(opts, &out, "BASE_INIT_BYTECODE_WRAPPED_TOKEN") + + if err != nil { + return *new([]byte), err + } + + out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte) + + return out0, err + +} + +// BASEINITBYTECODEWRAPPEDTOKEN is a free data retrieval call binding the contract method 0x83c43a55. +// +// Solidity: function BASE_INIT_BYTECODE_WRAPPED_TOKEN() view returns(bytes) +func (_Polygonzkevmbridge *PolygonzkevmbridgeSession) BASEINITBYTECODEWRAPPEDTOKEN() ([]byte, error) { + return _Polygonzkevmbridge.Contract.BASEINITBYTECODEWRAPPEDTOKEN(&_Polygonzkevmbridge.CallOpts) +} + +// BASEINITBYTECODEWRAPPEDTOKEN is a free data retrieval call binding the contract method 0x83c43a55. +// +// Solidity: function BASE_INIT_BYTECODE_WRAPPED_TOKEN() view returns(bytes) +func (_Polygonzkevmbridge *PolygonzkevmbridgeCallerSession) BASEINITBYTECODEWRAPPEDTOKEN() ([]byte, error) { + return _Polygonzkevmbridge.Contract.BASEINITBYTECODEWRAPPEDTOKEN(&_Polygonzkevmbridge.CallOpts) +} + +// 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 00000000..12d6dd50 --- /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: "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", +} + +// 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/proxy/proxy.go b/etherman/smartcontracts/proxy/proxy.go new file mode 100644 index 00000000..6e7d3572 --- /dev/null +++ b/etherman/smartcontracts/proxy/proxy.go @@ -0,0 +1,773 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package proxy + +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 +) + +// ProxyMetaData contains all meta data concerning the Proxy contract. +var ProxyMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_logic\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"admin_\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"_data\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"inputs\":[],\"name\":\"admin\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"admin_\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"changeAdmin\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"implementation\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"implementation_\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}]", + Bin: "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", +} + +// ProxyABI is the input ABI used to generate the binding from. +// Deprecated: Use ProxyMetaData.ABI instead. +var ProxyABI = ProxyMetaData.ABI + +// ProxyBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use ProxyMetaData.Bin instead. +var ProxyBin = ProxyMetaData.Bin + +// DeployProxy deploys a new Ethereum contract, binding an instance of Proxy to it. +func DeployProxy(auth *bind.TransactOpts, backend bind.ContractBackend, _logic common.Address, admin_ common.Address, _data []byte) (common.Address, *types.Transaction, *Proxy, error) { + parsed, err := ProxyMetaData.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(ProxyBin), backend, _logic, admin_, _data) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &Proxy{ProxyCaller: ProxyCaller{contract: contract}, ProxyTransactor: ProxyTransactor{contract: contract}, ProxyFilterer: ProxyFilterer{contract: contract}}, nil +} + +// Proxy is an auto generated Go binding around an Ethereum contract. +type Proxy struct { + ProxyCaller // Read-only binding to the contract + ProxyTransactor // Write-only binding to the contract + ProxyFilterer // Log filterer for contract events +} + +// ProxyCaller is an auto generated read-only Go binding around an Ethereum contract. +type ProxyCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ProxyTransactor is an auto generated write-only Go binding around an Ethereum contract. +type ProxyTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ProxyFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type ProxyFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ProxySession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type ProxySession struct { + Contract *Proxy // 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 +} + +// ProxyCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type ProxyCallerSession struct { + Contract *ProxyCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// ProxyTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type ProxyTransactorSession struct { + Contract *ProxyTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ProxyRaw is an auto generated low-level Go binding around an Ethereum contract. +type ProxyRaw struct { + Contract *Proxy // Generic contract binding to access the raw methods on +} + +// ProxyCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type ProxyCallerRaw struct { + Contract *ProxyCaller // Generic read-only contract binding to access the raw methods on +} + +// ProxyTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type ProxyTransactorRaw struct { + Contract *ProxyTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewProxy creates a new instance of Proxy, bound to a specific deployed contract. +func NewProxy(address common.Address, backend bind.ContractBackend) (*Proxy, error) { + contract, err := bindProxy(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &Proxy{ProxyCaller: ProxyCaller{contract: contract}, ProxyTransactor: ProxyTransactor{contract: contract}, ProxyFilterer: ProxyFilterer{contract: contract}}, nil +} + +// NewProxyCaller creates a new read-only instance of Proxy, bound to a specific deployed contract. +func NewProxyCaller(address common.Address, caller bind.ContractCaller) (*ProxyCaller, error) { + contract, err := bindProxy(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &ProxyCaller{contract: contract}, nil +} + +// NewProxyTransactor creates a new write-only instance of Proxy, bound to a specific deployed contract. +func NewProxyTransactor(address common.Address, transactor bind.ContractTransactor) (*ProxyTransactor, error) { + contract, err := bindProxy(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &ProxyTransactor{contract: contract}, nil +} + +// NewProxyFilterer creates a new log filterer instance of Proxy, bound to a specific deployed contract. +func NewProxyFilterer(address common.Address, filterer bind.ContractFilterer) (*ProxyFilterer, error) { + contract, err := bindProxy(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &ProxyFilterer{contract: contract}, nil +} + +// bindProxy binds a generic wrapper to an already deployed contract. +func bindProxy(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := ProxyMetaData.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 (_Proxy *ProxyRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Proxy.Contract.ProxyCaller.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 (_Proxy *ProxyRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Proxy.Contract.ProxyTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Proxy *ProxyRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Proxy.Contract.ProxyTransactor.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 (_Proxy *ProxyCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Proxy.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 (_Proxy *ProxyTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Proxy.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Proxy *ProxyTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Proxy.Contract.contract.Transact(opts, method, params...) +} + +// Admin is a paid mutator transaction binding the contract method 0xf851a440. +// +// Solidity: function admin() returns(address admin_) +func (_Proxy *ProxyTransactor) Admin(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Proxy.contract.Transact(opts, "admin") +} + +// Admin is a paid mutator transaction binding the contract method 0xf851a440. +// +// Solidity: function admin() returns(address admin_) +func (_Proxy *ProxySession) Admin() (*types.Transaction, error) { + return _Proxy.Contract.Admin(&_Proxy.TransactOpts) +} + +// Admin is a paid mutator transaction binding the contract method 0xf851a440. +// +// Solidity: function admin() returns(address admin_) +func (_Proxy *ProxyTransactorSession) Admin() (*types.Transaction, error) { + return _Proxy.Contract.Admin(&_Proxy.TransactOpts) +} + +// ChangeAdmin is a paid mutator transaction binding the contract method 0x8f283970. +// +// Solidity: function changeAdmin(address newAdmin) returns() +func (_Proxy *ProxyTransactor) ChangeAdmin(opts *bind.TransactOpts, newAdmin common.Address) (*types.Transaction, error) { + return _Proxy.contract.Transact(opts, "changeAdmin", newAdmin) +} + +// ChangeAdmin is a paid mutator transaction binding the contract method 0x8f283970. +// +// Solidity: function changeAdmin(address newAdmin) returns() +func (_Proxy *ProxySession) ChangeAdmin(newAdmin common.Address) (*types.Transaction, error) { + return _Proxy.Contract.ChangeAdmin(&_Proxy.TransactOpts, newAdmin) +} + +// ChangeAdmin is a paid mutator transaction binding the contract method 0x8f283970. +// +// Solidity: function changeAdmin(address newAdmin) returns() +func (_Proxy *ProxyTransactorSession) ChangeAdmin(newAdmin common.Address) (*types.Transaction, error) { + return _Proxy.Contract.ChangeAdmin(&_Proxy.TransactOpts, newAdmin) +} + +// Implementation is a paid mutator transaction binding the contract method 0x5c60da1b. +// +// Solidity: function implementation() returns(address implementation_) +func (_Proxy *ProxyTransactor) Implementation(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Proxy.contract.Transact(opts, "implementation") +} + +// Implementation is a paid mutator transaction binding the contract method 0x5c60da1b. +// +// Solidity: function implementation() returns(address implementation_) +func (_Proxy *ProxySession) Implementation() (*types.Transaction, error) { + return _Proxy.Contract.Implementation(&_Proxy.TransactOpts) +} + +// Implementation is a paid mutator transaction binding the contract method 0x5c60da1b. +// +// Solidity: function implementation() returns(address implementation_) +func (_Proxy *ProxyTransactorSession) Implementation() (*types.Transaction, error) { + return _Proxy.Contract.Implementation(&_Proxy.TransactOpts) +} + +// UpgradeTo is a paid mutator transaction binding the contract method 0x3659cfe6. +// +// Solidity: function upgradeTo(address newImplementation) returns() +func (_Proxy *ProxyTransactor) UpgradeTo(opts *bind.TransactOpts, newImplementation common.Address) (*types.Transaction, error) { + return _Proxy.contract.Transact(opts, "upgradeTo", newImplementation) +} + +// UpgradeTo is a paid mutator transaction binding the contract method 0x3659cfe6. +// +// Solidity: function upgradeTo(address newImplementation) returns() +func (_Proxy *ProxySession) UpgradeTo(newImplementation common.Address) (*types.Transaction, error) { + return _Proxy.Contract.UpgradeTo(&_Proxy.TransactOpts, newImplementation) +} + +// UpgradeTo is a paid mutator transaction binding the contract method 0x3659cfe6. +// +// Solidity: function upgradeTo(address newImplementation) returns() +func (_Proxy *ProxyTransactorSession) UpgradeTo(newImplementation common.Address) (*types.Transaction, error) { + return _Proxy.Contract.UpgradeTo(&_Proxy.TransactOpts, newImplementation) +} + +// UpgradeToAndCall is a paid mutator transaction binding the contract method 0x4f1ef286. +// +// Solidity: function upgradeToAndCall(address newImplementation, bytes data) payable returns() +func (_Proxy *ProxyTransactor) UpgradeToAndCall(opts *bind.TransactOpts, newImplementation common.Address, data []byte) (*types.Transaction, error) { + return _Proxy.contract.Transact(opts, "upgradeToAndCall", newImplementation, data) +} + +// UpgradeToAndCall is a paid mutator transaction binding the contract method 0x4f1ef286. +// +// Solidity: function upgradeToAndCall(address newImplementation, bytes data) payable returns() +func (_Proxy *ProxySession) UpgradeToAndCall(newImplementation common.Address, data []byte) (*types.Transaction, error) { + return _Proxy.Contract.UpgradeToAndCall(&_Proxy.TransactOpts, newImplementation, data) +} + +// UpgradeToAndCall is a paid mutator transaction binding the contract method 0x4f1ef286. +// +// Solidity: function upgradeToAndCall(address newImplementation, bytes data) payable returns() +func (_Proxy *ProxyTransactorSession) UpgradeToAndCall(newImplementation common.Address, data []byte) (*types.Transaction, error) { + return _Proxy.Contract.UpgradeToAndCall(&_Proxy.TransactOpts, newImplementation, data) +} + +// Fallback is a paid mutator transaction binding the contract fallback function. +// +// Solidity: fallback() payable returns() +func (_Proxy *ProxyTransactor) Fallback(opts *bind.TransactOpts, calldata []byte) (*types.Transaction, error) { + return _Proxy.contract.RawTransact(opts, calldata) +} + +// Fallback is a paid mutator transaction binding the contract fallback function. +// +// Solidity: fallback() payable returns() +func (_Proxy *ProxySession) Fallback(calldata []byte) (*types.Transaction, error) { + return _Proxy.Contract.Fallback(&_Proxy.TransactOpts, calldata) +} + +// Fallback is a paid mutator transaction binding the contract fallback function. +// +// Solidity: fallback() payable returns() +func (_Proxy *ProxyTransactorSession) Fallback(calldata []byte) (*types.Transaction, error) { + return _Proxy.Contract.Fallback(&_Proxy.TransactOpts, calldata) +} + +// Receive is a paid mutator transaction binding the contract receive function. +// +// Solidity: receive() payable returns() +func (_Proxy *ProxyTransactor) Receive(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Proxy.contract.RawTransact(opts, nil) // calldata is disallowed for receive function +} + +// Receive is a paid mutator transaction binding the contract receive function. +// +// Solidity: receive() payable returns() +func (_Proxy *ProxySession) Receive() (*types.Transaction, error) { + return _Proxy.Contract.Receive(&_Proxy.TransactOpts) +} + +// Receive is a paid mutator transaction binding the contract receive function. +// +// Solidity: receive() payable returns() +func (_Proxy *ProxyTransactorSession) Receive() (*types.Transaction, error) { + return _Proxy.Contract.Receive(&_Proxy.TransactOpts) +} + +// ProxyAdminChangedIterator is returned from FilterAdminChanged and is used to iterate over the raw logs and unpacked data for AdminChanged events raised by the Proxy contract. +type ProxyAdminChangedIterator struct { + Event *ProxyAdminChanged // 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 *ProxyAdminChangedIterator) 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(ProxyAdminChanged) + 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(ProxyAdminChanged) + 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 *ProxyAdminChangedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ProxyAdminChangedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ProxyAdminChanged represents a AdminChanged event raised by the Proxy contract. +type ProxyAdminChanged struct { + PreviousAdmin common.Address + NewAdmin common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterAdminChanged is a free log retrieval operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f. +// +// Solidity: event AdminChanged(address previousAdmin, address newAdmin) +func (_Proxy *ProxyFilterer) FilterAdminChanged(opts *bind.FilterOpts) (*ProxyAdminChangedIterator, error) { + + logs, sub, err := _Proxy.contract.FilterLogs(opts, "AdminChanged") + if err != nil { + return nil, err + } + return &ProxyAdminChangedIterator{contract: _Proxy.contract, event: "AdminChanged", logs: logs, sub: sub}, nil +} + +// WatchAdminChanged is a free log subscription operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f. +// +// Solidity: event AdminChanged(address previousAdmin, address newAdmin) +func (_Proxy *ProxyFilterer) WatchAdminChanged(opts *bind.WatchOpts, sink chan<- *ProxyAdminChanged) (event.Subscription, error) { + + logs, sub, err := _Proxy.contract.WatchLogs(opts, "AdminChanged") + 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(ProxyAdminChanged) + if err := _Proxy.contract.UnpackLog(event, "AdminChanged", 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 +} + +// ParseAdminChanged is a log parse operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f. +// +// Solidity: event AdminChanged(address previousAdmin, address newAdmin) +func (_Proxy *ProxyFilterer) ParseAdminChanged(log types.Log) (*ProxyAdminChanged, error) { + event := new(ProxyAdminChanged) + if err := _Proxy.contract.UnpackLog(event, "AdminChanged", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ProxyBeaconUpgradedIterator is returned from FilterBeaconUpgraded and is used to iterate over the raw logs and unpacked data for BeaconUpgraded events raised by the Proxy contract. +type ProxyBeaconUpgradedIterator struct { + Event *ProxyBeaconUpgraded // 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 *ProxyBeaconUpgradedIterator) 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(ProxyBeaconUpgraded) + 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(ProxyBeaconUpgraded) + 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 *ProxyBeaconUpgradedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ProxyBeaconUpgradedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ProxyBeaconUpgraded represents a BeaconUpgraded event raised by the Proxy contract. +type ProxyBeaconUpgraded struct { + Beacon common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterBeaconUpgraded is a free log retrieval operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e. +// +// Solidity: event BeaconUpgraded(address indexed beacon) +func (_Proxy *ProxyFilterer) FilterBeaconUpgraded(opts *bind.FilterOpts, beacon []common.Address) (*ProxyBeaconUpgradedIterator, error) { + + var beaconRule []interface{} + for _, beaconItem := range beacon { + beaconRule = append(beaconRule, beaconItem) + } + + logs, sub, err := _Proxy.contract.FilterLogs(opts, "BeaconUpgraded", beaconRule) + if err != nil { + return nil, err + } + return &ProxyBeaconUpgradedIterator{contract: _Proxy.contract, event: "BeaconUpgraded", logs: logs, sub: sub}, nil +} + +// WatchBeaconUpgraded is a free log subscription operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e. +// +// Solidity: event BeaconUpgraded(address indexed beacon) +func (_Proxy *ProxyFilterer) WatchBeaconUpgraded(opts *bind.WatchOpts, sink chan<- *ProxyBeaconUpgraded, beacon []common.Address) (event.Subscription, error) { + + var beaconRule []interface{} + for _, beaconItem := range beacon { + beaconRule = append(beaconRule, beaconItem) + } + + logs, sub, err := _Proxy.contract.WatchLogs(opts, "BeaconUpgraded", beaconRule) + 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(ProxyBeaconUpgraded) + if err := _Proxy.contract.UnpackLog(event, "BeaconUpgraded", 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 +} + +// ParseBeaconUpgraded is a log parse operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e. +// +// Solidity: event BeaconUpgraded(address indexed beacon) +func (_Proxy *ProxyFilterer) ParseBeaconUpgraded(log types.Log) (*ProxyBeaconUpgraded, error) { + event := new(ProxyBeaconUpgraded) + if err := _Proxy.contract.UnpackLog(event, "BeaconUpgraded", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ProxyUpgradedIterator is returned from FilterUpgraded and is used to iterate over the raw logs and unpacked data for Upgraded events raised by the Proxy contract. +type ProxyUpgradedIterator struct { + Event *ProxyUpgraded // 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 *ProxyUpgradedIterator) 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(ProxyUpgraded) + 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(ProxyUpgraded) + 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 *ProxyUpgradedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ProxyUpgradedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ProxyUpgraded represents a Upgraded event raised by the Proxy contract. +type ProxyUpgraded struct { + Implementation common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterUpgraded is a free log retrieval operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. +// +// Solidity: event Upgraded(address indexed implementation) +func (_Proxy *ProxyFilterer) FilterUpgraded(opts *bind.FilterOpts, implementation []common.Address) (*ProxyUpgradedIterator, error) { + + var implementationRule []interface{} + for _, implementationItem := range implementation { + implementationRule = append(implementationRule, implementationItem) + } + + logs, sub, err := _Proxy.contract.FilterLogs(opts, "Upgraded", implementationRule) + if err != nil { + return nil, err + } + return &ProxyUpgradedIterator{contract: _Proxy.contract, event: "Upgraded", logs: logs, sub: sub}, nil +} + +// WatchUpgraded is a free log subscription operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. +// +// Solidity: event Upgraded(address indexed implementation) +func (_Proxy *ProxyFilterer) WatchUpgraded(opts *bind.WatchOpts, sink chan<- *ProxyUpgraded, implementation []common.Address) (event.Subscription, error) { + + var implementationRule []interface{} + for _, implementationItem := range implementation { + implementationRule = append(implementationRule, implementationItem) + } + + logs, sub, err := _Proxy.contract.WatchLogs(opts, "Upgraded", implementationRule) + 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(ProxyUpgraded) + if err := _Proxy.contract.UnpackLog(event, "Upgraded", 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 +} + +// ParseUpgraded is a log parse operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. +// +// Solidity: event Upgraded(address indexed implementation) +func (_Proxy *ProxyFilterer) ParseUpgraded(log types.Log) (*ProxyUpgraded, error) { + event := new(ProxyUpgraded) + if err := _Proxy.contract.UnpackLog(event, "Upgraded", 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 00000000..7666d87e --- /dev/null +++ b/etherman/smartcontracts/script.sh @@ -0,0 +1,30 @@ +#!/bin/sh + +set -e + +gen() { + local package=$1 + + abigen --bin bin/${package}.bin --abi abi/${package}.abi --pkg=${package} --out=${package}/${package}.go +} + +genNoBin() { + local package=$1 + + abigen --abi abi/${package}.abi --pkg=${package} --out=${package}/${package}.go +} + +gen oldpolygonzkevmglobalexitroot +gen oldpolygonzkevmbridge +gen oldpolygonzkevm +gen etrogpolygonzkevm +gen polygonzkevm +gen polygonzkevmbridge +gen pol +gen polygonzkevmglobalexitroot +gen polygonrollupmanager +gen mockpolygonrollupmanager +gen mockverifier +gen polygondatacommittee +genNoBin dataavailabilityprotocol +gen proxy \ No newline at end of file diff --git a/etherman/types.go b/etherman/types.go new file mode 100644 index 00000000..154afd04 --- /dev/null +++ b/etherman/types.go @@ -0,0 +1,84 @@ +package etherman + +import ( + "time" + + "github.com/0xPolygon/cdk/etherman/smartcontracts/oldpolygonzkevm" + "github.com/0xPolygon/cdk/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 00000000..de5829a0 --- /dev/null +++ b/etherman/types/finalproofinputs.go @@ -0,0 +1,10 @@ +package types + +import "github.com/0xPolygon/cdk/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 00000000..5a27fa05 --- /dev/null +++ b/etherman/types/sequence.go @@ -0,0 +1,26 @@ +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 + LastL2BLockTimestamp uint64 + BatchL2Data []byte + IsSequenceTooBig bool + BatchNumber uint64 + ForcedBatchTimestamp int64 + PrevBlockHash common.Hash + LastCoinbase common.Address +} + +// IsEmpty checks is sequence struct is empty +func (s Sequence) IsEmpty() bool { + return reflect.DeepEqual(s, Sequence{}) +} diff --git a/go.mod b/go.mod index c90ef606..3705da7a 100644 --- a/go.mod +++ b/go.mod @@ -1,3 +1,146 @@ module github.com/0xPolygon/cdk -go 1.22 +go 1.22.4 + +require ( + github.com/0xPolygon/cdk-data-availability v0.0.7 + github.com/0xPolygon/cdk-rpc v0.0.0-20240419104226-c0a62ba0f49d + github.com/0xPolygonHermez/zkevm-data-streamer v0.2.2 + github.com/0xPolygonHermez/zkevm-ethtx-manager v0.1.9 + github.com/0xPolygonHermez/zkevm-sequence-sender v0.1.3 + github.com/0xPolygonHermez/zkevm-synchronizer-l1 v0.6.1 + github.com/ethereum/go-ethereum v1.14.5 + github.com/gobuffalo/packr/v2 v2.8.3 + github.com/hermeznetwork/tracerr v0.3.2 + github.com/iden3/go-iden3-crypto v0.0.16 + github.com/invopop/jsonschema v0.12.0 + github.com/jackc/pgconn v1.14.3 + github.com/jackc/pgx/v4 v4.18.3 + github.com/mitchellh/mapstructure v1.5.0 + github.com/prometheus/client_golang v1.19.1 + github.com/prometheus/client_model v0.6.1 + github.com/rubenv/sql-migrate v1.6.1 + github.com/spf13/viper v1.19.0 + github.com/stretchr/testify v1.9.0 + github.com/urfave/cli/v2 v2.27.2 + go.uber.org/zap v1.27.0 + golang.org/x/crypto v0.24.0 + golang.org/x/net v0.26.0 + google.golang.org/grpc v1.64.0 + google.golang.org/protobuf v1.34.2 +) + +require ( + github.com/DataDog/zstd v1.5.2 // indirect + github.com/Microsoft/go-winio v0.6.2 // indirect + github.com/StackExchange/wmi v1.2.1 // indirect + github.com/VictoriaMetrics/fastcache v1.12.2 // 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.3.0 // indirect + github.com/cockroachdb/errors v1.11.1 // indirect + github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b // indirect + github.com/cockroachdb/pebble v1.1.0 // indirect + github.com/cockroachdb/redact v1.1.5 // 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.4 // indirect + github.com/crate-crypto/go-ipa v0.0.0-20240223125850-b1e8a79f509c // indirect + github.com/crate-crypto/go-kzg-4844 v1.0.0 // indirect + github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect + github.com/deckarep/golang-set/v2 v2.6.0 // indirect + github.com/decred/dcrd/dcrec/secp256k1/v4 v4.1.0 // indirect + github.com/didip/tollbooth/v6 v6.1.2 // indirect + github.com/ethereum/c-kzg-4844 v1.0.0 // indirect + github.com/ethereum/go-verkle v0.1.1-0.20240306133620-7d920df305f0 // indirect + github.com/fjl/memsize v0.0.2 // indirect + github.com/fsnotify/fsnotify v1.7.0 // indirect + github.com/gballet/go-libpcsclite v0.0.0-20191108122812-4678299bea08 // 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.3.0 // indirect + github.com/go-pkgz/expirable-cache v0.0.3 // 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-jwt/jwt/v4 v4.5.0 // indirect + github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb // indirect + github.com/google/uuid v1.6.0 // indirect + github.com/gorilla/websocket v1.5.1 // indirect + github.com/hashicorp/go-bexpr v0.1.10 // indirect + github.com/hashicorp/hcl v1.0.1-0.20180906183839-65a6292f0157 // indirect + github.com/holiman/billy v0.0.0-20240216141850-2abb0c79d3c4 // indirect + github.com/holiman/bloomfilter/v2 v2.0.3 // indirect + github.com/holiman/uint256 v1.2.4 // indirect + github.com/huin/goupnp v1.3.0 // 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.3 // 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/jackpal/go-nat-pmp v1.0.2 // indirect + github.com/jmoiron/sqlx v1.2.0 // indirect + github.com/karrick/godirwalk v1.17.0 // indirect + github.com/klauspost/compress v1.17.2 // indirect + github.com/kr/pretty v0.3.1 // indirect + github.com/kr/text v0.2.0 // indirect + github.com/logrusorgru/aurora v2.0.3+incompatible // 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-colorable v0.1.13 // indirect + github.com/mattn/go-isatty v0.0.20 // indirect + github.com/mattn/go-runewidth v0.0.13 // indirect + github.com/miguelmota/go-solidity-sha3 v0.1.1 // indirect + github.com/mitchellh/pointerstructure v1.2.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.2.2 // 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.48.0 // indirect + github.com/prometheus/procfs v0.12.0 // indirect + github.com/rivo/uniseg v0.2.0 // indirect + github.com/rogpeppe/go-internal v1.11.0 // indirect + github.com/rs/cors v1.7.0 // indirect + github.com/russross/blackfriday/v2 v2.1.0 // indirect + github.com/sagikazarmark/locafero v0.4.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.3 // indirect + github.com/sourcegraph/conc v0.3.0 // indirect + github.com/spf13/afero v1.11.0 // indirect + github.com/spf13/cast v1.6.0 // indirect + github.com/spf13/pflag v1.0.5 // indirect + github.com/status-im/keycard-go v0.2.0 // indirect + github.com/stretchr/objx v0.5.2 // 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/tyler-smith/go-bip39 v1.1.0 // indirect + github.com/wk8/go-ordered-map/v2 v2.1.8 // indirect + github.com/xrash/smetrics v0.0.0-20240312152122-5f08fbb34913 // indirect + go.uber.org/multierr v1.10.0 // indirect + golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa // indirect + golang.org/x/sync v0.7.0 // indirect + golang.org/x/sys v0.21.0 // indirect + golang.org/x/term v0.21.0 // indirect + golang.org/x/text v0.16.0 // indirect + golang.org/x/time v0.5.0 // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20240318140521-94a12d6c2237 // indirect + gopkg.in/ini.v1 v1.67.0 // indirect + gopkg.in/natefinch/lumberjack.v2 v2.2.1 // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect + rsc.io/tmplfunc v0.0.3 // indirect +) diff --git a/go.sum b/go.sum index e69de29b..eb5c1474 100644 --- a/go.sum +++ b/go.sum @@ -0,0 +1,1062 @@ +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.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.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= +dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU= +github.com/0xPolygon/cdk-data-availability v0.0.7 h1:i5v2I8uEgHSZ5BjnJs3Dsy1XpKdSvfZbON9D16gSCUg= +github.com/0xPolygon/cdk-data-availability v0.0.7/go.mod h1:qF+xt2gYwBab8XPh3fr6pnNUMEJq/32rmJN0D630hmY= +github.com/0xPolygon/cdk-rpc v0.0.0-20240419104226-c0a62ba0f49d h1:sxh6hZ2jF/sxxj2jd5o1vuNNCZjYmn4aRG9SRlVaEFs= +github.com/0xPolygon/cdk-rpc v0.0.0-20240419104226-c0a62ba0f49d/go.mod h1:2scWqMMufrQXu7TikDgQ3BsyaKoX8qP26D6E262vSOg= +github.com/0xPolygonHermez/zkevm-data-streamer v0.2.2 h1:XRMTk+W6vtJVGVjuEznfWyNt7HkRkkuSmlN5Y6p60Sc= +github.com/0xPolygonHermez/zkevm-data-streamer v0.2.2/go.mod h1:0QkAXcFa92mFJrCbN3UPUJGJYes851yEgYHLONnaosE= +github.com/0xPolygonHermez/zkevm-ethtx-manager v0.1.9 h1:vrAezzwTNke6NroDAltGh1k2AJ6ibmZPBsG0bCltbRc= +github.com/0xPolygonHermez/zkevm-ethtx-manager v0.1.9/go.mod h1:pRqfLQVM3nbzdhy3buqjAgcVyNDKAXOHqTSgkwiKpic= +github.com/0xPolygonHermez/zkevm-sequence-sender v0.1.3 h1:8nxOREVVTe2RVgx32UO4ZI5jLjC63gwNroLAiG3ONvQ= +github.com/0xPolygonHermez/zkevm-sequence-sender v0.1.3/go.mod h1:pXTI0u3e/PoA0MgpS+l4Z4ayG39rGq+yalQSfIpWkfg= +github.com/0xPolygonHermez/zkevm-synchronizer-l1 v0.6.1 h1:pf0lvUJNl5/3AnpnFPvgaYTUoOydVUaqI0hyZGglI2E= +github.com/0xPolygonHermez/zkevm-synchronizer-l1 v0.6.1/go.mod h1:3L6m4ZYs2tTTNhxMtq1KHSclxr7RmlZ3eWtOe8lsYsM= +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/DATA-DOG/go-sqlmock v1.5.1 h1:FK6RCIUSfmbnI/imIICmboyQBkOckutaa6R5YYlLZyo= +github.com/DATA-DOG/go-sqlmock v1.5.1/go.mod h1:88MAG/4G7SMwSE3CeA0ZKzrT5CiOU3OJ+JlNzwDqpNU= +github.com/DataDog/zstd v1.5.2 h1:vUG4lAyuPCXO0TLbXvPv7EB7cNK1QV/luu55UHLrrn8= +github.com/DataDog/zstd v1.5.2/go.mod h1:g4AWEaM3yOg3HYfnJ3YIawPnVdXJh9QME85blwSAmyw= +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.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY= +github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU= +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.2 h1:N0y9ASrJ0F6h0QaC3o6uJb3NIZ9VKLjCM7NQbSmF7WI= +github.com/VictoriaMetrics/fastcache v1.12.2/go.mod h1:AmC+Nzz1+3G2eCPapF6UcsnkThDcMsQicp4xDukwJYI= +github.com/allegro/bigcache v1.2.1-0.20190218064605-e24eb225f156/go.mod h1:Cb/ax3seSYIx7SuZdm2G2xzfwmv3TPSk2ucNfQESPXM= +github.com/allegro/bigcache v1.2.1 h1:hg1sY1raCwic3Vnsvje6TT7/pnZba83LeFck5NrFKSc= +github.com/allegro/bigcache v1.2.1/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/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/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 v1.1.1 h1:nCb6ZLdB7NRaqsm91JtQTAme2SKJzXVsdPIPkyJr1MU= +github.com/cespare/cp v1.1.1/go.mod h1:SOGHArjBr4JWaSDEVpWpo/hNg6RoKrls6Oh40hiwW+s= +github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= +github.com/cespare/xxhash/v2 v2.3.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.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.11.1 h1:xSEW75zKaKCWzR3OfxXUxgrk/NtT4G1MiOv5lWZazG8= +github.com/cockroachdb/errors v1.11.1/go.mod h1:8MUxA3Gi6b25tYlFEBGLf+D8aISL+M4MIpiWMSNRfxw= +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 v1.1.0 h1:pcFh8CdCIt2kmEpK0OIatq67Ln9uGDYY3d5XnE0LJG4= +github.com/cockroachdb/pebble v1.1.0/go.mod h1:sEHm5NOXxyiAoKWhoFxT8xMgd/f3RA6qUqQ1BXKrh2E= +github.com/cockroachdb/redact v1.1.5 h1:u1PMllDkdFfPWaNGMyLD1+so+aq3uUItthCFqzwPJ30= +github.com/cockroachdb/redact v1.1.5/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/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/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/v2 v2.0.0/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU= +github.com/cpuguy83/go-md2man/v2 v2.0.4 h1:wfIWP927BUkWJb2NmU/kNDYIBTh/ziUX91+lVfRxZq4= +github.com/cpuguy83/go-md2man/v2 v2.0.4/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o= +github.com/crate-crypto/go-ipa v0.0.0-20240223125850-b1e8a79f509c h1:uQYC5Z1mdLRPrZhHjHxufI8+2UG/i25QG92j0Er9p6I= +github.com/crate-crypto/go-ipa v0.0.0-20240223125850-b1e8a79f509c/go.mod h1:geZJZH3SzKCqnz5VT0q/DyIG/tvu/dZk+VIfXicupJs= +github.com/crate-crypto/go-kzg-4844 v1.0.0 h1:TsSgHwrkTKecKJ4kadtHi4b3xHW5dCFUDFnUp1TsawI= +github.com/crate-crypto/go-kzg-4844 v1.0.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.6.0 h1:XfcQbWM1LlMB8BsJ8N9vW5ehnnPVIw0je80NsVHagjM= +github.com/deckarep/golang-set/v2 v2.6.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/didip/tollbooth/v6 v6.1.2 h1:Kdqxmqw9YTv0uKajBUiWQg+GURL/k4vy9gmLCL01PjQ= +github.com/didip/tollbooth/v6 v6.1.2/go.mod h1:xjcse6CTHCLuOkzsWrEgdy9WPJFv+p/x6v+MyfP+O9s= +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/ethereum/c-kzg-4844 v1.0.0 h1:0X1LBXxaEtYD9xsyj9B9ctQEZIpnvVDeoBx8aHEwTNA= +github.com/ethereum/c-kzg-4844 v1.0.0/go.mod h1:VewdlzQmpT5QSrVhbBuGoCdFJkpaJlO1aQputP83wc0= +github.com/ethereum/go-ethereum v1.14.5 h1:szuFzO1MhJmweXjoM5nSAeDvjNUH3vIQoMzzQnfvjpw= +github.com/ethereum/go-ethereum v1.14.5/go.mod h1:VEDGGhSxY7IEjn98hJRFXl/uFvpRgbIIf2PpXiyGGgc= +github.com/ethereum/go-verkle v0.1.1-0.20240306133620-7d920df305f0 h1:KrE8I4reeVvf7C1tm8elRjj4BdscTYzz/WAbYyf/JI4= +github.com/ethereum/go-verkle v0.1.1-0.20240306133620-7d920df305f0/go.mod h1:D9AJLVXSyZQXJQVk8oh1EwjISE+sJTn2duYIZC0dy3w= +github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4= +github.com/fjl/memsize v0.0.2 h1:27txuSD9or+NZlnOWdKUxeBzTAUkWCVh+4Gf2dWFOzA= +github.com/fjl/memsize v0.0.2/go.mod h1:VvhXpOYNQvB+uIk2RvXzuaQtkQJzzIx6lSBe1xv7hi0= +github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8= +github.com/frankban/quicktest v1.14.6/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.7.0 h1:8JEhPFa5W2WU7YfeZzPNqzMP6Lwt7L2715Ggo0nosvA= +github.com/fsnotify/fsnotify v1.7.0/go.mod h1:40Bi/Hjc2AVfZrqy+aj+yEI+/bRxZnMJyTJwOpGvigM= +github.com/gballet/go-libpcsclite v0.0.0-20191108122812-4678299bea08 h1:f6D9Hr8xV8uYKlyuj8XIruxlh9WjVjdh1gIicAS7ays= +github.com/gballet/go-libpcsclite v0.0.0-20191108122812-4678299bea08/go.mod h1:x7DCsMOv1taUwEWCzT4cmDeAkigA5/QCwUodaVOe8Ww= +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/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-ole/go-ole v1.2.5/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0= +github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE= +github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78= +github.com/go-pkgz/expirable-cache v0.0.3 h1:rTh6qNPp78z0bQE6HDhXBHUwqnV9i09Vm6dksJLXQDc= +github.com/go-pkgz/expirable-cache v0.0.3/go.mod h1:+IauqN00R2FqNRLCLA+X5YljQJrwB179PfiAoMPlTlQ= +github.com/go-sql-driver/mysql v1.4.0/go.mod h1:zAC/RDZ24gD3HViQzih4MyKcchzm+sOG5ZlKdlhCg5w= +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/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/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= +github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= +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/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/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.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= +github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +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-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.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.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/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY= +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.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/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ= +github.com/hashicorp/hcl v1.0.1-0.20180906183839-65a6292f0157 h1:uyodBE3xDz0ynKs1tLBU26wOQoEkAqqiY18DbZ+FZrA= +github.com/hashicorp/hcl v1.0.1-0.20180906183839-65a6292f0157/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-20240216141850-2abb0c79d3c4 h1:X4egAf/gcS1zATw6wn4Ej8vjuVGxeHdan+bRb2ebyv4= +github.com/holiman/billy v0.0.0-20240216141850-2abb0c79d3c4/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/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/iden3/go-iden3-crypto v0.0.16 h1:zN867xiz6HgErXVIV/6WyteGcOukE9gybYTorBMEdsk= +github.com/iden3/go-iden3-crypto v0.0.16/go.mod h1:dLpM4vEPJ3nDHzhWFXDjzkn1qHoBeOT/3UEhXsEsP3E= +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/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.3 h1:bVoTr12EGANZz66nZPkMInAV/KHD2TxH9npjXXgiB3w= +github.com/jackc/pgconn v1.14.3/go.mod h1:RZbme4uasqzybK2RK5c65VsHxoyaml09lx3tXOcO/VM= +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.3 h1:1HLSx5H+tXR9pW3in3zaztoEwQYRC9SQaYUHjTSUOag= +github.com/jackc/pgproto3/v2 v2.3.3/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.3 h1:dE2/TrEsGX3RBprb3qryqSV9Y60iZN1C6i8IrmW9/BA= +github.com/jackc/pgx/v4 v4.18.3/go.mod h1:Ey4Oru5tH5sB6tV7hDmfWFahwF15Eb7DNXlRKx2CkVw= +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/jmoiron/sqlx v1.2.0 h1:41Ip0zITnmWNR/vHV+S4m+VoUivnWY5E4OJfLZjCJMA= +github.com/jmoiron/sqlx v1.2.0/go.mod h1:1FEQNm3xlJgrMD+FBdI9+xvCksHtbpVBBw5dYhBSsks= +github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y= +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/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/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.17.2 h1:RlWWUY/Dr4fL8qk9YG7DTZ7PDgME2V4csBXA8L/ixi4= +github.com/klauspost/compress v1.17.2/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE= +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.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/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.9 h1:YXG7RB+JIjhP29X+OtkiDnYaXQwpS4JEWq7dtCCRUEw= +github.com/lib/pq v1.10.9/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o= +github.com/logrusorgru/aurora v0.0.0-20181002194514-a7b3b318ed4e/go.mod h1:7rIyQOR62GCctdiQpZ/zOJlFyk6y+94wXzv6RNZgaR4= +github.com/logrusorgru/aurora v2.0.3+incompatible h1:tOpm7WcpBTn4fjmVfgpQq0EfczGlG91VSDkswnjF5A8= +github.com/logrusorgru/aurora v2.0.3+incompatible/go.mod h1:7rIyQOR62GCctdiQpZ/zOJlFyk6y+94wXzv6RNZgaR4= +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.6/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc= +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.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU= +github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= +github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= +github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= +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.9.0/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc= +github.com/mattn/go-sqlite3 v1.14.19 h1:fhGleo2h1p8tVChob4I9HpmVFIAkKGpiukdrgQbWfGI= +github.com/mattn/go-sqlite3 v1.14.19/go.mod h1:2eHXhiwb8IkHr+BDWZGa96P6+rkvnG63S2DGjv9HUNg= +github.com/miekg/dns v1.0.14/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg= +github.com/miguelmota/go-solidity-sha3 v0.1.1 h1:3Y08sKZDtudtE5kbTBPC9RYJznoSYyWI9VD6mghU0CA= +github.com/miguelmota/go-solidity-sha3 v0.1.1/go.mod h1:sax1FvQF+f71j8W1uUHMZn8NxKyl5rYLks2nqj8RFEw= +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-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/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= +github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= +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.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/go.mod h1:LY+I3pBVzYsTBU1AnDwOSxaYi9WoWiqgwooUqq9yPro= +github.com/onsi/gomega v1.27.10 h1:naR28SdDFlqrG6kScpT8VWpu1xWY5nJRCF3XaYyBjhI= +github.com/onsi/gomega v1.27.10/go.mod h1:RsS8tutOdbdgzbPtzzATp12yT7kM5I5aElG3evPbQ0M= +github.com/pascaldekloe/goe v0.0.0-20180627143212-57f6aae5913c/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc= +github.com/pelletier/go-toml v1.9.3/go.mod h1:u1nR/EPcESfeI/szUZKdtJ0xRNbUoANCkoOuaOx1Y+c= +github.com/pelletier/go-toml/v2 v2.2.2 h1:aYUidT7k73Pcl9nb2gScu7NSrKCSHIDE89b3+6Wq+LM= +github.com/pelletier/go-toml/v2 v2.2.2/go.mod h1:1t835xjRzz80PqgE6HHgN2JOsmgYu/h4qDAS4n929Rs= +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/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.19.1 h1:wZWJDwK+NameRJuPGDhlnFgx8e8HN3XHQeLaYJFJBOE= +github.com/prometheus/client_golang v1.19.1/go.mod h1:mP78NwGzrVks5S2H6ab8+ZZGJLZUq1hoULYBAYBw1Ho= +github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= +github.com/prometheus/client_model v0.6.1 h1:ZKSh/rekM+n3CeS952MLRAdFwIKqeY8b62p8ais2e9E= +github.com/prometheus/client_model v0.6.1/go.mod h1:OrxVMOVHjw3lKMa8+x6HeMGkHMQyHDk9E3jmP2AmGiY= +github.com/prometheus/common v0.48.0 h1:QO8U2CdOzSn1BBsmXJXduaaW+dY/5QLjfB8svtSzKKE= +github.com/prometheus/common v0.48.0/go.mod h1:0/KsvlIEfPQCQ5I2iNSAWKPZziNCvRs5EC6ILDTlAPc= +github.com/prometheus/procfs v0.12.0 h1:jluTpSng7V9hY0O2R9DzzJHYb2xULk9VTR1V1R/k6Bo= +github.com/prometheus/procfs v0.12.0/go.mod h1:pcuDEFsWDnvcgNzo4EEweacyhjeA9Zk3cnaOZAZEfOo= +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.8.0/go.mod h1:WmiCO8CzOY8rg0OYDC4/i/2WRWAB6poM+XZ2dLUbcbE= +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.6.1 h1:bo6/sjsan9HaXAsNxYP/jCEDUGibHp8JmOBw7NTGRos= +github.com/rubenv/sql-migrate v1.6.1/go.mod h1:tPzespupJS0jacLfhbwto/UjSX+8h2FdWB7ar+QlHa0= +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/sagikazarmark/locafero v0.4.0 h1:HApY1R9zGo4DBgr7dqsTH/JJxLTTsOt7u6keLGt6kNQ= +github.com/sagikazarmark/locafero v0.4.0/go.mod h1:Pe1W6UlPYUk/+wc/6KFhbORCfqzgYEpgQ3O5fPuL3H4= +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/sean-/seed v0.0.0-20170313163322-e2103e2c3529/go.mod h1:DxrIzT+xaE7yg65j358z/aeFdxmN0P9QXhEzd20vsDc= +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/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ= +github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ= +github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ= +github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc= +github.com/smartystreets/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.6.0/go.mod h1:Ai8FlHk4v/PARR026UzYexafAt9roJ7LcLMAmO6Z93I= +github.com/spf13/afero v1.11.0 h1:WJQKhtpdm3v2IzqG8VMqrr6Rf3UYpEF239Jy9wNepM8= +github.com/spf13/afero v1.11.0/go.mod h1:GH9Y3pIexgf1MTIWtNGyogA5MwRIDXGUr+hbWNoBjkY= +github.com/spf13/cast v1.3.1/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE= +github.com/spf13/cast v1.6.0 h1:GEiTHELF+vaR5dhz3VqZfFSzZjYbgeKDpBxQVS4GYJ0= +github.com/spf13/cast v1.6.0/go.mod h1:ancEpBxwJDODSW/UG4rDrAqiKolqNNh2DX3mk86cAdo= +github.com/spf13/cobra v1.2.1/go.mod h1:ExllRjgxM/piMAM+3tAZvg8fsklGAf3tPfi+i8t68Nk= +github.com/spf13/jwalterweatherman v1.1.0/go.mod h1:aNWZUN0dPAAO/Ljvb5BEdw96iTZ0EXowPYD95IqWIGo= +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.8.1/go.mod h1:o0Pch8wJ9BVSWGQMbra6iw0oQ5oktSIBaujf1rJH9Ns= +github.com/spf13/viper v1.19.0 h1:RWq5SEjt8o25SROyN3z2OrDB9l7RPd3lwTWU8EcEdcI= +github.com/spf13/viper v1.19.0/go.mod h1:GQUN9bilAbhU/jgc1bKs99f/suXKeUMct8Adx5+Ntkg= +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/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY= +github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= +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.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= +github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= +github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= +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/urfave/cli/v2 v2.27.2 h1:6e0H+AkS+zDckwPCUrZkKX38mRaau4nL2uipkJpbkcI= +github.com/urfave/cli/v2 v2.27.2/go.mod h1:g0+79LmHHATl7DAcHO99smiR/T7uGLw84w8Y42x+4eM= +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/xrash/smetrics v0.0.0-20240312152122-5f08fbb34913 h1:+qGGcbkzsfDQNPPe9UDgpxAWQrhbbBXOYJFQDq/dtJw= +github.com/xrash/smetrics v0.0.0-20240312152122-5f08fbb34913/go.mod h1:4aEEwZQutDLsQv2Deui4iYQ6DWTxR14g6m8Wv88+Xqk= +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/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.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= +go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= +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.27.0 h1:aJMhYGrd5QSmlpLMr2MftRKl7t8J8PTZPA732ud/XR8= +go.uber.org/zap v1.27.0/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E= +golang.org/x/crypto v0.0.0-20181029021203-45a5f77698d3/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-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-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-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.24.0 h1:mnl8DM0o513X8fdIkmyFE/5hTYxbwYOjDS/+rK6qpRI= +golang.org/x/crypto v0.24.0/go.mod h1:Z1PMYSOR5nyMcyAVAIQSKCDwalqy85Aqn1x3Ws4L5DM= +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.17.0 h1:zY54UmvipHiNd+pm+m0x9KhZ9hl1/7QNMyxXbc6ICqA= +golang.org/x/mod v0.17.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-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-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-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-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-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.26.0 h1:soB7SVo0PWrY4vPW/+ay0jKDNScG2X9wFeYlXIvJsOQ= +golang.org/x/net v0.26.0/go.mod h1:5YKkiSynbBIh3p6iOc/vibscux0x38BZDkn8sCUPxHE= +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.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M= +golang.org/x/sync v0.7.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-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-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-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-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-20210809222454-d867a43fc93e/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-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-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.14.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/sys v0.21.0 h1:rF+pYz3DAGSQAxAu1CbC7catZg4ebC4UIeIhKxBZvws= +golang.org/x/sys v0.21.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.21.0 h1:WVXCp+/EBEHOj53Rvu+7KiT/iElMrO8ACK16SMZ3jaA= +golang.org/x/term v0.21.0/go.mod h1:ooXLefLobQVslOqselCNF4SxFAaoS6KujMbsGzSDmX0= +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.16.0 h1:a94ExnEXNtEwYLGJSIUxnWoxoRz/ZcCsV63ROupILh4= +golang.org/x/text v0.16.0/go.mod h1:GhwF1Be+LQoKShO3cGOHzqOgRrGaYc9AvblQOmPVHnI= +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-20200416051211-89c76fbcd5d1/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/time v0.5.0 h1:o7cqy6amK/52YcAKIPlM3a+Fpj35zvRj2TP+e1xFSfk= +golang.org/x/time v0.5.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/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-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.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0= +golang.org/x/tools v0.1.2/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= +golang.org/x/tools v0.1.7/go.mod h1:LGqMHiF4EqQNHR1JncWGqT5BVaXmza+X+BDGol+dOxo= +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-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-20210222152913-aa3ee6e6a81c/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/googleapis/rpc v0.0.0-20240318140521-94a12d6c2237 h1:NnYq6UN9ReLM9/Y01KWNOWyI5xQ9kbIms5GGJVwS/Yc= +google.golang.org/genproto/googleapis/rpc v0.0.0-20240318140521-94a12d6c2237/go.mod h1:WtryC6hu0hhx87FDGxWCDptyssuo68sk10vYjF+T9fY= +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.64.0 h1:KH3VH9y/MgNQg1dE7b3XfVK0GsPSIzJwdF617gUSbvY= +google.golang.org/grpc v1.64.0/go.mod h1:oxjF8E3FBnjp+/gVFYdWacaLDx9na1aqy9oovLpxQYg= +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.34.2 h1:6xV6lTsCfpGD21XK49h7MhtcApnLqkfYgPcdHftf6hg= +google.golang.org/protobuf v1.34.2/go.mod h1:qYOHts0dSfpeUzUFpOMr/WGzszTmLH+DiWniOlNbLDw= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= +gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI= +gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys= +gopkg.in/inconshreveable/log15.v2 v2.0.0-20180818164646-67afb5ed74ec/go.mod h1:aPpfJ7XW+gOuirDoZ8gHhLh3kZ1B08FtV2bbmy7Jv3s= +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/natefinch/lumberjack.v2 v2.2.1 h1:bBRl1b0OH9s/DuPhuXpNl+VtCaJXFZ5/uEFST95x9zc= +gopkg.in/natefinch/lumberjack.v2 v2.2.1/go.mod h1:YD8tP3GAjkrDg1eZH7EGmyESg/lsYskCTPBJVb9jqSc= +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-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 00000000..4699eb20 --- /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 00000000..da86da35 --- /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/l1infotree/hash.go b/l1infotree/hash.go new file mode 100644 index 00000000..b07c3f10 --- /dev/null +++ b/l1infotree/hash.go @@ -0,0 +1,41 @@ +package l1infotree + +import ( + "encoding/binary" + + "github.com/ethereum/go-ethereum/common" + "github.com/iden3/go-iden3-crypto/keccak256" + "golang.org/x/crypto/sha3" +) + +// Hash calculates the keccak hash of elements. +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 +} + +func generateZeroHashes(height uint8) [][32]byte { + var zeroHashes = [][32]byte{ + common.Hash{}, + } + // This generates a leaf = HashZero in position 0. In the rest of the positions that are equivalent to the ascending levels, + // we set the hashes of the nodes. So all nodes from level i=5 will have the same value and same children nodes. + for i := 1; i <= int(height); i++ { + zeroHashes = append(zeroHashes, Hash(zeroHashes[i-1], zeroHashes[i-1])) + } + return zeroHashes +} + +// HashLeafData calculates the keccak hash of the leaf values. +func HashLeafData(ger, prevBlockHash common.Hash, minTimestamp uint64) [32]byte { + var res [32]byte + t := make([]byte, 8) //nolint:gomnd + binary.BigEndian.PutUint64(t, minTimestamp) + copy(res[:], keccak256.Hash(ger.Bytes(), prevBlockHash.Bytes(), t)) + return res +} diff --git a/l1infotree/hash_test.go b/l1infotree/hash_test.go new file mode 100644 index 00000000..a792c0b8 --- /dev/null +++ b/l1infotree/hash_test.go @@ -0,0 +1,20 @@ +package l1infotree + +import ( + "testing" + + "github.com/ethereum/go-ethereum/common" + "github.com/stretchr/testify/assert" +) + +func TestHashLeaf(t *testing.T) { + expectedLeafHash := common.HexToHash("0xf62f487534b899b1c362242616725878188ca891fab60854b792ca0628286de7") + + prevBlockHash := common.HexToHash("0x24a5871d68723340d9eadc674aa8ad75f3e33b61d5a9db7db92af856a19270bb") + var minTimestamp uint64 = 1697231573 + ger := common.HexToHash("0x16994edfddddb9480667b64174fc00d3b6da7290d37b8db3a16571b4ddf0789f") + + leaf := HashLeafData(ger, prevBlockHash, minTimestamp) + + assert.Equal(t, expectedLeafHash, common.BytesToHash(leaf[:])) +} diff --git a/l1infotree/tree.go b/l1infotree/tree.go new file mode 100644 index 00000000..6fc01c87 --- /dev/null +++ b/l1infotree/tree.go @@ -0,0 +1,198 @@ +package l1infotree + +import ( + "fmt" + + "github.com/0xPolygon/cdk/log" + "github.com/ethereum/go-ethereum/common" +) + +// L1InfoTree provides methods to compute L1InfoTree +type L1InfoTree struct { + height uint8 + zeroHashes [][32]byte + count uint32 + siblings [][32]byte + currentRoot common.Hash +} + +// NewL1InfoTree creates new L1InfoTree. +func NewL1InfoTree(height uint8, initialLeaves [][32]byte) (*L1InfoTree, error) { + mt := &L1InfoTree{ + zeroHashes: generateZeroHashes(height), + height: height, + count: uint32(len(initialLeaves)), + } + var err error + mt.siblings, mt.currentRoot, err = mt.initSiblings(initialLeaves) + if err != nil { + log.Error("error initializing siblings. Error: ", err) + return nil, err + } + log.Debug("Initial count: ", mt.count) + log.Debug("Initial root: ", mt.currentRoot) + return mt, nil +} + +// ResetL1InfoTree resets the L1InfoTree. +func (mt *L1InfoTree) ResetL1InfoTree(initialLeaves [][32]byte) (*L1InfoTree, error) { + log.Info("Resetting L1InfoTree...") + newMT := &L1InfoTree{ + zeroHashes: generateZeroHashes(32), // nolint:gomnd + height: 32, // nolint:gomnd + count: uint32(len(initialLeaves)), + } + var err error + newMT.siblings, newMT.currentRoot, err = newMT.initSiblings(initialLeaves) + if err != nil { + log.Error("error initializing siblings. Error: ", err) + return nil, err + } + log.Debug("Reset initial count: ", newMT.count) + log.Debug("Reset initial root: ", newMT.currentRoot) + return newMT, nil +} + +func buildIntermediate(leaves [][32]byte) ([][][]byte, [][32]byte) { + var ( + nodes [][][]byte + hashes [][32]byte + ) + for i := 0; i < len(leaves); i += 2 { + var left, right int = i, i + 1 + hash := Hash(leaves[left], leaves[right]) + nodes = append(nodes, [][]byte{hash[:], leaves[left][:], leaves[right][:]}) + hashes = append(hashes, hash) + } + return nodes, hashes +} + +// BuildL1InfoRoot computes the root given the leaves of the tree +func (mt *L1InfoTree) BuildL1InfoRoot(leaves [][32]byte) (common.Hash, error) { + var ( + nodes [][][][]byte + ns [][][]byte + ) + if len(leaves) == 0 { + leaves = append(leaves, mt.zeroHashes[0]) + } + + for h := uint8(0); h < mt.height; h++ { + if len(leaves)%2 == 1 { + leaves = append(leaves, mt.zeroHashes[h]) + } + ns, leaves = buildIntermediate(leaves) + nodes = append(nodes, ns) + } + if len(ns) != 1 { + return common.Hash{}, fmt.Errorf("error: more than one root detected: %+v", nodes) + } + + return common.BytesToHash(ns[0][0]), nil +} + +// ComputeMerkleProof computes the merkleProof and root given the leaves of the tree +func (mt *L1InfoTree) ComputeMerkleProof(gerIndex uint32, leaves [][32]byte) ([][32]byte, common.Hash, error) { + var ns [][][]byte + if len(leaves) == 0 { + leaves = append(leaves, mt.zeroHashes[0]) + } + var siblings [][32]byte + index := gerIndex + for h := uint8(0); h < mt.height; h++ { + if len(leaves)%2 == 1 { + leaves = append(leaves, mt.zeroHashes[h]) + } + if index >= uint32(len(leaves)) { + siblings = append(siblings, mt.zeroHashes[h]) + } else { + if index%2 == 1 { //If it is odd + siblings = append(siblings, leaves[index-1]) + } else { // It is even + siblings = append(siblings, leaves[index+1]) + } + } + var ( + nsi [][][]byte + hashes [][32]byte + ) + for i := 0; i < len(leaves); i += 2 { + var left, right int = i, i + 1 + hash := Hash(leaves[left], leaves[right]) + nsi = append(nsi, [][]byte{hash[:], leaves[left][:], leaves[right][:]}) + hashes = append(hashes, hash) + } + // Find the index of the leave in the next level of the tree. + // Divide the index by 2 to find the position in the upper level + index = uint32(float64(index) / 2) //nolint:gomnd + ns = nsi + leaves = hashes + } + if len(ns) != 1 { + return nil, common.Hash{}, fmt.Errorf("error: more than one root detected: %+v", ns) + } + + return siblings, common.BytesToHash(ns[0][0]), nil +} + +// AddLeaf adds new leaves to the tree and computes the new root +func (mt *L1InfoTree) AddLeaf(index uint32, leaf [32]byte) (common.Hash, error) { + if index != mt.count { + return common.Hash{}, fmt.Errorf("mismatched leaf count: %d, expected: %d", index, mt.count) + } + cur := leaf + isFilledSubTree := true + + for h := uint8(0); h < mt.height; h++ { + if index&(1< 0 { + var child [32]byte + copy(child[:], cur[:]) + parent := Hash(mt.siblings[h], child) + cur = parent + } else { + if isFilledSubTree { + // we will update the sibling when the sub tree is complete + copy(mt.siblings[h][:], cur[:]) + // we have a left child in this layer, it means the right child is empty so the sub tree is not completed + isFilledSubTree = false + } + var child [32]byte + copy(child[:], cur[:]) + parent := Hash(child, mt.zeroHashes[h]) + cur = parent + // the sibling of 0 bit should be the zero hash, since we are in the last node of the tree + } + } + mt.currentRoot = cur + mt.count++ + return cur, nil +} + +// initSiblings returns the siblings of the node at the given index. +// it is used to initialize the siblings array in the beginning. +func (mt *L1InfoTree) initSiblings(initialLeaves [][32]byte) ([][32]byte, common.Hash, error) { + if mt.count != uint32(len(initialLeaves)) { + return nil, [32]byte{}, fmt.Errorf("error: mt.count and initialLeaves length mismatch") + } + if mt.count == 0 { + var siblings [][32]byte + for h := 0; h < int(mt.height); h++ { + var left [32]byte + copy(left[:], mt.zeroHashes[h][:]) + siblings = append(siblings, left) + } + root, err := mt.BuildL1InfoRoot(initialLeaves) + if err != nil { + log.Error("error calculating initial root: ", err) + return nil, [32]byte{}, err + } + return siblings, root, nil + } + + return mt.ComputeMerkleProof(mt.count, initialLeaves) +} + +// GetCurrentRootCountAndSiblings returns the latest root, count and sibblings +func (mt *L1InfoTree) GetCurrentRootCountAndSiblings() (common.Hash, uint32, [][32]byte) { + return mt.currentRoot, mt.count, mt.siblings +} diff --git a/log/config.go b/log/config.go new file mode 100644 index 00000000..2f166ee9 --- /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 00000000..8b9bcd5c --- /dev/null +++ b/log/log.go @@ -0,0 +1,320 @@ +package log + +import ( + "fmt" + "os" + "strings" + "sync/atomic" + + "github.com/0xPolygonHermez/zkevm-sequence-sender" + "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 00000000..9d33bcd0 --- /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/merkletree/key.go b/merkletree/key.go new file mode 100644 index 00000000..1534f462 --- /dev/null +++ b/merkletree/key.go @@ -0,0 +1,201 @@ +package merkletree + +import ( + "math" + "math/big" + + "github.com/ethereum/go-ethereum/common" + poseidon "github.com/iden3/go-iden3-crypto/goldenposeidon" +) + +// Key stores key of the leaf +type Key [32]byte + +const ( + // HashPoseidonAllZeroes represents the poseidon hash for an input with all + // bits set to zero. + HashPoseidonAllZeroes = "0xc71603f33a1144ca7953db0ab48808f4c4055e3364a246c33c18a9786cb0b359" +) + +// keyEthAddr is the common code for all the keys related to ethereum addresses. +func keyEthAddr(ethAddr common.Address, leafType leafType, key1Capacity [4]uint64) ([]byte, error) { + ethAddrBI := new(big.Int).SetBytes(ethAddr.Bytes()) + ethAddrArr := scalar2fea(ethAddrBI) + + key1 := [8]uint64{ + ethAddrArr[0], + ethAddrArr[1], + ethAddrArr[2], + ethAddrArr[3], + ethAddrArr[4], + 0, + uint64(leafType), + 0, + } + + result, err := poseidon.Hash(key1, key1Capacity) + if err != nil { + return nil, err + } + + return h4ToFilledByteSlice(result[:]), nil +} + +func defaultCapIn() ([4]uint64, error) { + capIn, err := StringToh4(HashPoseidonAllZeroes) + if err != nil { + return [4]uint64{}, err + } + + return [4]uint64{capIn[0], capIn[1], capIn[2], capIn[3]}, nil +} + +// KeyEthAddrBalance returns the key of balance leaf: +// hk0: H([0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0]) +// key: H([ethAddr[0:4], ethAddr[4:8], ethAddr[8:12], ethAddr[12:16], ethAddr[16:20], 0, 0, 0], [hk0[0], hk0[1], hk0[2], hk0[3]]) +func KeyEthAddrBalance(ethAddr common.Address) ([]byte, error) { + capIn, err := defaultCapIn() + if err != nil { + return nil, err + } + + return keyEthAddr(ethAddr, LeafTypeBalance, capIn) +} + +// KeyEthAddrNonce returns the key of nonce leaf: +// hk0: H([0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0]) +// key: H([ethAddr[0:4], ethAddr[4:8], ethAddr[8:12], ethAddr[12:16], ethAddr[16:20], 0, 1, 0], [hk0[0], hk0[1], hk0[2], hk0[3]] +func KeyEthAddrNonce(ethAddr common.Address) ([]byte, error) { + capIn, err := defaultCapIn() + if err != nil { + return nil, err + } + + return keyEthAddr(ethAddr, LeafTypeNonce, capIn) +} + +// KeyContractCode returns the key of contract code leaf: +// hk0: H([0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0]) +// key: H([ethAddr[0:4], ethAddr[4:8], ethAddr[8:12], ethAddr[12:16], ethAddr[16:20], 0, 2, 0], [hk0[0], hk0[1], hk0[2], hk0[3]] +func KeyContractCode(ethAddr common.Address) ([]byte, error) { + capIn, err := defaultCapIn() + if err != nil { + return nil, err + } + + return keyEthAddr(ethAddr, LeafTypeCode, capIn) +} + +// KeyContractStorage returns the key of contract storage position leaf: +// hk0: H([stoPos[0:4], stoPos[4:8], stoPos[8:12], stoPos[12:16], stoPos[16:20], stoPos[20:24], stoPos[24:28], stoPos[28:32], [0, 0, 0, 0]) +// key: H([ethAddr[0:4], ethAddr[4:8], ethAddr[8:12], ethAddr[12:16], ethAddr[16:20], 0, 3, 0], [hk0[0], hk0[1], hk0[2], hk0[3]) +func KeyContractStorage(ethAddr common.Address, storagePos []byte) ([]byte, error) { + storageBI := new(big.Int).SetBytes(storagePos) + + storageArr := scalar2fea(storageBI) + + hk0, err := poseidon.Hash([8]uint64{ + storageArr[0], + storageArr[1], + storageArr[2], + storageArr[3], + storageArr[4], + storageArr[5], + storageArr[6], + storageArr[7], + }, [4]uint64{}) + if err != nil { + return nil, err + } + + return keyEthAddr(ethAddr, LeafTypeStorage, hk0) +} + +// HashContractBytecode computes the bytecode hash in order to add it to the +// state-tree. +func HashContractBytecode(code []byte) ([]uint64, error) { + const ( + bytecodeElementsHash = 8 + bytecodeBytesElement = 7 + + maxBytesToAdd = bytecodeElementsHash * bytecodeBytesElement + ) + + // add 0x01 + code = append(code, 0x01) // nolint:gomnd + + // add padding + for len(code)%(56) != 0 { // nolint:gomnd + code = append(code, 0x00) // nolint:gomnd + } + + code[len(code)-1] = code[len(code)-1] | 0x80 // nolint:gomnd + + numHashes := int(math.Ceil(float64(len(code)) / float64(maxBytesToAdd))) + + tmpHash := [4]uint64{} + var err error + + bytesPointer := 0 + for i := 0; i < numHashes; i++ { + elementsToHash := [12]uint64{} + + for j := 0; j < 4; j++ { + elementsToHash[j] = tmpHash[j] + } + + subsetBytecode := code[bytesPointer : int(math.Min(float64(len(code)-1), float64(bytesPointer+maxBytesToAdd)))+1] + bytesPointer += maxBytesToAdd + tmpElem := [7]byte{} + counter := 0 + index := 4 + for j := 0; j < maxBytesToAdd; j++ { + byteToAdd := []byte{0} + + if j < len(subsetBytecode) { + byteToAdd = subsetBytecode[j : j+1] + } + + tmpElem[bytecodeBytesElement-1-counter] = byteToAdd[0] + counter++ + + if counter == bytecodeBytesElement { + elementsToHash[index] = new(big.Int).SetBytes(tmpElem[:]).Uint64() + index++ + tmpElem = [7]byte{} + counter = 0 + } + } + tmpHash, err = poseidon.Hash([8]uint64{ + elementsToHash[4], + elementsToHash[5], + elementsToHash[6], + elementsToHash[7], + elementsToHash[8], + elementsToHash[9], + elementsToHash[10], + elementsToHash[11], + }, [4]uint64{ + elementsToHash[0], + elementsToHash[1], + elementsToHash[2], + elementsToHash[3], + }) + if err != nil { + return nil, err + } + } + return tmpHash[:], nil +} + +// KeyCodeLength returns the key of code length leaf: +// hk0: H([0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0]) +// key: H([ethAddr[0:4], ethAddr[4:8], ethAddr[8:12], ethAddr[12:16], ethAddr[16:20], 0, 4, 0], [hk0[0], hk0[1], hk0[2], hk0[3]] +func KeyCodeLength(ethAddr common.Address) ([]byte, error) { + capIn, err := defaultCapIn() + if err != nil { + return nil, err + } + + return keyEthAddr(ethAddr, LeafTypeSCLength, capIn) +} diff --git a/merkletree/leaf.go b/merkletree/leaf.go new file mode 100644 index 00000000..5321f69a --- /dev/null +++ b/merkletree/leaf.go @@ -0,0 +1,17 @@ +package merkletree + +// leafType specifies type of the leaf +type leafType uint8 + +const ( + // 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 +) diff --git a/merkletree/split.go b/merkletree/split.go new file mode 100644 index 00000000..63fcae33 --- /dev/null +++ b/merkletree/split.go @@ -0,0 +1,98 @@ +package merkletree + +import ( + "encoding/binary" + "fmt" + "math/big" + "strings" + + "github.com/0xPolygon/cdk/hex" +) + +// maxBigIntLen is 256 bits (32 bytes) +const maxBigIntLen = 32 + +// wordLength is the number of bits of each ff limb +const wordLength = 64 + +// scalar2fea splits a *big.Int into array of 32bit uint64 values. +func scalar2fea(value *big.Int) []uint64 { + val := make([]uint64, 8) //nolint:gomnd + mask, _ := new(big.Int).SetString("FFFFFFFF", 16) //nolint:gomnd + val[0] = new(big.Int).And(value, mask).Uint64() + val[1] = new(big.Int).And(new(big.Int).Rsh(value, 32), mask).Uint64() //nolint:gomnd + val[2] = new(big.Int).And(new(big.Int).Rsh(value, 64), mask).Uint64() //nolint:gomnd + val[3] = new(big.Int).And(new(big.Int).Rsh(value, 96), mask).Uint64() //nolint:gomnd + val[4] = new(big.Int).And(new(big.Int).Rsh(value, 128), mask).Uint64() //nolint:gomnd + val[5] = new(big.Int).And(new(big.Int).Rsh(value, 160), mask).Uint64() //nolint:gomnd + val[6] = new(big.Int).And(new(big.Int).Rsh(value, 192), mask).Uint64() //nolint:gomnd + val[7] = new(big.Int).And(new(big.Int).Rsh(value, 224), mask).Uint64() //nolint:gomnd + return val +} + +// h4ToScalar converts array of 4 uint64 into a unique 256 bits scalar. +func h4ToScalar(h4 []uint64) *big.Int { + if len(h4) == 0 { + return new(big.Int) + } + result := new(big.Int).SetUint64(h4[0]) + + for i := 1; i < 4; i++ { + b2 := new(big.Int).SetUint64(h4[i]) + b2.Lsh(b2, uint(wordLength*i)) + result = result.Add(result, b2) + } + + return result +} + +// H4ToString converts array of 4 Scalars of 64 bits into an hex string. +func H4ToString(h4 []uint64) string { + sc := h4ToScalar(h4) + + return fmt.Sprintf("0x%064s", hex.EncodeToString(sc.Bytes())) +} + +// StringToh4 converts an hex string into array of 4 Scalars of 64 bits. +func StringToh4(str string) ([]uint64, error) { + if strings.HasPrefix(str, "0x") { // nolint + str = str[2:] + } + + bi, ok := new(big.Int).SetString(str, hex.Base) + if !ok { + return nil, fmt.Errorf("Could not convert %q into big int", str) + } + + return scalarToh4(bi), nil +} + +// scalarToh4 converts a *big.Int into an array of 4 uint64 +func scalarToh4(s *big.Int) []uint64 { + b := ScalarToFilledByteSlice(s) + + r := make([]uint64, 4) //nolint:gomnd + + f, _ := hex.DecodeHex("0xFFFFFFFFFFFFFFFF") + fbe := binary.BigEndian.Uint64(f) + + r[3] = binary.BigEndian.Uint64(b[0:8]) & fbe + r[2] = binary.BigEndian.Uint64(b[8:16]) & fbe + r[1] = binary.BigEndian.Uint64(b[16:24]) & fbe + r[0] = binary.BigEndian.Uint64(b[24:]) & fbe + + return r +} + +// ScalarToFilledByteSlice converts a *big.Int into an array of maxBigIntLen +// bytes. +func ScalarToFilledByteSlice(s *big.Int) []byte { + buf := make([]byte, maxBigIntLen) + return s.FillBytes(buf) +} + +// h4ToFilledByteSlice converts an array of 4 uint64 into an array of +// maxBigIntLen bytes. +func h4ToFilledByteSlice(h4 []uint64) []byte { + return ScalarToFilledByteSlice(h4ToScalar(h4)) +} diff --git a/metrics/api.go b/metrics/api.go new file mode 100644 index 00000000..c21e2cca --- /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 00000000..9fe7ef62 --- /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 00000000..f260d67b --- /dev/null +++ b/metrics/prometheus.go @@ -0,0 +1,677 @@ +package metrics + +import ( + "net/http" + "sync" + + "github.com/0xPolygon/cdk/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 00000000..3cf5683e --- /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/proto/include/google/protobuf/empty.proto b/proto/include/google/protobuf/empty.proto new file mode 100644 index 00000000..22274621 --- /dev/null +++ b/proto/include/google/protobuf/empty.proto @@ -0,0 +1,51 @@ +// Protocol Buffers - Google's data interchange format +// Copyright 2008 Google Inc. All rights reserved. +// https://developers.google.com/protocol-buffers/ +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +syntax = "proto3"; + +package google.protobuf; + +option csharp_namespace = "Google.Protobuf.WellKnownTypes"; +option go_package = "google.golang.org/protobuf/types/known/emptypb"; +option java_package = "com.google.protobuf"; +option java_outer_classname = "EmptyProto"; +option java_multiple_files = true; +option objc_class_prefix = "GPB"; +option cc_enable_arenas = true; + +// A generic empty message that you can re-use to avoid defining duplicated +// empty messages in your APIs. A typical example is to use it as the request +// or the response type of an API method. For instance: +// +// service Foo { +// rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); +// } +// +message Empty {} diff --git a/proto/src/proto/aggregator/v1/aggregator.proto b/proto/src/proto/aggregator/v1/aggregator.proto new file mode 100644 index 00000000..3d5480e4 --- /dev/null +++ b/proto/src/proto/aggregator/v1/aggregator.proto @@ -0,0 +1,330 @@ +syntax = "proto3"; + +package aggregator.v1; + +option go_package = ""github.com/0xPolygon/cdk/proverclient/prover"; + +message Version { + string v0_0_1 = 1; +} + +// timestamps are represented in unix time in seconds + +/** + * Define all methods implementes by the gRPC + * Channel: prover receives aggregator messages and returns prover messages with the same id + */ +service AggregatorService { + rpc Channel(stream ProverMessage) returns (stream AggregatorMessage) {} +} + +message AggregatorMessage +{ + string id = 1; + oneof request + { + GetStatusRequest get_status_request = 2; + GenBatchProofRequest gen_batch_proof_request = 3; + GenAggregatedProofRequest gen_aggregated_proof_request = 4; + GenFinalProofRequest gen_final_proof_request = 5; + CancelRequest cancel_request = 6; + GetProofRequest get_proof_request = 7; + GenStatelessBatchProofRequest gen_stateless_batch_proof_request = 8; + } +} + +message ProverMessage +{ + string id = 1; + oneof response + { + GetStatusResponse get_status_response = 2; + GenBatchProofResponse gen_batch_proof_response = 3; + GenAggregatedProofResponse gen_aggregated_proof_response = 4; + GenFinalProofResponse gen_final_proof_response = 5; + CancelResponse cancel_response = 6; + GetProofResponse get_proof_response = 7; + } +} + +/////////////////// +// Request messages +/////////////////// + +/** + * @dev GetStatusRequest + */ +message GetStatusRequest {} + +/** + * @dev GenBatchProofRequest + * @param {input} - input prover + */ +message GenBatchProofRequest { + InputProver input = 1; +} + +message GenStatelessBatchProofRequest { + StatelessInputProver input = 1; +} + +/** + * @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 + */ +message GenAggregatedProofRequest { + string recursive_proof_1 = 1; + string recursive_proof_2 = 2; +} + +/** + * @dev GenFinalProofRequest + * @param {recursive_proof} - proof json of the batch or aggregated proof to finalise + * @param {aggregator_addr} - address of the aggregator + */ +message GenFinalProofRequest { + string recursive_proof = 1; + string aggregator_addr = 2; +} + +/** + * @dev CancelRequest + * @param {id} - identifier of the proof request to cancel + */ + message CancelRequest { + string id = 1; +} + +/** + * @dev Request GetProof + * @param {id} - proof identifier of the proof request + * @param {timeout} - time to wait until the service responds + */ +message GetProofRequest { + string id = 1; + uint64 timeout = 2; +} + +///////////////////// +// Responses messages +///////////////////// + +/** + * @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 + */ +message GetStatusResponse { + enum Status { + STATUS_UNSPECIFIED = 0; + STATUS_BOOTING = 1; + STATUS_COMPUTING = 2; + STATUS_IDLE = 3; + STATUS_HALT = 4; + } + Status status = 1; + string last_computed_request_id = 2; + uint64 last_computed_end_time = 3; + string current_computing_request_id = 4; + uint64 current_computing_start_time = 5; + string version_proto = 6; + string version_server = 7; + repeated string pending_request_queue_ids = 8; + string prover_name = 9; + string prover_id = 10; + uint64 number_of_cores = 11; + uint64 total_memory = 12; + uint64 free_memory = 13; + uint64 fork_id = 14; +} + +/** + * @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 + */ +enum Result { + RESULT_UNSPECIFIED = 0; + RESULT_OK = 1; + RESULT_ERROR = 2; + RESULT_INTERNAL_ERROR = 3; +} + +/** + * @dev GenBatchProofResponse + * @param {id} - proof identifier, to be used in GetProofRequest() + * @param {result} - request result + */ +message GenBatchProofResponse { + string id = 1; + Result result = 2; +} + +/** + * @dev GenAggregatedProofResponse + * @param {id} - proof identifier, to be used in GetProofRequest() + * @param {result} - request result + */ +message GenAggregatedProofResponse { + string id = 1; + Result result = 2; +} + +/** + * @dev Response GenFinalProof + * @param {id} - proof identifier, to be used in GetProofRequest() + * @param {result} - request result + */ +message GenFinalProofResponse { + string id = 1; + Result result = 2; +} + +/** + * @dev CancelResponse + * @param {result} - request result + */ +message CancelResponse { + Result result = 1; +} + +/** + * @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 + */ +message GetProofResponse { + enum Result { + RESULT_UNSPECIFIED = 0; + RESULT_COMPLETED_OK = 1; + RESULT_ERROR = 2; + RESULT_COMPLETED_ERROR = 3; + RESULT_PENDING = 4; + RESULT_INTERNAL_ERROR = 5; + RESULT_CANCEL = 6; + } + string id = 1; + oneof proof { + FinalProof final_proof = 2; + string recursive_proof =3; + } + Result result = 4; + string result_string = 5; +} + +/* + * @dev FinalProof + * @param {proof} - groth16 proof + * @param {public} - public circuit inputs +*/ +message FinalProof { + string proof = 1; + PublicInputsExtended public = 2; +} + +/* + * @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} + */ +message PublicInputs { + bytes old_state_root = 1; + bytes old_acc_input_hash = 2; + uint64 old_batch_num = 3; + uint64 chain_id = 4; + uint64 fork_id = 5; + bytes batch_l2_data = 6; + bytes l1_info_root = 7; + uint64 timestamp_limit = 8; + string sequencer_addr = 9; + bytes forced_blockhash_l1 = 10; + string aggregator_addr = 12; + map l1_info_tree_data = 16; +} + +message StatelessPublicInputs { + bytes witness = 1; + bytes old_acc_input_hash = 2; + uint64 old_batch_num = 3; + uint64 chain_id = 4; + uint64 fork_id = 5; + bytes batch_l2_data = 6; + bytes l1_info_root = 7; + uint64 timestamp_limit = 8; + string sequencer_addr = 9; + bytes forced_blockhash_l1 = 10; + string aggregator_addr = 11; + map l1_info_tree_data = 12; +} + +// l1InfoTree leaf values +message L1Data { + bytes global_exit_root = 1; + bytes blockhash_l1 = 2; + uint32 min_timestamp = 3; + repeated bytes smt_proof = 4; +} + +/** + * @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 + */ +message InputProver { + PublicInputs public_inputs = 1; + map db = 4; // For debug/testing purpposes only. Don't fill this on production + map contracts_bytecode = 5; // For debug/testing purpposes only. Don't fill this on production +} + +message StatelessInputProver { + StatelessPublicInputs public_inputs = 1; +} + +/** + * @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. + */ +message PublicInputsExtended { + PublicInputs public_inputs = 1; + bytes new_state_root = 2; + bytes new_acc_input_hash = 3; + bytes new_local_exit_root = 4; + uint64 new_batch_num = 5; +} diff --git a/proto/src/proto/datastream/v1/datastream.proto b/proto/src/proto/datastream/v1/datastream.proto new file mode 100644 index 00000000..a93f0ab3 --- /dev/null +++ b/proto/src/proto/datastream/v1/datastream.proto @@ -0,0 +1,90 @@ +syntax = "proto3"; + +package datastream.v1; + +option go_package = "github.com/0xPolygon/cdk"state/datastream"; + +message BatchStart { + uint64 number = 1; + BatchType type = 2; + uint64 fork_id = 3; + uint64 chain_id = 4; + Debug debug = 5; +} + +message BatchEnd { + uint64 number = 1; + bytes local_exit_root = 2; + bytes state_root = 3; + Debug debug = 4; +} + +message L2Block { + uint64 number = 1; + uint64 batch_number = 2; + uint64 timestamp = 3; + uint32 delta_timestamp = 4; + uint64 min_timestamp = 5; + bytes l1_blockhash = 6; + uint32 l1_infotree_index = 7; + bytes hash = 8; + bytes state_root = 9; + bytes global_exit_root = 10; + bytes coinbase = 11; + uint64 block_gas_limit = 12; + bytes block_info_root = 13; + Debug debug = 14; +} + +message Transaction { + uint64 l2block_number = 1; + uint64 index = 2; + bool is_valid = 3; + bytes encoded = 4; + uint32 effective_gas_price_percentage = 5; + bytes im_state_root = 6; + Debug debug = 7; +} + +message UpdateGER { + uint64 batch_number = 1; + uint64 timestamp = 2; + bytes global_exit_root = 3; + bytes coinbase = 4; + uint64 fork_id = 5; + uint64 chain_id = 6; + bytes state_root = 7; + Debug debug = 8; +} + +message BookMark { + BookmarkType type = 1; + uint64 value = 2; +} + +message Debug { + string message = 1; +} + +enum BookmarkType { + BOOKMARK_TYPE_UNSPECIFIED = 0; + BOOKMARK_TYPE_BATCH = 1; + BOOKMARK_TYPE_L2_BLOCK = 2; +} + +enum EntryType { + ENTRY_TYPE_UNSPECIFIED = 0; + ENTRY_TYPE_BATCH_START = 1; + ENTRY_TYPE_L2_BLOCK = 2; + ENTRY_TYPE_TRANSACTION = 3; + ENTRY_TYPE_BATCH_END = 4; + ENTRY_TYPE_UPDATE_GER = 5; +} + +enum BatchType { + BATCH_TYPE_UNSPECIFIED = 0; + BATCH_TYPE_REGULAR = 1; + BATCH_TYPE_FORCED = 2; + BATCH_TYPE_INJECTED = 3; + BATCH_TYPE_INVALID = 4; +} diff --git a/sequencesender/config.go b/sequencesender/config.go new file mode 100644 index 00000000..58fa01d8 --- /dev/null +++ b/sequencesender/config.go @@ -0,0 +1,77 @@ +package sequencesender + +import ( + "github.com/0xPolygon/cdk/config/types" + "github.com/0xPolygon/cdk/log" + "github.com/0xPolygonHermez/zkevm-ethtx-manager/ethtxmanager" + "github.com/ethereum/go-ethereum/common" +) + +// Config represents the configuration of a sequence sender +type Config struct { + // IsValidiumMode has the value true if the sequence sender is running in validium mode. + IsValidiumMode bool `mapstructure:"IsValidiumMode"` + // WaitPeriodSendSequence is the time the sequencer waits until + // trying to send a sequence to L1 + WaitPeriodSendSequence types.Duration `mapstructure:"WaitPeriodSendSequence"` + // LastBatchVirtualizationTimeMaxWaitPeriod is time since sequences should be sent + LastBatchVirtualizationTimeMaxWaitPeriod types.Duration `mapstructure:"LastBatchVirtualizationTimeMaxWaitPeriod"` + // L1BlockTimestampMargin is the time difference (margin) that must exists between last L1 block and last L2 block in the sequence before + // to send the sequence to L1. If the difference is lower than this value then sequencesender will wait until the difference is equal or greater + L1BlockTimestampMargin types.Duration `mapstructure:"L1BlockTimestampMargin"` + // MaxTxSizeForL1 is the maximum size a single transaction can have. This field has + // non-trivial consequences: larger transactions than 128KB are significantly harder and + // more expensive to propagate; larger transactions also take more resources + // to validate whether they fit into the pool or not. + MaxTxSizeForL1 uint64 `mapstructure:"MaxTxSizeForL1"` + // SenderAddress defines which private key the eth tx manager needs to use + // to sign the L1 txs + SenderAddress common.Address + // L2Coinbase defines which address is going to receive the fees + L2Coinbase common.Address `mapstructure:"L2Coinbase"` + // PrivateKey defines all the key store files that are going + // to be read in order to provide the private keys to sign the L1 txs + PrivateKey types.KeystoreFileConfig `mapstructure:"PrivateKey"` + // Batch number where there is a forkid change (fork upgrade) + ForkUpgradeBatchNumber uint64 + // GasOffset is the amount of gas to be added to the gas estimation in order + // to provide an amount that is higher than the estimated one. This is used + // to avoid the TX getting reverted in case something has changed in the network + // state after the estimation which can cause the TX to require more gas to be + // executed. + // + // ex: + // gas estimation: 1000 + // gas offset: 100 + // final gas: 1100 + GasOffset uint64 `mapstructure:"GasOffset"` + + // SequencesTxFileName is the file name to store sequences sent to L1 + SequencesTxFileName string + + // WaitPeriodPurgeTxFile is the time to wait before purging from file the finished sent L1 tx + WaitPeriodPurgeTxFile types.Duration `mapstructure:"WaitPeriodPurgeTxFile"` + + // MaxPendingTx is the maximum number of pending transactions (those that are not in a final state) + MaxPendingTx uint64 + + // StreamClient is the config for the stream client + StreamClient StreamClientCfg `mapstructure:"StreamClient"` + + // EthTxManager is the config for the ethtxmanager + EthTxManager ethtxmanager.Config `mapstructure:"EthTxManager"` + + // Log is the log configuration + Log log.Config `mapstructure:"Log"` + + // MaxBatchesForL1 is the maximum amount of batches to be sequenced in a single L1 tx + MaxBatchesForL1 uint64 `mapstructure:"MaxBatchesForL1"` +} + +// StreamClientCfg contains the data streamer's configuration properties +type StreamClientCfg struct { + // Datastream server to connect + Server string `mapstructure:"Server"` + // Log is the log configuration + Log log.Config `mapstructure:"Log"` +} diff --git a/sequencesender/sequencesender.go b/sequencesender/sequencesender.go new file mode 100644 index 00000000..cea66a97 --- /dev/null +++ b/sequencesender/sequencesender.go @@ -0,0 +1,1184 @@ +package sequencesender + +import ( + "context" + "encoding/json" + "errors" + "fmt" + "math" + "math/big" + "os" + "strings" + "sync" + "time" + + "github.com/0xPolygon/cdk/dataavailability" + "github.com/0xPolygon/cdk/etherman" + "github.com/0xPolygon/cdk/etherman/types" + "github.com/0xPolygon/cdk/log" + "github.com/0xPolygon/cdk/state" + "github.com/0xPolygon/cdk/state/datastream" + "github.com/0xPolygonHermez/zkevm-data-streamer/datastreamer" + "github.com/0xPolygonHermez/zkevm-ethtx-manager/ethtxmanager" + ethtxlog "github.com/0xPolygonHermez/zkevm-ethtx-manager/log" + "github.com/ethereum/go-ethereum/common" + "google.golang.org/protobuf/proto" +) + +var ( + // ErrOversizedData when transaction input data is greater than a limit (DOS protection) + ErrOversizedData = errors.New("oversized data") +) + +// SequenceSender represents a sequence sender +type SequenceSender struct { + cfg Config + ethTxManager *ethtxmanager.Client + etherman *etherman.Client + currentNonce uint64 + latestVirtualBatch uint64 // Latest virtualized batch obtained from L1 + latestVirtualTime time.Time // Latest virtual batch timestamp + latestSentToL1Batch uint64 // Latest batch sent to L1 + wipBatch uint64 // Work in progress batch + sequenceList []uint64 // Sequence of batch number to be send to L1 + sequenceData map[uint64]*sequenceData // All the batch data indexed by batch number + mutexSequence sync.Mutex // Mutex to access sequenceData and sequenceList + ethTransactions map[common.Hash]*ethTxData // All the eth tx sent to L1 indexed by hash + ethTxData map[common.Hash][]byte // Tx data send to or received from L1 + mutexEthTx sync.Mutex // Mutex to access ethTransactions + sequencesTxFile *os.File // Persistence of sent transactions + validStream bool // Not valid while receiving data before the desired batch + fromStreamBatch uint64 // Initial batch to connect to the streaming + latestStreamBatch uint64 // Latest batch received by the streaming + seqSendingStopped bool // If there is a critical error + streamClient *datastreamer.StreamClient + da *dataavailability.DataAvailability +} + +type sequenceData struct { + batchClosed bool + batch *types.Sequence + batchRaw *state.BatchRawV2 +} + +type ethTxData struct { + Nonce uint64 `json:"nonce"` + Status string `json:"status"` + SentL1Timestamp time.Time `json:"sentL1Timestamp"` + StatusTimestamp time.Time `json:"statusTimestamp"` + FromBatch uint64 `json:"fromBatch"` + ToBatch uint64 `json:"toBatch"` + MinedAtBlock big.Int `json:"minedAtBlock"` + OnMonitor bool `json:"onMonitor"` + To common.Address `json:"to"` + StateHistory []string `json:"stateHistory"` + Txs map[common.Hash]ethTxAdditionalData `json:"txs"` +} + +type ethTxAdditionalData struct { + GasPrice *big.Int `json:"gasPrice,omitempty"` + RevertMessage string `json:"revertMessage,omitempty"` +} + +// New inits sequence sender +func New(cfg Config, etherman *etherman.Client, da *dataavailability.DataAvailability) (*SequenceSender, error) { + // Create sequencesender + s := SequenceSender{ + cfg: cfg, + etherman: etherman, + ethTransactions: make(map[common.Hash]*ethTxData), + ethTxData: make(map[common.Hash][]byte), + sequenceData: make(map[uint64]*sequenceData), + validStream: false, + latestStreamBatch: 0, + seqSendingStopped: false, + da: da, + } + + // Restore pending sent sequences + err := s.loadSentSequencesTransactions() + if err != nil { + log.Fatalf("[SeqSender] error restoring sent sequences from file", err) + return nil, err + } + + // Create ethtxmanager client + cfg.EthTxManager.Log = ethtxlog.Config{ + Environment: ethtxlog.LogEnvironment(cfg.Log.Environment), + Level: cfg.Log.Level, + Outputs: cfg.Log.Outputs, + } + s.ethTxManager, err = ethtxmanager.New(cfg.EthTxManager) + if err != nil { + log.Fatalf("[SeqSender] error creating ethtxmanager client: %v", err) + return nil, err + } + + // Create datastream client + s.streamClient, err = datastreamer.NewClient(s.cfg.StreamClient.Server, 1) + if err != nil { + log.Fatalf("[SeqSender] failed to create stream client, error: %v", err) + } else { + log.Infof("[SeqSender] new stream client") + } + // Set func to handle the streaming + s.streamClient.SetProcessEntryFunc(s.handleReceivedDataStream) + + return &s, nil +} + +// Start starts the sequence sender +func (s *SequenceSender) Start(ctx context.Context) { + // Start ethtxmanager client + go s.ethTxManager.Start() + + // Get current nonce + var err error + s.currentNonce, err = s.etherman.CurrentNonce(ctx, s.cfg.L2Coinbase) + if err != nil { + log.Fatalf("[SeqSender] failed to get current nonce from %v, error: %v", s.cfg.L2Coinbase, err) + } else { + log.Infof("[SeqSender] current nonce for %v is %d", s.cfg.L2Coinbase, s.currentNonce) + } + + // Get latest virtual state batch from L1 + err = s.updateLatestVirtualBatch() + if err != nil { + log.Fatalf("[SeqSender] error getting latest sequenced batch, error: %v", err) + } + + // Sync all monitored sent L1 tx + err = s.syncAllEthTxResults(ctx) + if err != nil { + log.Fatalf("[SeqSender] failed to sync monitored tx results, error: %v", err) + } + + // Start datastream client + err = s.streamClient.Start() + if err != nil { + log.Fatalf("[SeqSender] failed to start stream client, error: %v", err) + } + + // Set starting point of the streaming + s.fromStreamBatch = s.latestVirtualBatch + + bookmark := &datastream.BookMark{ + Type: datastream.BookmarkType_BOOKMARK_TYPE_BATCH, + Value: s.fromStreamBatch, + } + + marshalledBookmark, err := proto.Marshal(bookmark) + if err != nil { + log.Fatalf("[SeqSender] failed to marshal bookmark, error: %v", err) + } + + log.Infof("[SeqSender] stream client from bookmark %v", bookmark) + + // Current batch to sequence + s.wipBatch = s.latestVirtualBatch + 1 + s.latestSentToL1Batch = s.latestVirtualBatch + + // Start sequence sending + go s.sequenceSending(ctx) + + // Start receiving the streaming + err = s.streamClient.ExecCommandStartBookmark(marshalledBookmark) + if err != nil { + log.Fatalf("[SeqSender] failed to connect to the streaming: %v", err) + } +} + +// sequenceSending starts loop to check if there are sequences to send and sends them if it's convenient +func (s *SequenceSender) sequenceSending(ctx context.Context) { + for { + s.tryToSendSequence(ctx) + time.Sleep(s.cfg.WaitPeriodSendSequence.Duration) + } +} + +// purgeSequences purges batches from memory structures +func (s *SequenceSender) purgeSequences() { + // If sequence sending is stopped, do not purge + if s.seqSendingStopped { + return + } + + // Purge the information of batches that are already virtualized + s.mutexSequence.Lock() + truncateUntil := 0 + toPurge := make([]uint64, 0) + for i := 0; i < len(s.sequenceList); i++ { + batchNumber := s.sequenceList[i] + if batchNumber <= s.latestVirtualBatch { + truncateUntil = i + 1 + toPurge = append(toPurge, batchNumber) + } + } + + if len(toPurge) > 0 { + s.sequenceList = s.sequenceList[truncateUntil:] + + var firstPurged uint64 + var lastPurged uint64 + for i := 0; i < len(toPurge); i++ { + if i == 0 { + firstPurged = toPurge[i] + } + if i == len(toPurge)-1 { + lastPurged = toPurge[i] + } + delete(s.sequenceData, toPurge[i]) + } + log.Infof("[SeqSender] batches purged count: %d, fromBatch: %d, toBatch: %d", len(toPurge), firstPurged, lastPurged) + } + s.mutexSequence.Unlock() +} + +// purgeEthTx purges transactions from memory structures +func (s *SequenceSender) purgeEthTx(ctx context.Context) { + // If sequence sending is stopped, do not purge + if s.seqSendingStopped { + return + } + + // Purge old transactions that are finalized + s.mutexEthTx.Lock() + timePurge := time.Now().Add(-s.cfg.WaitPeriodPurgeTxFile.Duration) + toPurge := make([]common.Hash, 0) + for hash, data := range s.ethTransactions { + if !data.StatusTimestamp.Before(timePurge) { + continue + } + + if !data.OnMonitor || data.Status == ethtxmanager.MonitoredTxStatusFinalized.String() { + toPurge = append(toPurge, hash) + + // Remove from tx monitor + if data.OnMonitor { + err := s.ethTxManager.Remove(ctx, hash) + if err != nil { + log.Warnf("[SeqSender] error removing monitor tx %v from ethtxmanager: %v", hash, err) + } else { + log.Infof("[SeqSender] removed monitor tx %v from ethtxmanager", hash) + } + } + } + } + + if len(toPurge) > 0 { + var firstPurged uint64 = math.MaxUint64 + var lastPurged uint64 + for i := 0; i < len(toPurge); i++ { + if s.ethTransactions[toPurge[i]].Nonce < firstPurged { + firstPurged = s.ethTransactions[toPurge[i]].Nonce + } + if s.ethTransactions[toPurge[i]].Nonce > lastPurged { + lastPurged = s.ethTransactions[toPurge[i]].Nonce + } + delete(s.ethTransactions, toPurge[i]) + delete(s.ethTxData, toPurge[i]) + } + log.Infof("[SeqSender] txs purged count: %d, fromNonce: %d, toNonce: %d", len(toPurge), firstPurged, lastPurged) + } + s.mutexEthTx.Unlock() +} + +// syncEthTxResults syncs results from L1 for transactions in the memory structure +func (s *SequenceSender) syncEthTxResults(ctx context.Context) (uint64, error) { + s.mutexEthTx.Lock() + var txPending uint64 + var txSync uint64 + for hash, data := range s.ethTransactions { + if data.Status == ethtxmanager.MonitoredTxStatusFinalized.String() { + continue + } + + _ = s.getResultAndUpdateEthTx(ctx, hash) + txSync++ + txStatus := s.ethTransactions[hash].Status + // Count if it is not in a final state + if s.ethTransactions[hash].OnMonitor && + txStatus != ethtxmanager.MonitoredTxStatusFailed.String() && + txStatus != ethtxmanager.MonitoredTxStatusSafe.String() && + txStatus != ethtxmanager.MonitoredTxStatusFinalized.String() { + txPending++ + } + } + s.mutexEthTx.Unlock() + + // Save updated sequences transactions + err := s.saveSentSequencesTransactions(ctx) + if err != nil { + log.Errorf("[SeqSender] error saving tx sequence, error: %v", err) + } + + log.Infof("[SeqSender] %d tx results synchronized (%d in pending state)", txSync, txPending) + return txPending, nil +} + +// syncAllEthTxResults syncs all tx results from L1 +func (s *SequenceSender) syncAllEthTxResults(ctx context.Context) error { + // Get all results + results, err := s.ethTxManager.ResultsByStatus(ctx, nil) + if err != nil { + log.Warnf("[SeqSender] error getting results for all tx: %v", err) + return err + } + + // Check and update tx status + numResults := len(results) + s.mutexEthTx.Lock() + for _, result := range results { + txSequence, exists := s.ethTransactions[result.ID] + if !exists { + log.Infof("[SeqSender] transaction %v missing in memory structure. Adding it", result.ID) + // No info: from/to batch and the sent timestamp + s.ethTransactions[result.ID] = ðTxData{ + SentL1Timestamp: time.Time{}, + StatusTimestamp: time.Now(), + OnMonitor: true, + Status: "*missing", + } + txSequence = s.ethTransactions[result.ID] + } + + s.updateEthTxResult(txSequence, result) + } + s.mutexEthTx.Unlock() + + // Save updated sequences transactions + err = s.saveSentSequencesTransactions(ctx) + if err != nil { + log.Errorf("[SeqSender] error saving tx sequence, error: %v", err) + } + + log.Infof("[SeqSender] %d tx results synchronized", numResults) + return nil +} + +// copyTxData copies tx data in the internal structure +func (s *SequenceSender) copyTxData(txHash common.Hash, txData []byte, txsResults map[common.Hash]ethtxmanager.TxResult) { + s.ethTxData[txHash] = make([]byte, len(txData)) + copy(s.ethTxData[txHash], txData) + + s.ethTransactions[txHash].Txs = make(map[common.Hash]ethTxAdditionalData, 0) + for hash, result := range txsResults { + var gasPrice *big.Int + if result.Tx != nil { + gasPrice = result.Tx.GasPrice() + } + + add := ethTxAdditionalData{ + GasPrice: gasPrice, + RevertMessage: result.RevertMessage, + } + s.ethTransactions[txHash].Txs[hash] = add + } +} + +// updateEthTxResult handles updating transaction state +func (s *SequenceSender) updateEthTxResult(txData *ethTxData, txResult ethtxmanager.MonitoredTxResult) { + if txData.Status != txResult.Status.String() { + log.Infof("[SeqSender] update transaction %v to state %s", txResult.ID, txResult.Status.String()) + txData.StatusTimestamp = time.Now() + stTrans := txData.StatusTimestamp.Format("2006-01-02T15:04:05.000-07:00") + ", " + txData.Status + ", " + txResult.Status.String() + txData.Status = txResult.Status.String() + txData.StateHistory = append(txData.StateHistory, stTrans) + + // Manage according to the state + statusConsolidated := txData.Status == ethtxmanager.MonitoredTxStatusSafe.String() || txData.Status == ethtxmanager.MonitoredTxStatusFinalized.String() + if txData.Status == ethtxmanager.MonitoredTxStatusFailed.String() { + s.logFatalf("[SeqSender] transaction %v result failed!") + } else if statusConsolidated && txData.ToBatch >= s.latestVirtualBatch { + s.latestVirtualTime = txData.StatusTimestamp + } + } + + // Update info received from L1 + txData.Nonce = txResult.Nonce + if txResult.To != nil { + txData.To = *txResult.To + } + if txResult.MinedAtBlockNumber != nil { + txData.MinedAtBlock = *txResult.MinedAtBlockNumber + } + s.copyTxData(txResult.ID, txResult.Data, txResult.Txs) +} + +// getResultAndUpdateEthTx updates the tx status from the ethTxManager +func (s *SequenceSender) getResultAndUpdateEthTx(ctx context.Context, txHash common.Hash) error { + txData, exists := s.ethTransactions[txHash] + if !exists { + log.Errorf("[SeqSender] transaction %v not found in memory", txHash) + return errors.New("transaction not found in memory structure") + } + + txResult, err := s.ethTxManager.Result(ctx, txHash) + if err == ethtxmanager.ErrNotFound { + log.Infof("[SeqSender] transaction %v does not exist in ethtxmanager. Marking it", txHash) + txData.OnMonitor = false + // Resend tx + errSend := s.sendTx(ctx, true, &txHash, nil, 0, 0, nil) + if errSend == nil { + txData.OnMonitor = false + } + } else if err != nil { + log.Errorf("[SeqSender] error getting result for tx %v: %v", txHash, err) + return err + } else { + s.updateEthTxResult(txData, txResult) + } + + return nil +} + +// tryToSendSequence checks if there is a sequence and it's worth it to send to L1 +func (s *SequenceSender) tryToSendSequence(ctx context.Context) { + // Update latest virtual batch + log.Infof("[SeqSender] updating virtual batch") + err := s.updateLatestVirtualBatch() + if err != nil { + return + } + + // Update state of transactions + log.Infof("[SeqSender] updating tx results") + countPending, err := s.syncEthTxResults(ctx) + if err != nil { + return + } + + // Check if the sequence sending is stopped + if s.seqSendingStopped { + log.Warnf("[SeqSender] sending is stopped!") + return + } + + // Check if reached the maximum number of pending transactions + if countPending >= s.cfg.MaxPendingTx { + log.Infof("[SeqSender] max number of pending txs (%d) reached. Waiting for some to be completed", countPending) + return + } + + // Check if should send sequence to L1 + log.Infof("[SeqSender] getting sequences to send") + sequences, err := s.getSequencesToSend() + if err != nil || len(sequences) == 0 { + if err != nil { + log.Errorf("[SeqSender] error getting sequences: %v", err) + } + return + } + + // Send sequences to L1 + sequenceCount := len(sequences) + firstSequence := sequences[0] + lastSequence := sequences[sequenceCount-1] + lastL2BlockTimestamp := lastSequence.LastL2BLockTimestamp + + log.Infof("[SeqSender] sending sequences to L1. From batch %d to batch %d", firstSequence.BatchNumber, lastSequence.BatchNumber) + printSequences(sequences) + + // Wait until last L1 block timestamp is L1BlockTimestampMargin seconds above the timestamp of the last L2 block in the sequence + timeMargin := int64(s.cfg.L1BlockTimestampMargin.Seconds()) + for { + // Get header of the last L1 block + lastL1BlockHeader, err := s.etherman.GetLatestBlockHeader(ctx) + if err != nil { + log.Errorf("[SeqSender] failed to get last L1 block timestamp, err: %v", err) + return + } + + elapsed, waitTime := s.marginTimeElapsed(lastL2BlockTimestamp, lastL1BlockHeader.Time, timeMargin) + + if !elapsed { + log.Infof("[SeqSender] waiting at least %d seconds to send sequences, time difference between last L1 block %d (ts: %d) and last L2 block %d (ts: %d) in the sequence is lower than %d seconds", + waitTime, lastL1BlockHeader.Number, lastL1BlockHeader.Time, lastSequence.BatchNumber, lastL2BlockTimestamp, timeMargin) + time.Sleep(time.Duration(waitTime) * time.Second) + } else { + log.Infof("[SeqSender] continuing, time difference between last L1 block %d (ts: %d) and last L2 block %d (ts: %d) in the sequence is greater than %d seconds", + lastL1BlockHeader.Number, lastL1BlockHeader.Time, lastSequence.BatchNumber, lastL2BlockTimestamp, timeMargin) + break + } + } + + // Sanity check: Wait also until current time is L1BlockTimestampMargin seconds above the timestamp of the last L2 block in the sequence + for { + currentTime := uint64(time.Now().Unix()) + + elapsed, waitTime := s.marginTimeElapsed(lastL2BlockTimestamp, currentTime, timeMargin) + + // Wait if the time difference is less than L1BlockTimestampMargin + if !elapsed { + log.Infof("[SeqSender] waiting at least %d seconds to send sequences, time difference between now (ts: %d) and last L2 block %d (ts: %d) in the sequence is lower than %d seconds", + waitTime, currentTime, lastSequence.BatchNumber, lastL2BlockTimestamp, timeMargin) + time.Sleep(time.Duration(waitTime) * time.Second) + } else { + log.Infof("[SeqSender]sending sequences now, time difference between now (ts: %d) and last L2 block %d (ts: %d) in the sequence is also greater than %d seconds", + currentTime, lastSequence.BatchNumber, lastL2BlockTimestamp, timeMargin) + break + } + } + + // Send sequences to L1 + log.Infof("[SeqSender] sending sequences to L1. From batch %d to batch %d", firstSequence.BatchNumber, lastSequence.BatchNumber) + printSequences(sequences) + + // Post sequences to DA backend + var dataAvailabilityMessage []byte + if s.cfg.IsValidiumMode { + dataAvailabilityMessage, err = s.da.PostSequence(ctx, sequences) + if err != nil { + log.Error("error posting sequences to the data availability protocol: ", err) + return + } + } + + // Build sequence data + tx, err := s.etherman.BuildSequenceBatchesTx(s.cfg.SenderAddress, sequences, lastSequence.LastL2BLockTimestamp, firstSequence.BatchNumber-1, s.cfg.L2Coinbase, dataAvailabilityMessage) + if err != nil { + log.Errorf("[SeqSender] error estimating new sequenceBatches to add to ethtxmanager: ", err) + return + } + + // Add sequence tx + err = s.sendTx(ctx, false, nil, tx.To(), firstSequence.BatchNumber, lastSequence.BatchNumber, tx.Data()) + if err != nil { + return + } + + // Purge sequences data from memory + s.purgeSequences() +} + +// sendTx adds transaction to the ethTxManager to send it to L1 +func (s *SequenceSender) sendTx(ctx context.Context, resend bool, txOldHash *common.Hash, to *common.Address, fromBatch uint64, toBatch uint64, data []byte) error { + // Params if new tx to send or resend a previous tx + var paramTo *common.Address + var paramNonce *uint64 + var paramData []byte + var valueFromBatch uint64 + var valueToBatch uint64 + var valueToAddress common.Address + + if !resend { + paramTo = to + paramNonce = &s.currentNonce + paramData = data + valueFromBatch = fromBatch + valueToBatch = toBatch + } else { + if txOldHash == nil { + log.Errorf("[SeqSender] trying to resend a tx with nil hash") + return errors.New("resend tx with nil hash monitor id") + } + paramTo = &s.ethTransactions[*txOldHash].To + paramNonce = &s.ethTransactions[*txOldHash].Nonce + paramData = s.ethTxData[*txOldHash] + valueFromBatch = s.ethTransactions[*txOldHash].FromBatch + valueToBatch = s.ethTransactions[*txOldHash].ToBatch + } + if paramTo != nil { + valueToAddress = *paramTo + } + + // Add sequence tx + txHash, err := s.ethTxManager.Add(ctx, paramTo, paramNonce, big.NewInt(0), paramData, s.cfg.GasOffset, nil) + if err != nil { + log.Errorf("[SeqSender] error adding sequence to ethtxmanager: %v", err) + return err + } + if !resend { + s.currentNonce++ + } + + // Add new eth tx + txData := ethTxData{ + SentL1Timestamp: time.Now(), + StatusTimestamp: time.Now(), + Status: "*new", + FromBatch: valueFromBatch, + ToBatch: valueToBatch, + OnMonitor: true, + To: valueToAddress, + } + + // Add tx to internal structure + s.mutexEthTx.Lock() + s.ethTransactions[txHash] = &txData + txResults := make(map[common.Hash]ethtxmanager.TxResult, 0) + s.copyTxData(txHash, paramData, txResults) + _ = s.getResultAndUpdateEthTx(ctx, txHash) + if !resend { + s.latestSentToL1Batch = valueToBatch + } else { + s.ethTransactions[*txOldHash].Status = "*resent" + } + s.mutexEthTx.Unlock() + + // Save sent sequences + err = s.saveSentSequencesTransactions(ctx) + if err != nil { + log.Errorf("[SeqSender] error saving tx sequence sent, error: %v", err) + } + return nil +} + +// getSequencesToSend generates sequences to be sent to L1. Empty array means there are no sequences to send or it's not worth sending +func (s *SequenceSender) getSequencesToSend() ([]types.Sequence, error) { + // Add sequences until too big for a single L1 tx or last batch is reached + s.mutexSequence.Lock() + defer s.mutexSequence.Unlock() + var prevCoinbase common.Address + sequences := []types.Sequence{} + for i := 0; i < len(s.sequenceList); i++ { + batchNumber := s.sequenceList[i] + if batchNumber <= s.latestVirtualBatch || batchNumber <= s.latestSentToL1Batch { + continue + } + + // Check if the next batch belongs to a new forkid, in this case we need to stop sequencing as we need to + // wait the upgrade of forkid is completed and s.cfg.NumBatchForkIdUpgrade is disabled (=0) again + if (s.cfg.ForkUpgradeBatchNumber != 0) && (batchNumber == (s.cfg.ForkUpgradeBatchNumber + 1)) { + return nil, fmt.Errorf("aborting sequencing process as we reached the batch %d where a new forkid is applied (upgrade)", s.cfg.ForkUpgradeBatchNumber+1) + } + + // Check if batch is closed + if !s.sequenceData[batchNumber].batchClosed { + // Reached current wip batch + break + } + + // New potential batch to add to the sequence + batch := *s.sequenceData[batchNumber].batch + + // If the coinbase changes, the sequence ends here + if len(sequences) > 0 && batch.LastCoinbase != prevCoinbase { + log.Infof("[SeqSender] batch with different coinbase (batch %v, sequence %v), sequence will be sent to this point", prevCoinbase, batch.LastCoinbase) + return sequences, nil + } + prevCoinbase = batch.LastCoinbase + + // Add new sequence + sequences = append(sequences, batch) + + if s.cfg.IsValidiumMode { + if len(sequences) == int(s.cfg.MaxBatchesForL1) { + log.Infof( + "[SeqSender] sequence should be sent to L1, because MaxBatchesForL1 (%d) has been reached", + s.cfg.MaxBatchesForL1, + ) + return sequences, nil + } + } else { + firstSequence := sequences[0] + lastSequence := sequences[len(sequences)-1] + + // Check if can be sent + tx, err := s.etherman.BuildSequenceBatchesTx(s.cfg.SenderAddress, sequences, lastSequence.LastL2BLockTimestamp, firstSequence.BatchNumber-1, s.cfg.L2Coinbase, nil) + if err == nil && tx.Size() > s.cfg.MaxTxSizeForL1 { + log.Infof("[SeqSender] oversized Data on TX oldHash %s (txSize %d > %d)", tx.Hash(), tx.Size(), s.cfg.MaxTxSizeForL1) + err = ErrOversizedData + } + + if err != nil { + log.Infof("[SeqSender] handling estimate gas send sequence error: %v", err) + sequences, err = s.handleEstimateGasSendSequenceErr(sequences, batchNumber, err) + if sequences != nil { + // Handling the error gracefully, re-processing the sequence as a sanity check + lastSequence = sequences[len(sequences)-1] + _, err = s.etherman.BuildSequenceBatchesTx(s.cfg.SenderAddress, sequences, lastSequence.LastL2BLockTimestamp, firstSequence.BatchNumber-1, s.cfg.L2Coinbase, nil) + return sequences, err + } + return sequences, err + } + } + + // Check if the current batch is the last before a change to a new forkid, in this case we need to close and send the sequence to L1 + if (s.cfg.ForkUpgradeBatchNumber != 0) && (batchNumber == (s.cfg.ForkUpgradeBatchNumber)) { + log.Infof("[SeqSender] sequence should be sent to L1, as we have reached the batch %d from which a new forkid is applied (upgrade)", s.cfg.ForkUpgradeBatchNumber) + return sequences, nil + } + } + + // Reached the latest batch. Decide if it's worth to send the sequence, or wait for new batches + if len(sequences) == 0 { + log.Infof("[SeqSender] no batches to be sequenced") + return nil, nil + } + + if s.latestVirtualTime.Before(time.Now().Add(-s.cfg.LastBatchVirtualizationTimeMaxWaitPeriod.Duration)) { + log.Infof("[SeqSender] sequence should be sent, too much time without sending anything to L1") + return sequences, nil + } + + log.Infof("[SeqSender] not enough time has passed since last batch was virtualized and the sequence could be bigger") + return nil, nil +} + +// handleEstimateGasSendSequenceErr handles an error on the estimate gas. Results: (nil,nil)=requires waiting, (nil,error)=no handled gracefully, (seq,nil) handled gracefully +func (s *SequenceSender) handleEstimateGasSendSequenceErr(sequences []types.Sequence, currentBatchNumToSequence uint64, err error) ([]types.Sequence, error) { + // Insufficient allowance + if errors.Is(err, etherman.ErrInsufficientAllowance) { + return nil, err + } + if isDataForEthTxTooBig(err) { + // Remove the latest item and send the sequences + log.Infof("Done building sequences, selected batches to %d. Batch %d caused the L1 tx to be too big: %v", currentBatchNumToSequence-1, currentBatchNumToSequence, err) + } else { + // Remove the latest item and send the sequences + log.Infof("Done building sequences, selected batches to %d. Batch %d excluded due to unknown error: %v", currentBatchNumToSequence, currentBatchNumToSequence+1, err) + } + + if len(sequences) > 1 { + sequences = sequences[:len(sequences)-1] + } else { + sequences = nil + } + return sequences, nil +} + +// isDataForEthTxTooBig checks if tx oversize error +func isDataForEthTxTooBig(err error) bool { + return errors.Is(err, etherman.ErrGasRequiredExceedsAllowance) || + errors.Is(err, ErrOversizedData) || + errors.Is(err, etherman.ErrContentLengthTooLarge) +} + +// loadSentSequencesTransactions loads the file into the memory structure +func (s *SequenceSender) loadSentSequencesTransactions() error { + // Check if file exists + if _, err := os.Stat(s.cfg.SequencesTxFileName); os.IsNotExist(err) { + log.Infof("[SeqSender] file not found %s: %v", s.cfg.SequencesTxFileName, err) + return nil + } else if err != nil { + log.Errorf("[SeqSender] error opening file %s: %v", s.cfg.SequencesTxFileName, err) + return err + } + + // Read file + data, err := os.ReadFile(s.cfg.SequencesTxFileName) + if err != nil { + log.Errorf("[SeqSender] error reading file %s: %v", s.cfg.SequencesTxFileName, err) + return err + } + + // Restore memory structure + s.mutexEthTx.Lock() + err = json.Unmarshal(data, &s.ethTransactions) + s.mutexEthTx.Unlock() + if err != nil { + log.Errorf("[SeqSender] error decoding data from %s: %v", s.cfg.SequencesTxFileName, err) + return err + } + + return nil +} + +// saveSentSequencesTransactions saves memory structure into persistent file +func (s *SequenceSender) saveSentSequencesTransactions(ctx context.Context) error { + var err error + + // Purge tx + s.purgeEthTx(ctx) + + // Ceate file + fileName := s.cfg.SequencesTxFileName[0:strings.IndexRune(s.cfg.SequencesTxFileName, '.')] + ".tmp" + s.sequencesTxFile, err = os.Create(fileName) + if err != nil { + log.Errorf("[SeqSender] error creating file %s: %v", fileName, err) + return err + } + defer s.sequencesTxFile.Close() + + // Write data JSON encoded + encoder := json.NewEncoder(s.sequencesTxFile) + encoder.SetIndent("", " ") + s.mutexEthTx.Lock() + err = encoder.Encode(s.ethTransactions) + s.mutexEthTx.Unlock() + if err != nil { + log.Errorf("[SeqSender] error writing file %s: %v", fileName, err) + return err + } + + // Rename the new file + err = os.Rename(fileName, s.cfg.SequencesTxFileName) + if err != nil { + log.Errorf("[SeqSender] error renaming file %s to %s: %v", fileName, s.cfg.SequencesTxFileName, err) + return err + } + + return nil +} + +// handleReceivedDataStream manages the events received by the streaming +func (s *SequenceSender) handleReceivedDataStream(e *datastreamer.FileEntry, c *datastreamer.StreamClient, ss *datastreamer.StreamServer) error { + dsType := datastream.EntryType(e.Type) + + switch dsType { + case datastream.EntryType_ENTRY_TYPE_L2_BLOCK: + // Handle stream entry: L2Block + l2Block := &datastream.L2Block{} + err := proto.Unmarshal(e.Data, l2Block) + if err != nil { + log.Errorf("[SeqSender] error unmarshalling L2Block: %v", err) + return err + } + + // Already virtualized + if l2Block.BatchNumber <= s.fromStreamBatch { + if l2Block.BatchNumber != s.latestStreamBatch { + log.Infof("[SeqSender] skipped! batch already virtualized, number %d", l2Block.BatchNumber) + } + } else if !s.validStream && l2Block.BatchNumber == s.fromStreamBatch+1 { + // Initial case after startup + s.addNewSequenceBatch(l2Block) + s.validStream = true + } + + // Latest stream batch + s.latestStreamBatch = l2Block.BatchNumber + if !s.validStream { + return nil + } + + // Handle whether it's only a new block or also a new batch + if l2Block.BatchNumber > s.wipBatch { + // New batch in the sequence + // Close current batch + err := s.closeSequenceBatch() + if err != nil { + log.Fatalf("[SeqSender] error closing wip batch") + return err + } + + // Create new sequential batch + s.addNewSequenceBatch(l2Block) + } + + // Add L2 block + s.addNewBatchL2Block(l2Block) + + case datastream.EntryType_ENTRY_TYPE_TRANSACTION: + // Handle stream entry: Transaction + if !s.validStream { + return nil + } + + l2Tx := &datastream.Transaction{} + err := proto.Unmarshal(e.Data, l2Tx) + if err != nil { + log.Errorf("[SeqSender] error unmarshalling Transaction: %v", err) + return err + } + + // Add tx data + s.addNewBlockTx(l2Tx) + + case datastream.EntryType_ENTRY_TYPE_BATCH_START: + // Handle stream entry: BatchStart + if !s.validStream { + return nil + } + + batch := &datastream.BatchStart{} + err := proto.Unmarshal(e.Data, batch) + if err != nil { + log.Errorf("[SeqSender] error unmarshalling BatchStart: %v", err) + return err + } + + // Add batch start data + s.addInfoSequenceBatchStart(batch) + + case datastream.EntryType_ENTRY_TYPE_BATCH_END: + // Handle stream entry: BatchEnd + if !s.validStream { + return nil + } + + batch := &datastream.BatchEnd{} + err := proto.Unmarshal(e.Data, batch) + if err != nil { + log.Errorf("[SeqSender] error unmarshalling BatchEnd: %v", err) + return err + } + + // Add batch end data + s.addInfoSequenceBatchEnd(batch) + } + + return nil +} + +// closeSequenceBatch closes the current batch +func (s *SequenceSender) closeSequenceBatch() error { + s.mutexSequence.Lock() + log.Infof("[SeqSender] closing batch %d", s.wipBatch) + + data := s.sequenceData[s.wipBatch] + if data != nil { + data.batchClosed = true + + var err error + data.batch.BatchL2Data, err = state.EncodeBatchV2(data.batchRaw) + if err != nil { + log.Errorf("[SeqSender] error closing and encoding the batch %d: %v", s.wipBatch, err) + return err + } + } + + s.mutexSequence.Unlock() + return nil +} + +// addNewSequenceBatch adds a new batch to the sequence +func (s *SequenceSender) addNewSequenceBatch(l2Block *datastream.L2Block) { + s.mutexSequence.Lock() + log.Infof("[SeqSender] ...new batch, number %d", l2Block.BatchNumber) + + if l2Block.BatchNumber > s.wipBatch+1 { + s.logFatalf("[SeqSender] new batch number (%d) is not consecutive to the current one (%d)", l2Block.BatchNumber, s.wipBatch) + } else if l2Block.BatchNumber < s.wipBatch { + s.logFatalf("[SeqSender] new batch number (%d) is lower than the current one (%d)", l2Block.BatchNumber, s.wipBatch) + } + + // Create sequence + sequence := types.Sequence{ + GlobalExitRoot: common.BytesToHash(l2Block.GlobalExitRoot), + LastL2BLockTimestamp: l2Block.Timestamp, + BatchNumber: l2Block.BatchNumber, + LastCoinbase: common.BytesToAddress(l2Block.Coinbase), + } + + // Add to the list + s.sequenceList = append(s.sequenceList, l2Block.BatchNumber) + + // Create initial data + batchRaw := state.BatchRawV2{} + data := sequenceData{ + batchClosed: false, + batch: &sequence, + batchRaw: &batchRaw, + } + s.sequenceData[l2Block.BatchNumber] = &data + + // Update wip batch + s.wipBatch = l2Block.BatchNumber + s.mutexSequence.Unlock() +} + +// addInfoSequenceBatchStart adds info from the batch start +func (s *SequenceSender) addInfoSequenceBatchStart(batch *datastream.BatchStart) { + s.mutexSequence.Lock() + log.Infof("[SeqSender] batch %d (%s) Start: type %d forkId %d chainId %d", batch.Number, datastream.BatchType_name[int32(batch.Type)], batch.Type, batch.ForkId, batch.ChainId) + + // Current batch + data := s.sequenceData[s.wipBatch] + if data != nil { + wipBatch := data.batch + if wipBatch.BatchNumber+1 != batch.Number { + s.logFatalf("[SeqSender] batch start number (%d) does not match the current consecutive one (%d)", batch.Number, wipBatch.BatchNumber) + } + } + + s.mutexSequence.Unlock() +} + +// addInfoSequenceBatchEnd adds info from the batch end +func (s *SequenceSender) addInfoSequenceBatchEnd(batch *datastream.BatchEnd) { + s.mutexSequence.Lock() + + // Current batch + data := s.sequenceData[s.wipBatch] + if data != nil { + wipBatch := data.batch + if wipBatch.BatchNumber == batch.Number { + wipBatch.StateRoot = common.BytesToHash(batch.StateRoot) + } else { + s.logFatalf("[SeqSender] batch end number (%d) does not match the current one (%d)", batch.Number, wipBatch.BatchNumber) + } + } + + s.mutexSequence.Unlock() +} + +// addNewBatchL2Block adds a new L2 block to the work in progress batch +func (s *SequenceSender) addNewBatchL2Block(l2Block *datastream.L2Block) { + s.mutexSequence.Lock() + log.Infof("[SeqSender] .....new L2 block, number %d (batch %d)", l2Block.Number, l2Block.BatchNumber) + + // Current batch + data := s.sequenceData[s.wipBatch] + if data != nil { + wipBatchRaw := data.batchRaw + data.batch.LastL2BLockTimestamp = l2Block.Timestamp + // Sanity check: should be the same coinbase within the batch + if common.BytesToAddress(l2Block.Coinbase) != data.batch.LastCoinbase { + s.logFatalf("[SeqSender] coinbase changed within the batch! (Previous %v, Current %v)", data.batch.LastCoinbase, common.BytesToAddress(l2Block.Coinbase)) + } + data.batch.LastCoinbase = common.BytesToAddress(l2Block.Coinbase) + data.batch.StateRoot = common.BytesToHash(l2Block.StateRoot) + + // New L2 block raw + newBlockRaw := state.L2BlockRaw{} + + // Add L2 block + wipBatchRaw.Blocks = append(wipBatchRaw.Blocks, newBlockRaw) + + // Update batch timestamp + data.batch.LastL2BLockTimestamp = l2Block.Timestamp + + // Get current L2 block + _, blockRaw := s.getWipL2Block() + if blockRaw == nil { + log.Debugf("[SeqSender] wip block %d not found!") + return + } + + // Fill in data + blockRaw.DeltaTimestamp = l2Block.DeltaTimestamp + blockRaw.IndexL1InfoTree = l2Block.L1InfotreeIndex + } + + s.mutexSequence.Unlock() +} + +// addNewBlockTx adds a new Tx to the current L2 block +func (s *SequenceSender) addNewBlockTx(l2Tx *datastream.Transaction) { + s.mutexSequence.Lock() + log.Debugf("[SeqSender] ........new tx, length %d EGP %d SR %x..", len(l2Tx.Encoded), l2Tx.EffectiveGasPricePercentage, l2Tx.ImStateRoot[:8]) + + // Current L2 block + _, blockRaw := s.getWipL2Block() + + // New Tx raw + tx, err := state.DecodeTx(common.Bytes2Hex(l2Tx.Encoded)) + if err != nil { + log.Fatalf("[SeqSender] error decoding tx!") + return + } + + l2TxRaw := state.L2TxRaw{ + EfficiencyPercentage: uint8(l2Tx.EffectiveGasPricePercentage), + TxAlreadyEncoded: false, + Tx: tx, + } + + // Add Tx + blockRaw.Transactions = append(blockRaw.Transactions, l2TxRaw) + s.mutexSequence.Unlock() +} + +// getWipL2Block returns index of the array and pointer to the current L2 block (helper func) +func (s *SequenceSender) getWipL2Block() (uint64, *state.L2BlockRaw) { + // Current batch + var wipBatchRaw *state.BatchRawV2 + if s.sequenceData[s.wipBatch] != nil { + wipBatchRaw = s.sequenceData[s.wipBatch].batchRaw + } + + // Current wip block + if len(wipBatchRaw.Blocks) > 0 { + blockIndex := uint64(len(wipBatchRaw.Blocks)) - 1 + return blockIndex, &wipBatchRaw.Blocks[blockIndex] + } else { + return 0, nil + } +} + +// updateLatestVirtualBatch queries the value in L1 and updates the latest virtual batch field +func (s *SequenceSender) updateLatestVirtualBatch() error { + // Get latest virtual state batch from L1 + var err error + + s.latestVirtualBatch, err = s.etherman.GetLatestBatchNumber() + if err != nil { + log.Errorf("[SeqSender] error getting latest virtual batch, error: %v", err) + return errors.New("fail to get latest virtual batch") + } else { + log.Infof("[SeqSender] latest virtual batch is %d", s.latestVirtualBatch) + } + return nil +} + +// marginTimeElapsed checks if the time between currentTime and l2BlockTimestamp is greater than timeMargin. +// If it's greater returns true, otherwise it returns false and the waitTime needed to achieve this timeMargin +func (s *SequenceSender) marginTimeElapsed(l2BlockTimestamp uint64, currentTime uint64, timeMargin int64) (bool, int64) { + // Check the time difference between L2 block and currentTime + var timeDiff int64 + if l2BlockTimestamp >= currentTime { + //L2 block timestamp is above currentTime, negative timeDiff. We do in this way to avoid uint64 overflow + timeDiff = int64(-(l2BlockTimestamp - currentTime)) + } else { + timeDiff = int64(currentTime - l2BlockTimestamp) + } + + // Check if the time difference is less than timeMargin (L1BlockTimestampMargin) + if timeDiff < timeMargin { + var waitTime int64 + if timeDiff < 0 { //L2 block timestamp is above currentTime + waitTime = timeMargin + (-timeDiff) + } else { + waitTime = timeMargin - timeDiff + } + return false, waitTime + } else { // timeDiff is greater than timeMargin + return true, 0 + } +} + +// logFatalf logs error, activates flag to stop sequencing, and remains in an infinite loop +func (s *SequenceSender) logFatalf(template string, args ...interface{}) { + s.seqSendingStopped = true + log.Errorf(template, args...) + log.Errorf("[SeqSender] sequence sending stopped.") + for { + time.Sleep(1 * time.Second) + } +} + +// printSequences prints data from slice of type sequences +func printSequences(sequences []types.Sequence) { + for i, seq := range sequences { + log.Debugf("[SeqSender] // sequence(%d): batch: %d, ts: %v, lenData: %d, GER: %x..", i, seq.BatchNumber, seq.LastL2BLockTimestamp, len(seq.BatchL2Data), seq.GlobalExitRoot[:8]) + } +} + +// printBatch prints data from batch raw V2 +func printBatch(raw *state.BatchRawV2, showBlock bool, showTx bool) { + // Total amount of L2 tx in the batch + totalL2Txs := 0 + for k := 0; k < len(raw.Blocks); k++ { + totalL2Txs += len(raw.Blocks[k].Transactions) + } + + log.Debugf("[SeqSender] // #blocks: %d, #L2txs: %d", len(raw.Blocks), totalL2Txs) + + // Blocks info + if showBlock { + numBlocks := len(raw.Blocks) + var firstBlock *state.L2BlockRaw + var lastBlock *state.L2BlockRaw + if numBlocks > 0 { + firstBlock = &raw.Blocks[0] + } + if numBlocks > 1 { + lastBlock = &raw.Blocks[numBlocks-1] + } + if firstBlock != nil { + log.Debugf("[SeqSender] // block first (indL1info: %d, delta-timestamp: %d, #L2txs: %d)", firstBlock.IndexL1InfoTree, firstBlock.DeltaTimestamp, len(firstBlock.Transactions)) + // Tx info + if showTx { + for iTx, tx := range firstBlock.Transactions { + v, r, s := tx.Tx.RawSignatureValues() + log.Debugf("[SeqSender] // tx(%d) effPct: %d, encoded: %t, v: %v, r: %v, s: %v", iTx, tx.EfficiencyPercentage, tx.TxAlreadyEncoded, v, r, s) + } + } + } + if lastBlock != nil { + log.Debugf("[SeqSender] // block last (indL1info: %d, delta-timestamp: %d, #L2txs: %d)", lastBlock.DeltaTimestamp, lastBlock.DeltaTimestamp, len(lastBlock.Transactions)) + } + } +} diff --git a/sequencesender/sequencesender_test.go b/sequencesender/sequencesender_test.go new file mode 100644 index 00000000..ca0d33e7 --- /dev/null +++ b/sequencesender/sequencesender_test.go @@ -0,0 +1,65 @@ +package sequencesender + +import ( + "testing" + + "github.com/0xPolygon/cdk/log" + "github.com/0xPolygon/cdk/state" + "github.com/ethereum/go-ethereum/common" + "github.com/stretchr/testify/require" +) + +const ( + txStreamEncoded1 = "f86508843b9aca0082520894617b3a3528f9cdd6630fd3301b9c8911f7bf063d0a808207f5a0579b72a1c1ffdd845fba45317540982109298e2ec8d67ddf2cdaf22e80903677a01831e9a01291c7ea246742a5b5a543ca6938bfc3f6958c22be06fad99274e4ac" + txStreamEncoded2 = "f86509843b9aca0082520894617b3a3528f9cdd6630fd3301b9c8911f7bf063d0a808207f5a0908a522075e09485166ffa7630cd2b7013897fa1f1238013677d6f0a86efb3d2a0068b12435fcdc8ee254f3b1df8c5b29ed691eeee6065704f061130935976ca99" +) + +func TestStreamTx(t *testing.T) { + tx1, err := state.DecodeTx(txStreamEncoded1) + require.NoError(t, err) + tx2, err := state.DecodeTx(txStreamEncoded2) + require.NoError(t, err) + + txTest := state.L2TxRaw{ + EfficiencyPercentage: 129, + TxAlreadyEncoded: false, + Tx: tx1, + } + txTestEncoded := make([]byte, 0) + txTestEncoded, err = txTest.Encode(txTestEncoded) + require.NoError(t, err) + log.Debugf("%s", common.Bytes2Hex(txTestEncoded)) + + batch := state.BatchRawV2{ + Blocks: []state.L2BlockRaw{ + { + ChangeL2BlockHeader: state.ChangeL2BlockHeader{ + DeltaTimestamp: 3633752, + IndexL1InfoTree: 0, + }, + Transactions: []state.L2TxRaw{ + { + EfficiencyPercentage: 129, + TxAlreadyEncoded: false, + Tx: tx1, + }, + { + EfficiencyPercentage: 97, + TxAlreadyEncoded: false, + Tx: tx2, + }, + }, + }, + }, + } + + printBatch(&batch, true, true) + + encodedBatch, err := state.EncodeBatchV2(&batch) + require.NoError(t, err) + + decodedBatch, err := state.DecodeBatchV2(encodedBatch) + require.NoError(t, err) + + printBatch(decodedBatch, true, true) +} diff --git a/state/batch.go b/state/batch.go new file mode 100644 index 00000000..4975a961 --- /dev/null +++ b/state/batch.go @@ -0,0 +1,33 @@ +package state + +import ( + "time" + + "github.com/0xPolygon/cdk/state/datastream" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// Batch struct +type Batch struct { + BatchNumber uint64 + Coinbase common.Address + BatchL2Data []byte + StateRoot common.Hash + LocalExitRoot common.Hash + AccInputHash common.Hash + L1InfoTreeIndex uint32 + L1InfoRoot common.Hash + // Timestamp (<=incaberry) -> batch time + // (>incaberry) -> minTimestamp used in batch creation, real timestamp is in virtual_batch.batch_timestamp + Timestamp time.Time + Transactions []types.Transaction + GlobalExitRoot common.Hash + ForcedBatchNum *uint64 + Resources BatchResources + // WIP: if WIP == true is a openBatch + WIP bool + ChainID uint64 + ForkID uint64 + Type datastream.BatchType +} diff --git a/state/config.go b/state/config.go new file mode 100644 index 00000000..e77231f2 --- /dev/null +++ b/state/config.go @@ -0,0 +1,13 @@ +package state + +import ( + "github.com/0xPolygon/cdk/db" +) + +// Config is state config +type Config struct { + // ChainID is the L2 ChainID provided by the Network Config + ChainID uint64 + // DB is the database configuration + DB db.Config `mapstructure:"DB"` +} diff --git a/state/datastream.go b/state/datastream.go new file mode 100644 index 00000000..7687dba7 --- /dev/null +++ b/state/datastream.go @@ -0,0 +1,12 @@ +package state + +import ( + "github.com/0xPolygonHermez/zkevm-data-streamer/datastreamer" +) + +const ( + // StreamTypeSequencer represents a Sequencer stream + StreamTypeSequencer datastreamer.StreamType = 1 + // EntryTypeBookMark represents a bookmark entry + EntryTypeBookMark datastreamer.EntryType = datastreamer.EtBookmark +) diff --git a/state/datastream/datastream.pb.go b/state/datastream/datastream.pb.go new file mode 100644 index 00000000..e600a4fd --- /dev/null +++ b/state/datastream/datastream.pb.go @@ -0,0 +1,1069 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.34.1 +// protoc v5.27.0 +// source: datastream.proto + +package datastream + +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) +) + +type BookmarkType int32 + +const ( + BookmarkType_BOOKMARK_TYPE_UNSPECIFIED BookmarkType = 0 + BookmarkType_BOOKMARK_TYPE_BATCH BookmarkType = 1 + BookmarkType_BOOKMARK_TYPE_L2_BLOCK BookmarkType = 2 +) + +// Enum value maps for BookmarkType. +var ( + BookmarkType_name = map[int32]string{ + 0: "BOOKMARK_TYPE_UNSPECIFIED", + 1: "BOOKMARK_TYPE_BATCH", + 2: "BOOKMARK_TYPE_L2_BLOCK", + } + BookmarkType_value = map[string]int32{ + "BOOKMARK_TYPE_UNSPECIFIED": 0, + "BOOKMARK_TYPE_BATCH": 1, + "BOOKMARK_TYPE_L2_BLOCK": 2, + } +) + +func (x BookmarkType) Enum() *BookmarkType { + p := new(BookmarkType) + *p = x + return p +} + +func (x BookmarkType) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (BookmarkType) Descriptor() protoreflect.EnumDescriptor { + return file_datastream_proto_enumTypes[0].Descriptor() +} + +func (BookmarkType) Type() protoreflect.EnumType { + return &file_datastream_proto_enumTypes[0] +} + +func (x BookmarkType) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use BookmarkType.Descriptor instead. +func (BookmarkType) EnumDescriptor() ([]byte, []int) { + return file_datastream_proto_rawDescGZIP(), []int{0} +} + +type EntryType int32 + +const ( + EntryType_ENTRY_TYPE_UNSPECIFIED EntryType = 0 + EntryType_ENTRY_TYPE_BATCH_START EntryType = 1 + EntryType_ENTRY_TYPE_L2_BLOCK EntryType = 2 + EntryType_ENTRY_TYPE_TRANSACTION EntryType = 3 + EntryType_ENTRY_TYPE_BATCH_END EntryType = 4 + EntryType_ENTRY_TYPE_UPDATE_GER EntryType = 5 +) + +// Enum value maps for EntryType. +var ( + EntryType_name = map[int32]string{ + 0: "ENTRY_TYPE_UNSPECIFIED", + 1: "ENTRY_TYPE_BATCH_START", + 2: "ENTRY_TYPE_L2_BLOCK", + 3: "ENTRY_TYPE_TRANSACTION", + 4: "ENTRY_TYPE_BATCH_END", + 5: "ENTRY_TYPE_UPDATE_GER", + } + EntryType_value = map[string]int32{ + "ENTRY_TYPE_UNSPECIFIED": 0, + "ENTRY_TYPE_BATCH_START": 1, + "ENTRY_TYPE_L2_BLOCK": 2, + "ENTRY_TYPE_TRANSACTION": 3, + "ENTRY_TYPE_BATCH_END": 4, + "ENTRY_TYPE_UPDATE_GER": 5, + } +) + +func (x EntryType) Enum() *EntryType { + p := new(EntryType) + *p = x + return p +} + +func (x EntryType) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (EntryType) Descriptor() protoreflect.EnumDescriptor { + return file_datastream_proto_enumTypes[1].Descriptor() +} + +func (EntryType) Type() protoreflect.EnumType { + return &file_datastream_proto_enumTypes[1] +} + +func (x EntryType) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use EntryType.Descriptor instead. +func (EntryType) EnumDescriptor() ([]byte, []int) { + return file_datastream_proto_rawDescGZIP(), []int{1} +} + +type BatchType int32 + +const ( + BatchType_BATCH_TYPE_UNSPECIFIED BatchType = 0 + BatchType_BATCH_TYPE_REGULAR BatchType = 1 + BatchType_BATCH_TYPE_FORCED BatchType = 2 + BatchType_BATCH_TYPE_INJECTED BatchType = 3 + BatchType_BATCH_TYPE_INVALID BatchType = 4 +) + +// Enum value maps for BatchType. +var ( + BatchType_name = map[int32]string{ + 0: "BATCH_TYPE_UNSPECIFIED", + 1: "BATCH_TYPE_REGULAR", + 2: "BATCH_TYPE_FORCED", + 3: "BATCH_TYPE_INJECTED", + 4: "BATCH_TYPE_INVALID", + } + BatchType_value = map[string]int32{ + "BATCH_TYPE_UNSPECIFIED": 0, + "BATCH_TYPE_REGULAR": 1, + "BATCH_TYPE_FORCED": 2, + "BATCH_TYPE_INJECTED": 3, + "BATCH_TYPE_INVALID": 4, + } +) + +func (x BatchType) Enum() *BatchType { + p := new(BatchType) + *p = x + return p +} + +func (x BatchType) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (BatchType) Descriptor() protoreflect.EnumDescriptor { + return file_datastream_proto_enumTypes[2].Descriptor() +} + +func (BatchType) Type() protoreflect.EnumType { + return &file_datastream_proto_enumTypes[2] +} + +func (x BatchType) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use BatchType.Descriptor instead. +func (BatchType) EnumDescriptor() ([]byte, []int) { + return file_datastream_proto_rawDescGZIP(), []int{2} +} + +type BatchStart struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Number uint64 `protobuf:"varint,1,opt,name=number,proto3" json:"number,omitempty"` + Type BatchType `protobuf:"varint,2,opt,name=type,proto3,enum=datastream.v1.BatchType" json:"type,omitempty"` + ForkId uint64 `protobuf:"varint,3,opt,name=fork_id,json=forkId,proto3" json:"fork_id,omitempty"` + ChainId uint64 `protobuf:"varint,4,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` + Debug *Debug `protobuf:"bytes,5,opt,name=debug,proto3" json:"debug,omitempty"` +} + +func (x *BatchStart) Reset() { + *x = BatchStart{} + if protoimpl.UnsafeEnabled { + mi := &file_datastream_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *BatchStart) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*BatchStart) ProtoMessage() {} + +func (x *BatchStart) ProtoReflect() protoreflect.Message { + mi := &file_datastream_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 BatchStart.ProtoReflect.Descriptor instead. +func (*BatchStart) Descriptor() ([]byte, []int) { + return file_datastream_proto_rawDescGZIP(), []int{0} +} + +func (x *BatchStart) GetNumber() uint64 { + if x != nil { + return x.Number + } + return 0 +} + +func (x *BatchStart) GetType() BatchType { + if x != nil { + return x.Type + } + return BatchType_BATCH_TYPE_UNSPECIFIED +} + +func (x *BatchStart) GetForkId() uint64 { + if x != nil { + return x.ForkId + } + return 0 +} + +func (x *BatchStart) GetChainId() uint64 { + if x != nil { + return x.ChainId + } + return 0 +} + +func (x *BatchStart) GetDebug() *Debug { + if x != nil { + return x.Debug + } + return nil +} + +type BatchEnd struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Number uint64 `protobuf:"varint,1,opt,name=number,proto3" json:"number,omitempty"` + LocalExitRoot []byte `protobuf:"bytes,2,opt,name=local_exit_root,json=localExitRoot,proto3" json:"local_exit_root,omitempty"` + StateRoot []byte `protobuf:"bytes,3,opt,name=state_root,json=stateRoot,proto3" json:"state_root,omitempty"` + Debug *Debug `protobuf:"bytes,4,opt,name=debug,proto3" json:"debug,omitempty"` +} + +func (x *BatchEnd) Reset() { + *x = BatchEnd{} + if protoimpl.UnsafeEnabled { + mi := &file_datastream_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *BatchEnd) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*BatchEnd) ProtoMessage() {} + +func (x *BatchEnd) ProtoReflect() protoreflect.Message { + mi := &file_datastream_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 BatchEnd.ProtoReflect.Descriptor instead. +func (*BatchEnd) Descriptor() ([]byte, []int) { + return file_datastream_proto_rawDescGZIP(), []int{1} +} + +func (x *BatchEnd) GetNumber() uint64 { + if x != nil { + return x.Number + } + return 0 +} + +func (x *BatchEnd) GetLocalExitRoot() []byte { + if x != nil { + return x.LocalExitRoot + } + return nil +} + +func (x *BatchEnd) GetStateRoot() []byte { + if x != nil { + return x.StateRoot + } + return nil +} + +func (x *BatchEnd) GetDebug() *Debug { + if x != nil { + return x.Debug + } + return nil +} + +type L2Block struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Number uint64 `protobuf:"varint,1,opt,name=number,proto3" json:"number,omitempty"` + BatchNumber uint64 `protobuf:"varint,2,opt,name=batch_number,json=batchNumber,proto3" json:"batch_number,omitempty"` + Timestamp uint64 `protobuf:"varint,3,opt,name=timestamp,proto3" json:"timestamp,omitempty"` + DeltaTimestamp uint32 `protobuf:"varint,4,opt,name=delta_timestamp,json=deltaTimestamp,proto3" json:"delta_timestamp,omitempty"` + MinTimestamp uint64 `protobuf:"varint,5,opt,name=min_timestamp,json=minTimestamp,proto3" json:"min_timestamp,omitempty"` + L1Blockhash []byte `protobuf:"bytes,6,opt,name=l1_blockhash,json=l1Blockhash,proto3" json:"l1_blockhash,omitempty"` + L1InfotreeIndex uint32 `protobuf:"varint,7,opt,name=l1_infotree_index,json=l1InfotreeIndex,proto3" json:"l1_infotree_index,omitempty"` + Hash []byte `protobuf:"bytes,8,opt,name=hash,proto3" json:"hash,omitempty"` + StateRoot []byte `protobuf:"bytes,9,opt,name=state_root,json=stateRoot,proto3" json:"state_root,omitempty"` + GlobalExitRoot []byte `protobuf:"bytes,10,opt,name=global_exit_root,json=globalExitRoot,proto3" json:"global_exit_root,omitempty"` + Coinbase []byte `protobuf:"bytes,11,opt,name=coinbase,proto3" json:"coinbase,omitempty"` + BlockGasLimit uint64 `protobuf:"varint,12,opt,name=block_gas_limit,json=blockGasLimit,proto3" json:"block_gas_limit,omitempty"` + BlockInfoRoot []byte `protobuf:"bytes,13,opt,name=block_info_root,json=blockInfoRoot,proto3" json:"block_info_root,omitempty"` + Debug *Debug `protobuf:"bytes,14,opt,name=debug,proto3" json:"debug,omitempty"` +} + +func (x *L2Block) Reset() { + *x = L2Block{} + if protoimpl.UnsafeEnabled { + mi := &file_datastream_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *L2Block) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*L2Block) ProtoMessage() {} + +func (x *L2Block) ProtoReflect() protoreflect.Message { + mi := &file_datastream_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 L2Block.ProtoReflect.Descriptor instead. +func (*L2Block) Descriptor() ([]byte, []int) { + return file_datastream_proto_rawDescGZIP(), []int{2} +} + +func (x *L2Block) GetNumber() uint64 { + if x != nil { + return x.Number + } + return 0 +} + +func (x *L2Block) GetBatchNumber() uint64 { + if x != nil { + return x.BatchNumber + } + return 0 +} + +func (x *L2Block) GetTimestamp() uint64 { + if x != nil { + return x.Timestamp + } + return 0 +} + +func (x *L2Block) GetDeltaTimestamp() uint32 { + if x != nil { + return x.DeltaTimestamp + } + return 0 +} + +func (x *L2Block) GetMinTimestamp() uint64 { + if x != nil { + return x.MinTimestamp + } + return 0 +} + +func (x *L2Block) GetL1Blockhash() []byte { + if x != nil { + return x.L1Blockhash + } + return nil +} + +func (x *L2Block) GetL1InfotreeIndex() uint32 { + if x != nil { + return x.L1InfotreeIndex + } + return 0 +} + +func (x *L2Block) GetHash() []byte { + if x != nil { + return x.Hash + } + return nil +} + +func (x *L2Block) GetStateRoot() []byte { + if x != nil { + return x.StateRoot + } + return nil +} + +func (x *L2Block) GetGlobalExitRoot() []byte { + if x != nil { + return x.GlobalExitRoot + } + return nil +} + +func (x *L2Block) GetCoinbase() []byte { + if x != nil { + return x.Coinbase + } + return nil +} + +func (x *L2Block) GetBlockGasLimit() uint64 { + if x != nil { + return x.BlockGasLimit + } + return 0 +} + +func (x *L2Block) GetBlockInfoRoot() []byte { + if x != nil { + return x.BlockInfoRoot + } + return nil +} + +func (x *L2Block) GetDebug() *Debug { + if x != nil { + return x.Debug + } + return nil +} + +type Transaction struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + L2BlockNumber uint64 `protobuf:"varint,1,opt,name=l2block_number,json=l2blockNumber,proto3" json:"l2block_number,omitempty"` + Index uint64 `protobuf:"varint,2,opt,name=index,proto3" json:"index,omitempty"` + IsValid bool `protobuf:"varint,3,opt,name=is_valid,json=isValid,proto3" json:"is_valid,omitempty"` + Encoded []byte `protobuf:"bytes,4,opt,name=encoded,proto3" json:"encoded,omitempty"` + EffectiveGasPricePercentage uint32 `protobuf:"varint,5,opt,name=effective_gas_price_percentage,json=effectiveGasPricePercentage,proto3" json:"effective_gas_price_percentage,omitempty"` + ImStateRoot []byte `protobuf:"bytes,6,opt,name=im_state_root,json=imStateRoot,proto3" json:"im_state_root,omitempty"` + Debug *Debug `protobuf:"bytes,7,opt,name=debug,proto3" json:"debug,omitempty"` +} + +func (x *Transaction) Reset() { + *x = Transaction{} + if protoimpl.UnsafeEnabled { + mi := &file_datastream_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Transaction) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Transaction) ProtoMessage() {} + +func (x *Transaction) ProtoReflect() protoreflect.Message { + mi := &file_datastream_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 Transaction.ProtoReflect.Descriptor instead. +func (*Transaction) Descriptor() ([]byte, []int) { + return file_datastream_proto_rawDescGZIP(), []int{3} +} + +func (x *Transaction) GetL2BlockNumber() uint64 { + if x != nil { + return x.L2BlockNumber + } + return 0 +} + +func (x *Transaction) GetIndex() uint64 { + if x != nil { + return x.Index + } + return 0 +} + +func (x *Transaction) GetIsValid() bool { + if x != nil { + return x.IsValid + } + return false +} + +func (x *Transaction) GetEncoded() []byte { + if x != nil { + return x.Encoded + } + return nil +} + +func (x *Transaction) GetEffectiveGasPricePercentage() uint32 { + if x != nil { + return x.EffectiveGasPricePercentage + } + return 0 +} + +func (x *Transaction) GetImStateRoot() []byte { + if x != nil { + return x.ImStateRoot + } + return nil +} + +func (x *Transaction) GetDebug() *Debug { + if x != nil { + return x.Debug + } + return nil +} + +type UpdateGER struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + BatchNumber uint64 `protobuf:"varint,1,opt,name=batch_number,json=batchNumber,proto3" json:"batch_number,omitempty"` + Timestamp uint64 `protobuf:"varint,2,opt,name=timestamp,proto3" json:"timestamp,omitempty"` + GlobalExitRoot []byte `protobuf:"bytes,3,opt,name=global_exit_root,json=globalExitRoot,proto3" json:"global_exit_root,omitempty"` + Coinbase []byte `protobuf:"bytes,4,opt,name=coinbase,proto3" json:"coinbase,omitempty"` + ForkId uint64 `protobuf:"varint,5,opt,name=fork_id,json=forkId,proto3" json:"fork_id,omitempty"` + ChainId uint64 `protobuf:"varint,6,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` + StateRoot []byte `protobuf:"bytes,7,opt,name=state_root,json=stateRoot,proto3" json:"state_root,omitempty"` + Debug *Debug `protobuf:"bytes,8,opt,name=debug,proto3" json:"debug,omitempty"` +} + +func (x *UpdateGER) Reset() { + *x = UpdateGER{} + if protoimpl.UnsafeEnabled { + mi := &file_datastream_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *UpdateGER) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UpdateGER) ProtoMessage() {} + +func (x *UpdateGER) ProtoReflect() protoreflect.Message { + mi := &file_datastream_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 UpdateGER.ProtoReflect.Descriptor instead. +func (*UpdateGER) Descriptor() ([]byte, []int) { + return file_datastream_proto_rawDescGZIP(), []int{4} +} + +func (x *UpdateGER) GetBatchNumber() uint64 { + if x != nil { + return x.BatchNumber + } + return 0 +} + +func (x *UpdateGER) GetTimestamp() uint64 { + if x != nil { + return x.Timestamp + } + return 0 +} + +func (x *UpdateGER) GetGlobalExitRoot() []byte { + if x != nil { + return x.GlobalExitRoot + } + return nil +} + +func (x *UpdateGER) GetCoinbase() []byte { + if x != nil { + return x.Coinbase + } + return nil +} + +func (x *UpdateGER) GetForkId() uint64 { + if x != nil { + return x.ForkId + } + return 0 +} + +func (x *UpdateGER) GetChainId() uint64 { + if x != nil { + return x.ChainId + } + return 0 +} + +func (x *UpdateGER) GetStateRoot() []byte { + if x != nil { + return x.StateRoot + } + return nil +} + +func (x *UpdateGER) GetDebug() *Debug { + if x != nil { + return x.Debug + } + return nil +} + +type BookMark struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Type BookmarkType `protobuf:"varint,1,opt,name=type,proto3,enum=datastream.v1.BookmarkType" json:"type,omitempty"` + Value uint64 `protobuf:"varint,2,opt,name=value,proto3" json:"value,omitempty"` +} + +func (x *BookMark) Reset() { + *x = BookMark{} + if protoimpl.UnsafeEnabled { + mi := &file_datastream_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *BookMark) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*BookMark) ProtoMessage() {} + +func (x *BookMark) ProtoReflect() protoreflect.Message { + mi := &file_datastream_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 BookMark.ProtoReflect.Descriptor instead. +func (*BookMark) Descriptor() ([]byte, []int) { + return file_datastream_proto_rawDescGZIP(), []int{5} +} + +func (x *BookMark) GetType() BookmarkType { + if x != nil { + return x.Type + } + return BookmarkType_BOOKMARK_TYPE_UNSPECIFIED +} + +func (x *BookMark) GetValue() uint64 { + if x != nil { + return x.Value + } + return 0 +} + +type Debug struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"` +} + +func (x *Debug) Reset() { + *x = Debug{} + if protoimpl.UnsafeEnabled { + mi := &file_datastream_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Debug) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Debug) ProtoMessage() {} + +func (x *Debug) ProtoReflect() protoreflect.Message { + mi := &file_datastream_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 Debug.ProtoReflect.Descriptor instead. +func (*Debug) Descriptor() ([]byte, []int) { + return file_datastream_proto_rawDescGZIP(), []int{6} +} + +func (x *Debug) GetMessage() string { + if x != nil { + return x.Message + } + return "" +} + +var File_datastream_proto protoreflect.FileDescriptor + +var file_datastream_proto_rawDesc = []byte{ + 0x0a, 0x10, 0x64, 0x61, 0x74, 0x61, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x12, 0x0d, 0x64, 0x61, 0x74, 0x61, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, + 0x31, 0x22, 0xb2, 0x01, 0x0a, 0x0a, 0x42, 0x61, 0x74, 0x63, 0x68, 0x53, 0x74, 0x61, 0x72, 0x74, + 0x12, 0x16, 0x0a, 0x06, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, + 0x52, 0x06, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, 0x2c, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x18, 0x2e, 0x64, 0x61, 0x74, 0x61, 0x73, 0x74, 0x72, + 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x61, 0x74, 0x63, 0x68, 0x54, 0x79, 0x70, 0x65, + 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x17, 0x0a, 0x07, 0x66, 0x6f, 0x72, 0x6b, 0x5f, 0x69, + 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x66, 0x6f, 0x72, 0x6b, 0x49, 0x64, 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, 0x2a, 0x0a, 0x05, 0x64, 0x65, + 0x62, 0x75, 0x67, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x64, 0x61, 0x74, 0x61, + 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x62, 0x75, 0x67, 0x52, + 0x05, 0x64, 0x65, 0x62, 0x75, 0x67, 0x22, 0x95, 0x01, 0x0a, 0x08, 0x42, 0x61, 0x74, 0x63, 0x68, + 0x45, 0x6e, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x04, 0x52, 0x06, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, 0x26, 0x0a, 0x0f, 0x6c, + 0x6f, 0x63, 0x61, 0x6c, 0x5f, 0x65, 0x78, 0x69, 0x74, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0d, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x45, 0x78, 0x69, 0x74, 0x52, + 0x6f, 0x6f, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x74, 0x65, 0x5f, 0x72, 0x6f, 0x6f, + 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x73, 0x74, 0x61, 0x74, 0x65, 0x52, 0x6f, + 0x6f, 0x74, 0x12, 0x2a, 0x0a, 0x05, 0x64, 0x65, 0x62, 0x75, 0x67, 0x18, 0x04, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x14, 0x2e, 0x64, 0x61, 0x74, 0x61, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, + 0x31, 0x2e, 0x44, 0x65, 0x62, 0x75, 0x67, 0x52, 0x05, 0x64, 0x65, 0x62, 0x75, 0x67, 0x22, 0xf4, + 0x03, 0x0a, 0x07, 0x4c, 0x32, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x12, 0x16, 0x0a, 0x06, 0x6e, 0x75, + 0x6d, 0x62, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x6e, 0x75, 0x6d, 0x62, + 0x65, 0x72, 0x12, 0x21, 0x0a, 0x0c, 0x62, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x6e, 0x75, 0x6d, 0x62, + 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x62, 0x61, 0x74, 0x63, 0x68, 0x4e, + 0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, 0x1c, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, + 0x6d, 0x70, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, + 0x61, 0x6d, 0x70, 0x12, 0x27, 0x0a, 0x0f, 0x64, 0x65, 0x6c, 0x74, 0x61, 0x5f, 0x74, 0x69, 0x6d, + 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0e, 0x64, 0x65, + 0x6c, 0x74, 0x61, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x23, 0x0a, 0x0d, + 0x6d, 0x69, 0x6e, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x05, 0x20, + 0x01, 0x28, 0x04, 0x52, 0x0c, 0x6d, 0x69, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, + 0x70, 0x12, 0x21, 0x0a, 0x0c, 0x6c, 0x31, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x68, 0x61, 0x73, + 0x68, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x6c, 0x31, 0x42, 0x6c, 0x6f, 0x63, 0x6b, + 0x68, 0x61, 0x73, 0x68, 0x12, 0x2a, 0x0a, 0x11, 0x6c, 0x31, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x74, + 0x72, 0x65, 0x65, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0d, 0x52, + 0x0f, 0x6c, 0x31, 0x49, 0x6e, 0x66, 0x6f, 0x74, 0x72, 0x65, 0x65, 0x49, 0x6e, 0x64, 0x65, 0x78, + 0x12, 0x12, 0x0a, 0x04, 0x68, 0x61, 0x73, 0x68, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, + 0x68, 0x61, 0x73, 0x68, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x74, 0x65, 0x5f, 0x72, 0x6f, + 0x6f, 0x74, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x73, 0x74, 0x61, 0x74, 0x65, 0x52, + 0x6f, 0x6f, 0x74, 0x12, 0x28, 0x0a, 0x10, 0x67, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x5f, 0x65, 0x78, + 0x69, 0x74, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0e, 0x67, + 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x45, 0x78, 0x69, 0x74, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x1a, 0x0a, + 0x08, 0x63, 0x6f, 0x69, 0x6e, 0x62, 0x61, 0x73, 0x65, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0c, 0x52, + 0x08, 0x63, 0x6f, 0x69, 0x6e, 0x62, 0x61, 0x73, 0x65, 0x12, 0x26, 0x0a, 0x0f, 0x62, 0x6c, 0x6f, + 0x63, 0x6b, 0x5f, 0x67, 0x61, 0x73, 0x5f, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x18, 0x0c, 0x20, 0x01, + 0x28, 0x04, 0x52, 0x0d, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x47, 0x61, 0x73, 0x4c, 0x69, 0x6d, 0x69, + 0x74, 0x12, 0x26, 0x0a, 0x0f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x5f, + 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0d, 0x62, 0x6c, 0x6f, 0x63, + 0x6b, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x2a, 0x0a, 0x05, 0x64, 0x65, 0x62, + 0x75, 0x67, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x64, 0x61, 0x74, 0x61, 0x73, + 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x62, 0x75, 0x67, 0x52, 0x05, + 0x64, 0x65, 0x62, 0x75, 0x67, 0x22, 0x94, 0x02, 0x0a, 0x0b, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x25, 0x0a, 0x0e, 0x6c, 0x32, 0x62, 0x6c, 0x6f, 0x63, 0x6b, + 0x5f, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0d, 0x6c, + 0x32, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, 0x14, 0x0a, 0x05, + 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x69, 0x6e, 0x64, + 0x65, 0x78, 0x12, 0x19, 0x0a, 0x08, 0x69, 0x73, 0x5f, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x69, 0x73, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x12, 0x18, 0x0a, + 0x07, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x07, + 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x12, 0x43, 0x0a, 0x1e, 0x65, 0x66, 0x66, 0x65, 0x63, + 0x74, 0x69, 0x76, 0x65, 0x5f, 0x67, 0x61, 0x73, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x5f, 0x70, + 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0d, 0x52, + 0x1b, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x69, 0x76, 0x65, 0x47, 0x61, 0x73, 0x50, 0x72, 0x69, + 0x63, 0x65, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x12, 0x22, 0x0a, 0x0d, + 0x69, 0x6d, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x06, 0x20, + 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x69, 0x6d, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x6f, 0x6f, 0x74, + 0x12, 0x2a, 0x0a, 0x05, 0x64, 0x65, 0x62, 0x75, 0x67, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x14, 0x2e, 0x64, 0x61, 0x74, 0x61, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x31, 0x2e, + 0x44, 0x65, 0x62, 0x75, 0x67, 0x52, 0x05, 0x64, 0x65, 0x62, 0x75, 0x67, 0x22, 0x91, 0x02, 0x0a, + 0x09, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x47, 0x45, 0x52, 0x12, 0x21, 0x0a, 0x0c, 0x62, 0x61, + 0x74, 0x63, 0x68, 0x5f, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, + 0x52, 0x0b, 0x62, 0x61, 0x74, 0x63, 0x68, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, 0x1c, 0x0a, + 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, + 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x28, 0x0a, 0x10, 0x67, + 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x5f, 0x65, 0x78, 0x69, 0x74, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0e, 0x67, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x45, 0x78, 0x69, + 0x74, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x63, 0x6f, 0x69, 0x6e, 0x62, 0x61, 0x73, + 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x63, 0x6f, 0x69, 0x6e, 0x62, 0x61, 0x73, + 0x65, 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, 0x19, 0x0a, 0x08, 0x63, 0x68, + 0x61, 0x69, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x06, 0x20, 0x01, 0x28, 0x04, 0x52, 0x07, 0x63, 0x68, + 0x61, 0x69, 0x6e, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x74, 0x65, 0x5f, 0x72, + 0x6f, 0x6f, 0x74, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x09, 0x73, 0x74, 0x61, 0x74, 0x65, + 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x2a, 0x0a, 0x05, 0x64, 0x65, 0x62, 0x75, 0x67, 0x18, 0x08, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x64, 0x61, 0x74, 0x61, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, + 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x65, 0x62, 0x75, 0x67, 0x52, 0x05, 0x64, 0x65, 0x62, 0x75, 0x67, + 0x22, 0x51, 0x0a, 0x08, 0x42, 0x6f, 0x6f, 0x6b, 0x4d, 0x61, 0x72, 0x6b, 0x12, 0x2f, 0x0a, 0x04, + 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1b, 0x2e, 0x64, 0x61, 0x74, + 0x61, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x2e, 0x76, 0x31, 0x2e, 0x42, 0x6f, 0x6f, 0x6b, 0x6d, + 0x61, 0x72, 0x6b, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x14, 0x0a, + 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x22, 0x21, 0x0a, 0x05, 0x44, 0x65, 0x62, 0x75, 0x67, 0x12, 0x18, 0x0a, 0x07, + 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, + 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x2a, 0x62, 0x0a, 0x0c, 0x42, 0x6f, 0x6f, 0x6b, 0x6d, 0x61, + 0x72, 0x6b, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1d, 0x0a, 0x19, 0x42, 0x4f, 0x4f, 0x4b, 0x4d, 0x41, + 0x52, 0x4b, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, + 0x49, 0x45, 0x44, 0x10, 0x00, 0x12, 0x17, 0x0a, 0x13, 0x42, 0x4f, 0x4f, 0x4b, 0x4d, 0x41, 0x52, + 0x4b, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x42, 0x41, 0x54, 0x43, 0x48, 0x10, 0x01, 0x12, 0x1a, + 0x0a, 0x16, 0x42, 0x4f, 0x4f, 0x4b, 0x4d, 0x41, 0x52, 0x4b, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, + 0x4c, 0x32, 0x5f, 0x42, 0x4c, 0x4f, 0x43, 0x4b, 0x10, 0x02, 0x2a, 0xad, 0x01, 0x0a, 0x09, 0x45, + 0x6e, 0x74, 0x72, 0x79, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1a, 0x0a, 0x16, 0x45, 0x4e, 0x54, 0x52, + 0x59, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, + 0x45, 0x44, 0x10, 0x00, 0x12, 0x1a, 0x0a, 0x16, 0x45, 0x4e, 0x54, 0x52, 0x59, 0x5f, 0x54, 0x59, + 0x50, 0x45, 0x5f, 0x42, 0x41, 0x54, 0x43, 0x48, 0x5f, 0x53, 0x54, 0x41, 0x52, 0x54, 0x10, 0x01, + 0x12, 0x17, 0x0a, 0x13, 0x45, 0x4e, 0x54, 0x52, 0x59, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x4c, + 0x32, 0x5f, 0x42, 0x4c, 0x4f, 0x43, 0x4b, 0x10, 0x02, 0x12, 0x1a, 0x0a, 0x16, 0x45, 0x4e, 0x54, + 0x52, 0x59, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x54, 0x52, 0x41, 0x4e, 0x53, 0x41, 0x43, 0x54, + 0x49, 0x4f, 0x4e, 0x10, 0x03, 0x12, 0x18, 0x0a, 0x14, 0x45, 0x4e, 0x54, 0x52, 0x59, 0x5f, 0x54, + 0x59, 0x50, 0x45, 0x5f, 0x42, 0x41, 0x54, 0x43, 0x48, 0x5f, 0x45, 0x4e, 0x44, 0x10, 0x04, 0x12, + 0x19, 0x0a, 0x15, 0x45, 0x4e, 0x54, 0x52, 0x59, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x55, 0x50, + 0x44, 0x41, 0x54, 0x45, 0x5f, 0x47, 0x45, 0x52, 0x10, 0x05, 0x2a, 0x87, 0x01, 0x0a, 0x09, 0x42, + 0x61, 0x74, 0x63, 0x68, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1a, 0x0a, 0x16, 0x42, 0x41, 0x54, 0x43, + 0x48, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x55, 0x4e, 0x53, 0x50, 0x45, 0x43, 0x49, 0x46, 0x49, + 0x45, 0x44, 0x10, 0x00, 0x12, 0x16, 0x0a, 0x12, 0x42, 0x41, 0x54, 0x43, 0x48, 0x5f, 0x54, 0x59, + 0x50, 0x45, 0x5f, 0x52, 0x45, 0x47, 0x55, 0x4c, 0x41, 0x52, 0x10, 0x01, 0x12, 0x15, 0x0a, 0x11, + 0x42, 0x41, 0x54, 0x43, 0x48, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x46, 0x4f, 0x52, 0x43, 0x45, + 0x44, 0x10, 0x02, 0x12, 0x17, 0x0a, 0x13, 0x42, 0x41, 0x54, 0x43, 0x48, 0x5f, 0x54, 0x59, 0x50, + 0x45, 0x5f, 0x49, 0x4e, 0x4a, 0x45, 0x43, 0x54, 0x45, 0x44, 0x10, 0x03, 0x12, 0x16, 0x0a, 0x12, + 0x42, 0x41, 0x54, 0x43, 0x48, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x49, 0x4e, 0x56, 0x41, 0x4c, + 0x49, 0x44, 0x10, 0x04, 0x42, 0x3e, 0x5a, 0x3c, 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, 0x61, 0x67, 0x67, 0x72, 0x65, 0x67, 0x61, + 0x74, 0x6f, 0x72, 0x2f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x2f, 0x64, 0x61, 0x74, 0x61, 0x73, 0x74, + 0x72, 0x65, 0x61, 0x6d, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_datastream_proto_rawDescOnce sync.Once + file_datastream_proto_rawDescData = file_datastream_proto_rawDesc +) + +func file_datastream_proto_rawDescGZIP() []byte { + file_datastream_proto_rawDescOnce.Do(func() { + file_datastream_proto_rawDescData = protoimpl.X.CompressGZIP(file_datastream_proto_rawDescData) + }) + return file_datastream_proto_rawDescData +} + +var file_datastream_proto_enumTypes = make([]protoimpl.EnumInfo, 3) +var file_datastream_proto_msgTypes = make([]protoimpl.MessageInfo, 7) +var file_datastream_proto_goTypes = []interface{}{ + (BookmarkType)(0), // 0: datastream.v1.BookmarkType + (EntryType)(0), // 1: datastream.v1.EntryType + (BatchType)(0), // 2: datastream.v1.BatchType + (*BatchStart)(nil), // 3: datastream.v1.BatchStart + (*BatchEnd)(nil), // 4: datastream.v1.BatchEnd + (*L2Block)(nil), // 5: datastream.v1.L2Block + (*Transaction)(nil), // 6: datastream.v1.Transaction + (*UpdateGER)(nil), // 7: datastream.v1.UpdateGER + (*BookMark)(nil), // 8: datastream.v1.BookMark + (*Debug)(nil), // 9: datastream.v1.Debug +} +var file_datastream_proto_depIdxs = []int32{ + 2, // 0: datastream.v1.BatchStart.type:type_name -> datastream.v1.BatchType + 9, // 1: datastream.v1.BatchStart.debug:type_name -> datastream.v1.Debug + 9, // 2: datastream.v1.BatchEnd.debug:type_name -> datastream.v1.Debug + 9, // 3: datastream.v1.L2Block.debug:type_name -> datastream.v1.Debug + 9, // 4: datastream.v1.Transaction.debug:type_name -> datastream.v1.Debug + 9, // 5: datastream.v1.UpdateGER.debug:type_name -> datastream.v1.Debug + 0, // 6: datastream.v1.BookMark.type:type_name -> datastream.v1.BookmarkType + 7, // [7:7] is the sub-list for method output_type + 7, // [7:7] is the sub-list for method input_type + 7, // [7:7] is the sub-list for extension type_name + 7, // [7:7] is the sub-list for extension extendee + 0, // [0:7] is the sub-list for field type_name +} + +func init() { file_datastream_proto_init() } +func file_datastream_proto_init() { + if File_datastream_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_datastream_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*BatchStart); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_datastream_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*BatchEnd); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_datastream_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*L2Block); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_datastream_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Transaction); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_datastream_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*UpdateGER); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_datastream_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*BookMark); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_datastream_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Debug); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_datastream_proto_rawDesc, + NumEnums: 3, + NumMessages: 7, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_datastream_proto_goTypes, + DependencyIndexes: file_datastream_proto_depIdxs, + EnumInfos: file_datastream_proto_enumTypes, + MessageInfos: file_datastream_proto_msgTypes, + }.Build() + File_datastream_proto = out.File + file_datastream_proto_rawDesc = nil + file_datastream_proto_goTypes = nil + file_datastream_proto_depIdxs = nil +} diff --git a/state/encoding_batch_v2.go b/state/encoding_batch_v2.go new file mode 100644 index 00000000..8e3561bd --- /dev/null +++ b/state/encoding_batch_v2.go @@ -0,0 +1,373 @@ +/* +This file provide functions to work with ETROG batches: +- EncodeBatchV2 (equivalent to EncodeTransactions) +- DecodeBatchV2 (equivalent to DecodeTxs) +- DecodeForcedBatchV2 + +Also provide a builder class to create batches (BatchV2Encoder): + This method doesnt check anything, so is more flexible but you need to know what you are doing + - `builder := NewBatchV2Encoder()` : Create a new `BatchV2Encoder`` + - You can call to `AddBlockHeader` or `AddTransaction` to add a block header or a transaction as you wish + - You can call to `GetResult` to get the batch data + + +// batch data format: +// 0xb | 1 | changeL2Block +// --------- L2 block Header --------------------------------- +// 0x73e6af6f | 4 | deltaTimestamp +// 0x00000012 | 4 | indexL1InfoTree +// -------- Transaction --------------------------------------- +// 0x00...0x00 | n | transaction RLP coded +// 0x00...0x00 | 32 | R +// 0x00...0x00 | 32 | S +// 0x00 | 32 | V +// 0x00 | 1 | efficiencyPercentage +// Repeat Transaction or changeL2Block +// Note: RLP codification: https://ethereum.org/en/developers/docs/data-structures-and-encoding/rlp/ + +/ forced batch data format: +// -------- Transaction --------------------------------------- +// 0x00...0x00 | n | transaction RLP coded +// 0x00...0x00 | 32 | R +// 0x00...0x00 | 32 | S +// 0x00 | 32 | V +// 0x00 | 1 | efficiencyPercentage +// Repeat Transaction +// +// Usage: +// There are 2 ways of use this module, direct calls or a builder class: +// 1) Direct calls: +// - EncodeBatchV2: Encode a batch of transactions +// - DecodeBatchV2: Decode a batch of transactions +// +// 2) Builder class: +// This method doesnt check anything, so is more flexible but you need to know what you are doing +// - builder := NewBatchV2Encoder(): Create a new BatchV2Encoder +// - You can call to `AddBlockHeader` or `AddTransaction` to add a block header or a transaction as you wish +// - You can call to `GetResult` to get the batch data + +*/ + +package state + +import ( + "encoding/binary" + "errors" + "fmt" + "strconv" + + "github.com/0xPolygon/cdk/hex" + "github.com/0xPolygon/cdk/log" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/rlp" +) + +// ChangeL2BlockHeader is the header of a L2 block. +type ChangeL2BlockHeader struct { + DeltaTimestamp uint32 + IndexL1InfoTree uint32 +} + +// L2BlockRaw is the raw representation of a L2 block. +type L2BlockRaw struct { + BlockNumber uint64 + ChangeL2BlockHeader + Transactions []L2TxRaw +} + +// BatchRawV2 is the representation of a batch of transactions. +type BatchRawV2 struct { + Blocks []L2BlockRaw +} + +// ForcedBatchRawV2 is the representation of a forced batch of transactions. +type ForcedBatchRawV2 struct { + Transactions []L2TxRaw +} + +// L2TxRaw is the raw representation of a L2 transaction inside a L2 block. +type L2TxRaw struct { + EfficiencyPercentage uint8 // valid always + TxAlreadyEncoded bool // If true the tx is already encoded (data field is used) + Tx *types.Transaction // valid if TxAlreadyEncoded == false + Data []byte // valid if TxAlreadyEncoded == true +} + +const ( + changeL2Block = uint8(0x0b) + sizeUInt32 = 4 +) + +var ( + // ErrBatchV2DontStartWithChangeL2Block is returned when the batch start directly with a trsansaction (without a changeL2Block) + ErrBatchV2DontStartWithChangeL2Block = errors.New("batch v2 must start with changeL2Block before Tx (suspect a V1 Batch or a ForcedBatch?))") + // ErrInvalidBatchV2 is returned when the batch is invalid. + ErrInvalidBatchV2 = errors.New("invalid batch v2") + // ErrInvalidRLP is returned when the rlp is invalid. + ErrInvalidRLP = errors.New("invalid rlp codification") +) + +func (b *BatchRawV2) String() string { + res := "" + nTxs := 0 + for i, block := range b.Blocks { + res += fmt.Sprintf("Block[%d/%d]: deltaTimestamp: %d, indexL1InfoTree: %d nTxs: %d\n", i, len(b.Blocks), + block.DeltaTimestamp, block.IndexL1InfoTree, len(block.Transactions)) + nTxs += len(block.Transactions) + } + res = fmt.Sprintf("BATCHv2, nBlocks: %d nTxs:%d \n", len(b.Blocks), nTxs) + res + return res +} + +// EncodeBatchV2 encodes a batch of transactions into a byte slice. +func EncodeBatchV2(batch *BatchRawV2) ([]byte, error) { + if batch == nil { + return nil, fmt.Errorf("batch is nil: %w", ErrInvalidBatchV2) + } + if len(batch.Blocks) == 0 { + return nil, fmt.Errorf("a batch need minimum a L2Block: %w", ErrInvalidBatchV2) + } + + encoder := NewBatchV2Encoder() + for _, block := range batch.Blocks { + encoder.AddBlockHeader(block.ChangeL2BlockHeader) + err := encoder.AddTransactions(block.Transactions) + if err != nil { + return nil, fmt.Errorf("can't encode tx: %w", err) + } + } + return encoder.GetResult(), nil +} + +// BatchV2Encoder is a builder of the batchl2data used by EncodeBatchV2 +type BatchV2Encoder struct { + batchData []byte +} + +// NewBatchV2Encoder creates a new BatchV2Encoder. +func NewBatchV2Encoder() *BatchV2Encoder { + return &BatchV2Encoder{} +} + +// AddBlockHeader adds a block header to the batch. +func (b *BatchV2Encoder) AddBlockHeader(l2BlockHeader ChangeL2BlockHeader) { + b.batchData = l2BlockHeader.Encode(b.batchData) +} + +// AddTransactions adds a set of transactions to the batch. +func (b *BatchV2Encoder) AddTransactions(transactions []L2TxRaw) error { + for i := range transactions { + tx := transactions[i] + err := b.AddTransaction(&tx) + if err != nil { + return fmt.Errorf("can't encode tx: %w", err) + } + } + return nil +} + +// AddTransaction adds a transaction to the batch. +func (b *BatchV2Encoder) AddTransaction(transaction *L2TxRaw) error { + var err error + b.batchData, err = transaction.Encode(b.batchData) + if err != nil { + return fmt.Errorf("can't encode tx: %w", err) + } + return nil +} + +// GetResult returns the batch data. +func (b *BatchV2Encoder) GetResult() []byte { + return b.batchData +} + +// Encode encodes a batch of l2blocks header into a byte slice. +func (c ChangeL2BlockHeader) Encode(batchData []byte) []byte { + batchData = append(batchData, changeL2Block) + batchData = append(batchData, encodeUint32(c.DeltaTimestamp)...) + batchData = append(batchData, encodeUint32(c.IndexL1InfoTree)...) + return batchData +} + +// Encode encodes a transaction into a byte slice. +func (tx L2TxRaw) Encode(batchData []byte) ([]byte, error) { + if tx.TxAlreadyEncoded { + batchData = append(batchData, tx.Data...) + } else { + rlpTx, err := prepareRLPTxData(tx.Tx) + if err != nil { + return nil, fmt.Errorf("can't encode tx to RLP: %w", err) + } + batchData = append(batchData, rlpTx...) + } + batchData = append(batchData, tx.EfficiencyPercentage) + return batchData, nil +} + +// DecodeBatchV2 decodes a batch of transactions from a byte slice. +func DecodeBatchV2(txsData []byte) (*BatchRawV2, error) { + // The transactions is not RLP encoded. Is the raw bytes in this form: 1 byte for the transaction type (always 0b for changeL2Block) + 4 bytes for deltaTimestamp + for bytes for indexL1InfoTree + var err error + var blocks []L2BlockRaw + var currentBlock *L2BlockRaw + pos := int(0) + for pos < len(txsData) { + switch txsData[pos] { + case changeL2Block: + if currentBlock != nil { + blocks = append(blocks, *currentBlock) + } + pos, currentBlock, err = decodeBlockHeader(txsData, pos+1) + if err != nil { + return nil, fmt.Errorf("pos: %d can't decode new BlockHeader: %w", pos, err) + } + // by RLP definition a tx never starts with a 0x0b. So, if is not a changeL2Block + // is a tx + default: + if currentBlock == nil { + _, _, err := DecodeTxRLP(txsData, pos) + if err == nil { + // There is no changeL2Block but have a valid RLP transaction + return nil, ErrBatchV2DontStartWithChangeL2Block + } else { + // No changeL2Block and no valid RLP transaction + return nil, fmt.Errorf("no ChangeL2Block neither valid Tx, batch malformed : %w", ErrInvalidBatchV2) + } + } + var tx *L2TxRaw + pos, tx, err = DecodeTxRLP(txsData, pos) + if err != nil { + return nil, fmt.Errorf("can't decode transactions: %w", err) + } + + currentBlock.Transactions = append(currentBlock.Transactions, *tx) + } + } + if currentBlock != nil { + blocks = append(blocks, *currentBlock) + } + return &BatchRawV2{blocks}, nil +} + +// DecodeForcedBatchV2 decodes a forced batch V2 (Etrog) +// Is forbidden changeL2Block, so are just the set of transactions +func DecodeForcedBatchV2(txsData []byte) (*ForcedBatchRawV2, error) { + txs, _, efficiencyPercentages, err := DecodeTxs(txsData, FORKID_ETROG) + if err != nil { + return nil, err + } + // Sanity check, this should never happen + if len(efficiencyPercentages) != len(txs) { + return nil, fmt.Errorf("error decoding len(efficiencyPercentages) != len(txs). len(efficiencyPercentages)=%d, len(txs)=%d : %w", len(efficiencyPercentages), len(txs), ErrInvalidRLP) + } + forcedBatch := ForcedBatchRawV2{} + for i := range txs { + tx := txs[i] + forcedBatch.Transactions = append(forcedBatch.Transactions, L2TxRaw{ + Tx: tx, + EfficiencyPercentage: efficiencyPercentages[i], + }) + } + return &forcedBatch, nil +} + +// decodeBlockHeader decodes a block header from a byte slice. +// +// Extract: 4 bytes for deltaTimestamp + 4 bytes for indexL1InfoTree +func decodeBlockHeader(txsData []byte, pos int) (int, *L2BlockRaw, error) { + var err error + currentBlock := &L2BlockRaw{} + pos, currentBlock.DeltaTimestamp, err = decodeUint32(txsData, pos) + if err != nil { + return 0, nil, fmt.Errorf("can't get deltaTimestamp: %w", err) + } + pos, currentBlock.IndexL1InfoTree, err = decodeUint32(txsData, pos) + if err != nil { + return 0, nil, fmt.Errorf("can't get leafIndex: %w", err) + } + + return pos, currentBlock, nil +} + +// DecodeTxRLP decodes a transaction from a byte slice. +func DecodeTxRLP(txsData []byte, offset int) (int, *L2TxRaw, error) { + var err error + length, err := decodeRLPListLengthFromOffset(txsData, offset) + if err != nil { + return 0, nil, fmt.Errorf("can't get RLP length (offset=%d): %w", offset, err) + } + endPos := uint64(offset) + length + rLength + sLength + vLength + EfficiencyPercentageByteLength + if endPos > uint64(len(txsData)) { + return 0, nil, fmt.Errorf("can't get tx because not enough data (endPos=%d lenData=%d): %w", + endPos, len(txsData), ErrInvalidBatchV2) + } + fullDataTx := txsData[offset:endPos] + dataStart := uint64(offset) + length + txInfo := txsData[offset:dataStart] + rData := txsData[dataStart : dataStart+rLength] + sData := txsData[dataStart+rLength : dataStart+rLength+sLength] + vData := txsData[dataStart+rLength+sLength : dataStart+rLength+sLength+vLength] + efficiencyPercentage := txsData[dataStart+rLength+sLength+vLength] + var rlpFields [][]byte + err = rlp.DecodeBytes(txInfo, &rlpFields) + if err != nil { + log.Error("error decoding tx Bytes: ", err, ". fullDataTx: ", hex.EncodeToString(fullDataTx), "\n tx: ", hex.EncodeToString(txInfo), "\n Txs received: ", hex.EncodeToString(txsData)) + return 0, nil, err + } + legacyTx, err := RlpFieldsToLegacyTx(rlpFields, vData, rData, sData) + if err != nil { + log.Debug("error creating tx from rlp fields: ", err, ". fullDataTx: ", hex.EncodeToString(fullDataTx), "\n tx: ", hex.EncodeToString(txInfo), "\n Txs received: ", hex.EncodeToString(txsData)) + return 0, nil, err + } + + l2Tx := &L2TxRaw{ + Tx: types.NewTx(legacyTx), + EfficiencyPercentage: efficiencyPercentage, + } + + return int(endPos), l2Tx, err +} + +// It returns the length of data from the param offset +// ex: +// 0xc0 -> empty data -> 1 byte because it include the 0xc0 +func decodeRLPListLengthFromOffset(txsData []byte, offset int) (uint64, error) { + txDataLength := uint64(len(txsData)) + num := uint64(txsData[offset]) + if num < c0 { // c0 -> is a empty data + log.Debugf("error num < c0 : %d, %d", num, c0) + return 0, fmt.Errorf("first byte of tx (%x) is < 0xc0: %w", num, ErrInvalidRLP) + } + length := num - c0 + if length > shortRlp { // If rlp is bigger than length 55 + // n is the length of the rlp data without the header (1 byte) for example "0xf7" + pos64 := uint64(offset) + lengthInByteOfSize := num - f7 + if (pos64 + headerByteLength + lengthInByteOfSize) > txDataLength { + log.Debug("error not enough data: ") + return 0, fmt.Errorf("not enough data to get length: %w", ErrInvalidRLP) + } + + n, err := strconv.ParseUint(hex.EncodeToString(txsData[pos64+1:pos64+1+lengthInByteOfSize]), hex.Base, hex.BitSize64) // +1 is the header. For example 0xf7 + if err != nil { + log.Debug("error parsing length: ", err) + return 0, fmt.Errorf("error parsing length value: %w", err) + } + // TODO: RLP specifications says length = n ??? that is wrong?? + length = n + num - f7 // num - f7 is the header. For example 0xf7 + } + return length + headerByteLength, nil +} + +func encodeUint32(value uint32) []byte { + data := make([]byte, sizeUInt32) + binary.BigEndian.PutUint32(data, value) + return data +} + +func decodeUint32(txsData []byte, pos int) (int, uint32, error) { + if len(txsData)-pos < sizeUInt32 { + return 0, 0, fmt.Errorf("can't get u32 because not enough data: %w", ErrInvalidBatchV2) + } + return pos + sizeUInt32, binary.BigEndian.Uint32(txsData[pos : pos+sizeUInt32]), nil +} diff --git a/state/encoding_batch_v2_test.go b/state/encoding_batch_v2_test.go new file mode 100644 index 00000000..30b16d23 --- /dev/null +++ b/state/encoding_batch_v2_test.go @@ -0,0 +1,245 @@ +package state + +import ( + "testing" + + "github.com/0xPolygon/cdk/hex" + "github.com/0xPolygon/cdk/log" + "github.com/stretchr/testify/require" +) + +const ( + // changeL2Block + deltaTimeStamp + indexL1InfoTree + codedL2BlockHeader = "0b73e6af6f00000000" + // 2 x [ tx coded in RLP + r,s,v,efficiencyPercentage] + codedRLP2Txs1 = "ee02843b9aca00830186a0944d5cf5032b2a844602278b01199ed191a86c93ff88016345785d8a0000808203e88080bff0e780ba7db409339fd3f71969fa2cbf1b8535f6c725a1499d3318d3ef9c2b6340ddfab84add2c188f9efddb99771db1fe621c981846394ea4f035c85bcdd51bffee03843b9aca00830186a0944d5cf5032b2a844602278b01199ed191a86c93ff88016345785d8a0000808203e880805b346aa02230b22e62f73608de9ff39a162a6c24be9822209c770e3685b92d0756d5316ef954eefc58b068231ccea001fb7ac763ebe03afd009ad71cab36861e1bff" + // 2 x [ tx coded in RLP + r,s,v,efficiencyPercentage] + codedRLP2Txs2 = "ee80843b9aca00830186a0944d5cf5032b2a844602278b01199ed191a86c93ff88016345785d8a0000808203e880801cee7e01dc62f69a12c3510c6d64de04ee6346d84b6a017f3e786c7d87f963e75d8cc91fa983cd6d9cf55fff80d73bd26cd333b0f098acc1e58edb1fd484ad731bffee01843b9aca00830186a0944d5cf5032b2a844602278b01199ed191a86c93ff88016345785d8a0000808203e880803ee20a0764440b016c4a2ee4e7e4eb3a5a97f1e6a6c9f40bf5ecf50f95ff636d63878ddb3e997e519826c7bb26fb7c5950a208e1ec722a9f1c568c4e479b40341cff" + codedL2Block1 = codedL2BlockHeader + codedRLP2Txs1 + codedL2Block2 = codedL2BlockHeader + codedRLP2Txs2 + // Batch 420.000 (Incaberry) from Testnet + realBatchIncaberry = "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" + realBatchConvertedEtrog = codedL2BlockHeader + realBatchIncaberry +) + +func TestDecodeEmptyBatchV2(t *testing.T) { + batchL2Data, err := hex.DecodeString("") + require.NoError(t, err) + + batch, err := DecodeBatchV2(batchL2Data) + require.NoError(t, err) + require.Equal(t, 0, len(batch.Blocks)) +} + +func TestDecodeBatches(t *testing.T) { + type testCase struct { + name string + batchL2Data string + expectedError error + } + testCases := []testCase{ + { + name: "batch dont start with 0x0b (changeL2Block)", + batchL2Data: "0c", + expectedError: ErrInvalidBatchV2, + }, + { + name: "batch no enough data to decode block.deltaTimestamp", + batchL2Data: "0b010203", + expectedError: ErrInvalidBatchV2, + }, + { + name: "batch no enough data to decode block.index", + batchL2Data: "0b01020304010203", + expectedError: ErrInvalidBatchV2, + }, + { + name: "batch no enough data to decode block.index", + batchL2Data: "0b01020304010203", + expectedError: ErrInvalidBatchV2, + }, + { + name: "valid batch no trx, just L2Block", + batchL2Data: "0b0102030401020304", + expectedError: nil, + }, + { + name: "invalid batch bad RLP codification", + batchL2Data: "0b" + "01020304" + "01020304" + "7f", + expectedError: ErrInvalidRLP, + }, + { + name: "1 block + 2 txs", + batchL2Data: "0b" + "73e6af6f" + "00000000" + codedRLP2Txs1 + codedRLP2Txs2, + expectedError: nil, + }, + { + name: "1 block + 1 txs", + batchL2Data: "0b" + "73e6af6f" + "00000000" + codedRLP2Txs1, + expectedError: nil, + }, + { + name: "1 block + 1 txs, missiging efficiencyPercentage", + batchL2Data: "0b" + "73e6af6f" + "00000000" + codedRLP2Txs1[0:len(codedRLP2Txs1)-2], + expectedError: ErrInvalidBatchV2, + }, + { + name: "real batch converted to etrog", + batchL2Data: realBatchConvertedEtrog, + expectedError: nil, + }, + { + name: "pass a V1 batch(incaberry) must fail", + batchL2Data: realBatchIncaberry, + expectedError: ErrBatchV2DontStartWithChangeL2Block, + }, + } + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + log.Debug("************************ ", tc.name, " ************************") + data, err := hex.DecodeString(tc.batchL2Data) + require.NoError(t, err) + _, err = DecodeBatchV2(data) + if err != nil { + log.Debugf("[%s] %v", tc.name, err) + } + if tc.expectedError != nil { + require.ErrorIs(t, err, tc.expectedError) + } else { + require.NoError(t, err) + } + }) + } +} + +func TestDecodeBatchV2(t *testing.T) { + batchL2Data, err := hex.DecodeString(codedL2Block1) + require.NoError(t, err) + batchL2Data2, err := hex.DecodeString(codedL2Block2) + require.NoError(t, err) + batch := append(batchL2Data, batchL2Data2...) + decodedBatch, err := DecodeBatchV2(batch) + require.NoError(t, err) + require.Equal(t, 2, len(decodedBatch.Blocks)) + require.Equal(t, uint32(0x73e6af6f), decodedBatch.Blocks[0].DeltaTimestamp) + require.Equal(t, uint32(0x00000000), decodedBatch.Blocks[0].IndexL1InfoTree) +} + +func TestDecodeRLPLength(t *testing.T) { + type testCase struct { + name string + data string + expectedError error + expectedResult uint64 + } + testCases := []testCase{ + { + name: "must start >= 0xc0", + data: "bf", + expectedError: ErrInvalidRLP, + }, + { + name: "shortRLP: c0 -> len=0", + data: "c0", + expectedResult: 1, + }, + { + name: "shortRLP: c1 -> len=1", + data: "c1", + expectedResult: 2, // 1 byte header + 1 byte of data + }, + { + name: "shortRLP: byte>0xf7", + data: "f7", + expectedResult: 56, // 1 byte header + 55 bytes of data + }, + { + name: "longRLP: f8: 1 extra byte, missing data", + data: "f8", + expectedError: ErrInvalidRLP, + }, + { + name: "longRLP: f8:size is stored in next byte ->0x01 (code add the length of bytes of the size??)", + data: "f8" + "01", + expectedResult: 3, // 2 bytes of header + 1 byte of data + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + log.Debug("************************ ", tc.name, " ************************") + data, err := hex.DecodeString(tc.data) + require.NoError(t, err) + length, err := decodeRLPListLengthFromOffset(data, 0) + if err != nil { + log.Debugf("[%s] %v", tc.name, err) + } + if tc.expectedError != nil { + require.ErrorIs(t, err, tc.expectedError) + } else { + require.NoError(t, err) + require.Equal(t, tc.expectedResult, length) + } + }) + } +} + +func TestEncodeBatchV2(t *testing.T) { + block1 := L2BlockRaw{ + ChangeL2BlockHeader: ChangeL2BlockHeader{ + DeltaTimestamp: 123, + IndexL1InfoTree: 456, + }, + Transactions: []L2TxRaw{}, + } + block2 := L2BlockRaw{ + ChangeL2BlockHeader: ChangeL2BlockHeader{ + DeltaTimestamp: 789, + IndexL1InfoTree: 101112, + }, + Transactions: []L2TxRaw{}, + } + blocks := []L2BlockRaw{block1, block2} + + expectedBatchData := []byte{ + 0xb, 0x0, 0x0, 0x0, 0x7b, 0x0, 0x0, 0x1, 0xc8, 0xb, 0x0, 0x0, 0x3, 0x15, 0x0, 0x1, 0x8a, 0xf8, + } + + batchData, err := EncodeBatchV2(&BatchRawV2{Blocks: blocks}) + require.NoError(t, err) + require.Equal(t, expectedBatchData, batchData) +} + +func TestDecodeEncodeBatchV2(t *testing.T) { + batchL2Data, err := hex.DecodeString(codedL2Block1 + codedL2Block2) + require.NoError(t, err) + decodedBatch, err := DecodeBatchV2(batchL2Data) + require.NoError(t, err) + require.Equal(t, 2, len(decodedBatch.Blocks)) + encoded, err := EncodeBatchV2(decodedBatch) + require.NoError(t, err) + require.Equal(t, batchL2Data, encoded) +} + +func TestEncodeEmptyBatchV2Fails(t *testing.T) { + l2Batch := BatchRawV2{} + _, err := EncodeBatchV2(&l2Batch) + require.ErrorIs(t, err, ErrInvalidBatchV2) + _, err = EncodeBatchV2(nil) + require.ErrorIs(t, err, ErrInvalidBatchV2) +} + +func TestDecodeForcedBatchV2(t *testing.T) { + batchL2Data, err := hex.DecodeString(codedRLP2Txs1) + require.NoError(t, err) + decodedBatch, err := DecodeForcedBatchV2(batchL2Data) + require.NoError(t, err) + require.Equal(t, 2, len(decodedBatch.Transactions)) +} + +func TestDecodeForcedBatchV2WithRegularBatch(t *testing.T) { + batchL2Data, err := hex.DecodeString(codedL2Block1) + require.NoError(t, err) + _, err = DecodeForcedBatchV2(batchL2Data) + require.Error(t, err) +} diff --git a/state/errors.go b/state/errors.go new file mode 100644 index 00000000..5a394a24 --- /dev/null +++ b/state/errors.go @@ -0,0 +1,68 @@ +package state + +import ( + "errors" + "fmt" +) + +var ( + // ErrInvalidBatchHeader indicates the batch header is invalid + ErrInvalidBatchHeader = errors.New("invalid batch header") + // ErrUnexpectedBatch indicates that the batch is unexpected + ErrUnexpectedBatch = errors.New("unexpected batch") + // ErrStateNotSynchronized indicates the state database may be empty + ErrStateNotSynchronized = errors.New("state not synchronized") + // ErrNotFound indicates an object has not been found for the search criteria used + ErrNotFound = errors.New("object not found") + // ErrNilDBTransaction indicates the db transaction has not been properly initialized + ErrNilDBTransaction = errors.New("database transaction not properly initialized") + // ErrAlreadyInitializedDBTransaction indicates the db transaction was already initialized + ErrAlreadyInitializedDBTransaction = errors.New("database transaction already initialized") + // ErrNotEnoughIntrinsicGas indicates the gas is not enough to cover the intrinsic gas cost + ErrNotEnoughIntrinsicGas = fmt.Errorf("not enough gas supplied for intrinsic gas costs") + // ErrParsingExecutorTrace indicates an error occurred while parsing the executor trace + ErrParsingExecutorTrace = fmt.Errorf("error while parsing executor trace") + // ErrInvalidBatchNumber indicates the provided batch number is not the latest in db + ErrInvalidBatchNumber = errors.New("provided batch number is not latest") + // ErrLastBatchShouldBeClosed indicates that last batch needs to be closed before adding a new one + ErrLastBatchShouldBeClosed = errors.New("last batch needs to be closed before adding a new one") + // ErrBatchAlreadyClosed indicates that batch is already closed + ErrBatchAlreadyClosed = errors.New("batch is already closed") + // ErrClosingBatchWithoutTxs indicates that the batch attempted to close does not have txs. + ErrClosingBatchWithoutTxs = errors.New("can not close a batch without transactions") + // ErrTimestampGE indicates that timestamp needs to be greater or equal + ErrTimestampGE = errors.New("timestamp needs to be greater or equal") + // ErrDBTxNil indicates that the method requires a dbTx that is not nil + ErrDBTxNil = errors.New("the method requires a dbTx that is not nil") + // ErrExistingTxGreaterThanProcessedTx indicates that we have more txs stored + // in db than the txs we want to process. + ErrExistingTxGreaterThanProcessedTx = errors.New("there are more transactions in the database than in the processed transaction set") + // ErrOutOfOrderProcessedTx indicates the the processed transactions of an + // ongoing batch are not in the same order as the transactions stored in the + // database for the same batch. + ErrOutOfOrderProcessedTx = errors.New("the processed transactions are not in the same order as the stored transactions") + // ErrInsufficientFundsForTransfer is returned if the transaction sender doesn't + // have enough funds for transfer(topmost call only). + ErrInsufficientFundsForTransfer = errors.New("insufficient funds for transfer") + // ErrExecutorNil indicates that the method requires an executor that is not nil + ErrExecutorNil = errors.New("the method requires an executor that is not nil") + // ErrStateTreeNil indicates that the method requires a state tree that is not nil + ErrStateTreeNil = errors.New("the method requires a state tree that is not nil") + // ErrUnsupportedDuration is returned if the provided unit for a time + // interval is not supported by our conversion mechanism. + ErrUnsupportedDuration = errors.New("unsupported time duration") + // ErrInvalidData is the error when the raw txs is unexpected + ErrInvalidData = errors.New("invalid data") + // ErrInvalidBlockRange returned when the selected block range is invalid, generally + // because the toBlock is bigger than the fromBlock + ErrInvalidBlockRange = errors.New("invalid block range") + // ErrMaxLogsCountLimitExceeded returned when the number of logs is bigger than the + // configured limit + ErrMaxLogsCountLimitExceeded = errors.New("query returned more than %v results") + // ErrMaxLogsBlockRangeLimitExceeded returned when the range between block number range + // to filter logs is bigger than the configured limit + ErrMaxLogsBlockRangeLimitExceeded = errors.New("logs are limited to a %v block range") + // ErrMaxNativeBlockHashBlockRangeLimitExceeded returned when the range between block number range + // to filter native block hashes is bigger than the configured limit + ErrMaxNativeBlockHashBlockRangeLimitExceeded = errors.New("native block hashes are limited to a %v block range") +) diff --git a/state/forkid.go b/state/forkid.go new file mode 100644 index 00000000..27617313 --- /dev/null +++ b/state/forkid.go @@ -0,0 +1,12 @@ +package state + +const ( + // FORKID_BLUEBERRY is the fork id 4 + FORKID_BLUEBERRY = 4 + // FORKID_DRAGONFRUIT is the fork id 5 + FORKID_DRAGONFRUIT = 5 + // FORKID_INCABERRY is the fork id 6 + FORKID_INCABERRY = 6 + // FORKID_ETROG is the fork id 7 + FORKID_ETROG = 7 +) diff --git a/state/genesis.go b/state/genesis.go new file mode 100644 index 00000000..368a56eb --- /dev/null +++ b/state/genesis.go @@ -0,0 +1,26 @@ +package state + +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/state/helper.go b/state/helper.go new file mode 100644 index 00000000..efb1b1df --- /dev/null +++ b/state/helper.go @@ -0,0 +1,188 @@ +package state + +import ( + "fmt" + "math/big" + "strconv" + + "github.com/0xPolygon/cdk/hex" + "github.com/0xPolygon/cdk/log" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/rlp" +) + +const ( + double = 2 + ether155V = 27 + etherPre155V = 35 + // MaxEffectivePercentage is the maximum value that can be used as effective percentage + MaxEffectivePercentage = uint8(255) + // Decoding constants + headerByteLength uint64 = 1 + sLength uint64 = 32 + rLength uint64 = 32 + vLength uint64 = 1 + c0 uint64 = 192 // 192 is c0. This value is defined by the rlp protocol + ff uint64 = 255 // max value of rlp header + shortRlp uint64 = 55 // length of the short rlp codification + f7 uint64 = 247 // 192 + 55 = c0 + shortRlp + + // EfficiencyPercentageByteLength is the length of the effective percentage in bytes + EfficiencyPercentageByteLength uint64 = 1 +) + +func prepareRLPTxData(tx *types.Transaction) ([]byte, error) { + v, r, s := tx.RawSignatureValues() + sign := 1 - (v.Uint64() & 1) + + nonce, gasPrice, gas, to, value, data, chainID := tx.Nonce(), tx.GasPrice(), tx.Gas(), tx.To(), tx.Value(), tx.Data(), tx.ChainId() + + rlpFieldsToEncode := []interface{}{ + nonce, + gasPrice, + gas, + to, + value, + data, + } + + if !IsPreEIP155Tx(tx) { + rlpFieldsToEncode = append(rlpFieldsToEncode, chainID) + rlpFieldsToEncode = append(rlpFieldsToEncode, uint(0)) + rlpFieldsToEncode = append(rlpFieldsToEncode, uint(0)) + } + + txCodedRlp, err := rlp.EncodeToBytes(rlpFieldsToEncode) + if err != nil { + return nil, err + } + + newV := new(big.Int).Add(big.NewInt(ether155V), big.NewInt(int64(sign))) + newRPadded := fmt.Sprintf("%064s", r.Text(hex.Base)) + newSPadded := fmt.Sprintf("%064s", s.Text(hex.Base)) + newVPadded := fmt.Sprintf("%02s", newV.Text(hex.Base)) + txData, err := hex.DecodeString(hex.EncodeToString(txCodedRlp) + newRPadded + newSPadded + newVPadded) + if err != nil { + return nil, err + } + return txData, nil +} + +// DecodeTxs extracts Transactions for its encoded form +func DecodeTxs(txsData []byte, forkID uint64) ([]*types.Transaction, []byte, []uint8, error) { + // Process coded txs + var pos uint64 + var txs []*types.Transaction + var efficiencyPercentages []uint8 + txDataLength := uint64(len(txsData)) + if txDataLength == 0 { + return txs, txsData, nil, nil + } + for pos < txDataLength { + num, err := strconv.ParseUint(hex.EncodeToString(txsData[pos:pos+1]), hex.Base, hex.BitSize64) + if err != nil { + log.Debug("error parsing header length: ", err) + return []*types.Transaction{}, txsData, []uint8{}, err + } + // First byte is the length and must be ignored + if num < c0 { + log.Debugf("error num < c0 : %d, %d", num, c0) + return []*types.Transaction{}, txsData, []uint8{}, ErrInvalidData + } + length := num - c0 + if length > shortRlp { // If rlp is bigger than length 55 + // n is the length of the rlp data without the header (1 byte) for example "0xf7" + if (pos + 1 + num - f7) > txDataLength { + log.Debug("error parsing length: ", err) + return []*types.Transaction{}, txsData, []uint8{}, err + } + n, err := strconv.ParseUint(hex.EncodeToString(txsData[pos+1:pos+1+num-f7]), hex.Base, hex.BitSize64) // +1 is the header. For example 0xf7 + if err != nil { + log.Debug("error parsing length: ", err) + return []*types.Transaction{}, txsData, []uint8{}, err + } + if n+num < f7 { + log.Debug("error n + num < f7: ", err) + return []*types.Transaction{}, txsData, []uint8{}, ErrInvalidData + } + length = n + num - f7 // num - f7 is the header. For example 0xf7 + } + + endPos := pos + length + rLength + sLength + vLength + headerByteLength + + if forkID >= FORKID_DRAGONFRUIT { + endPos += EfficiencyPercentageByteLength + } + + if endPos > txDataLength { + err := fmt.Errorf("endPos %d is bigger than txDataLength %d", endPos, txDataLength) + log.Debug("error parsing header: ", err) + return []*types.Transaction{}, txsData, []uint8{}, ErrInvalidData + } + + if endPos < pos { + err := fmt.Errorf("endPos %d is smaller than pos %d", endPos, pos) + log.Debug("error parsing header: ", err) + return []*types.Transaction{}, txsData, []uint8{}, ErrInvalidData + } + + if endPos < pos { + err := fmt.Errorf("endPos %d is smaller than pos %d", endPos, pos) + log.Debug("error parsing header: ", err) + return []*types.Transaction{}, txsData, []uint8{}, ErrInvalidData + } + + fullDataTx := txsData[pos:endPos] + dataStart := pos + length + headerByteLength + txInfo := txsData[pos:dataStart] + rData := txsData[dataStart : dataStart+rLength] + sData := txsData[dataStart+rLength : dataStart+rLength+sLength] + vData := txsData[dataStart+rLength+sLength : dataStart+rLength+sLength+vLength] + + if forkID >= FORKID_DRAGONFRUIT { + efficiencyPercentage := txsData[dataStart+rLength+sLength+vLength : endPos] + efficiencyPercentages = append(efficiencyPercentages, efficiencyPercentage[0]) + } + + pos = endPos + + // Decode rlpFields + var rlpFields [][]byte + err = rlp.DecodeBytes(txInfo, &rlpFields) + if err != nil { + log.Error("error decoding tx Bytes: ", err, ". fullDataTx: ", hex.EncodeToString(fullDataTx), "\n tx: ", hex.EncodeToString(txInfo), "\n Txs received: ", hex.EncodeToString(txsData)) + return []*types.Transaction{}, txsData, []uint8{}, ErrInvalidData + } + + legacyTx, err := RlpFieldsToLegacyTx(rlpFields, vData, rData, sData) + if err != nil { + log.Debug("error creating tx from rlp fields: ", err, ". fullDataTx: ", hex.EncodeToString(fullDataTx), "\n tx: ", hex.EncodeToString(txInfo), "\n Txs received: ", hex.EncodeToString(txsData)) + return []*types.Transaction{}, txsData, []uint8{}, err + } + + tx := types.NewTx(legacyTx) + txs = append(txs, tx) + } + return txs, txsData, efficiencyPercentages, nil +} + +// DecodeTx decodes a string rlp tx representation into a types.Transaction instance +func DecodeTx(encodedTx string) (*types.Transaction, error) { + b, err := hex.DecodeHex(encodedTx) + if err != nil { + return nil, err + } + + tx := new(types.Transaction) + if err := tx.UnmarshalBinary(b); err != nil { + return nil, err + } + return tx, nil +} + +// IsPreEIP155Tx checks if the tx is a tx that has a chainID as zero and +// V field is either 27 or 28 +func IsPreEIP155Tx(tx *types.Transaction) bool { + v, _, _ := tx.RawSignatureValues() + return tx.ChainId().Uint64() == 0 && (v.Uint64() == 27 || v.Uint64() == 28) +} diff --git a/state/interfaces.go b/state/interfaces.go new file mode 100644 index 00000000..a0c38337 --- /dev/null +++ b/state/interfaces.go @@ -0,0 +1,30 @@ +package state + +import ( + "context" + + "github.com/jackc/pgconn" + "github.com/jackc/pgx/v4" +) + +type storage 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 + Begin(ctx context.Context) (pgx.Tx, error) + AddSequence(ctx context.Context, sequence Sequence, dbTx pgx.Tx) error + CheckProofContainsCompleteSequences(ctx context.Context, proof *Proof, dbTx pgx.Tx) (bool, error) + GetProofReadyToVerify(ctx context.Context, lastVerfiedBatchNumber uint64, dbTx pgx.Tx) (*Proof, error) + GetProofsToAggregate(ctx context.Context, dbTx pgx.Tx) (*Proof, *Proof, error) + AddGeneratedProof(ctx context.Context, proof *Proof, dbTx pgx.Tx) error + UpdateGeneratedProof(ctx context.Context, proof *Proof, dbTx pgx.Tx) error + DeleteGeneratedProofs(ctx context.Context, batchNumber uint64, batchNumberFinal uint64, dbTx pgx.Tx) error + DeleteUngeneratedProofs(ctx context.Context, dbTx pgx.Tx) error + CleanupGeneratedProofs(ctx context.Context, batchNumber uint64, dbTx pgx.Tx) error + CleanupLockedProofs(ctx context.Context, duration string, dbTx pgx.Tx) (int64, error) + CheckProofExistsForBatch(ctx context.Context, batchNumber uint64, dbTx pgx.Tx) (bool, error) + AddBatch(ctx context.Context, batch *Batch, datastream []byte, dbTx pgx.Tx) error + GetBatch(ctx context.Context, batchNumber uint64, dbTx pgx.Tx) (*Batch, []byte, error) + DeleteBatchesOlderThanBatchNumber(ctx context.Context, batchNumber uint64, dbTx pgx.Tx) error + DeleteBatchesNewerThanBatchNumber(ctx context.Context, batchNumber uint64, dbTx pgx.Tx) error +} diff --git a/state/pgstatestorage/batch.go b/state/pgstatestorage/batch.go new file mode 100644 index 00000000..ab8414d1 --- /dev/null +++ b/state/pgstatestorage/batch.go @@ -0,0 +1,46 @@ +package pgstatestorage + +import ( + "context" + + "github.com/0xPolygon/cdk/state" + "github.com/ethereum/go-ethereum/common" + "github.com/jackc/pgx/v4" +) + +// AddBatch stores a batch +func (p *PostgresStorage) AddBatch(ctx context.Context, batch *state.Batch, datastream []byte, dbTx pgx.Tx) error { + const addInputHashSQL = "INSERT INTO aggregator.batch (batch_num, batch, datastream) VALUES ($1, $2, $3) ON CONFLICT (batch_num) DO UPDATE SET batch = $2, datastream = $3" + e := p.getExecQuerier(dbTx) + _, err := e.Exec(ctx, addInputHashSQL, batch.BatchNumber, &batch, common.Bytes2Hex(datastream)) + return err +} + +// GetBatch gets a batch by a given batch number +func (p *PostgresStorage) GetBatch(ctx context.Context, batchNumber uint64, dbTx pgx.Tx) (*state.Batch, []byte, error) { + const getInputHashSQL = "SELECT batch, datastream FROM aggregator.batch WHERE batch_num = $1" + e := p.getExecQuerier(dbTx) + var batch *state.Batch + var streamStr string + err := e.QueryRow(ctx, getInputHashSQL, batchNumber).Scan(&batch, &streamStr) + if err != nil { + return nil, nil, err + } + return batch, common.Hex2Bytes(streamStr), nil +} + +// DeleteBatchesOlderThanBatchNumber deletes batches previous to the given batch number +func (p *PostgresStorage) DeleteBatchesOlderThanBatchNumber(ctx context.Context, batchNumber uint64, dbTx pgx.Tx) error { + const deleteBatchesSQL = "DELETE FROM aggregator.batch WHERE batch_num < $1" + e := p.getExecQuerier(dbTx) + _, err := e.Exec(ctx, deleteBatchesSQL, batchNumber) + return err +} + +// DeleteBatchesNewerThanBatchNumber deletes batches previous to the given batch number +func (p *PostgresStorage) DeleteBatchesNewerThanBatchNumber(ctx context.Context, batchNumber uint64, dbTx pgx.Tx) error { + const deleteBatchesSQL = "DELETE FROM aggregator.batch WHERE batch_num > $1" + e := p.getExecQuerier(dbTx) + _, err := e.Exec(ctx, deleteBatchesSQL, batchNumber) + return err +} diff --git a/state/pgstatestorage/interfaces.go b/state/pgstatestorage/interfaces.go new file mode 100644 index 00000000..e5f7402b --- /dev/null +++ b/state/pgstatestorage/interfaces.go @@ -0,0 +1,14 @@ +package pgstatestorage + +import ( + "context" + + "github.com/jackc/pgconn" + "github.com/jackc/pgx/v4" +) + +type ExecQuerier 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 +} diff --git a/state/pgstatestorage/pgstatestorage.go b/state/pgstatestorage/pgstatestorage.go new file mode 100644 index 00000000..7e294c6b --- /dev/null +++ b/state/pgstatestorage/pgstatestorage.go @@ -0,0 +1,29 @@ +package pgstatestorage + +import ( + "github.com/0xPolygon/cdk/state" + "github.com/jackc/pgx/v4" + "github.com/jackc/pgx/v4/pgxpool" +) + +// PostgresStorage implements the Storage interface +type PostgresStorage struct { + cfg state.Config + *pgxpool.Pool +} + +// NewPostgresStorage creates a new StateDB +func NewPostgresStorage(cfg state.Config, db *pgxpool.Pool) *PostgresStorage { + return &PostgresStorage{ + cfg, + db, + } +} + +// getExecQuerier determines which execQuerier to use, dbTx or the main pgxpool +func (p *PostgresStorage) getExecQuerier(dbTx pgx.Tx) ExecQuerier { + if dbTx != nil { + return dbTx + } + return p +} diff --git a/state/pgstatestorage/proof.go b/state/pgstatestorage/proof.go new file mode 100644 index 00000000..98668a44 --- /dev/null +++ b/state/pgstatestorage/proof.go @@ -0,0 +1,227 @@ +package pgstatestorage + +import ( + "context" + "errors" + "fmt" + "time" + + "github.com/0xPolygon/cdk/state" + "github.com/jackc/pgx/v4" +) + +// CheckProofExistsForBatch checks if the batch is already included in any proof +func (p *PostgresStorage) CheckProofExistsForBatch(ctx context.Context, batchNumber uint64, dbTx pgx.Tx) (bool, error) { + const checkProofExistsForBatchSQL = ` + SELECT EXISTS (SELECT 1 FROM aggregator.proof p WHERE $1 >= p.batch_num AND $1 <= p.batch_num_final) + ` + e := p.getExecQuerier(dbTx) + var exists bool + err := e.QueryRow(ctx, checkProofExistsForBatchSQL, batchNumber).Scan(&exists) + if err != nil && !errors.Is(err, pgx.ErrNoRows) { + return exists, err + } + return exists, nil +} + +// CheckProofContainsCompleteSequences checks if a recursive proof contains complete sequences +func (p *PostgresStorage) CheckProofContainsCompleteSequences(ctx context.Context, proof *state.Proof, dbTx pgx.Tx) (bool, error) { + const getProofContainsCompleteSequencesSQL = ` + SELECT EXISTS (SELECT 1 FROM aggregator.sequence s1 WHERE s1.from_batch_num = $1) AND + EXISTS (SELECT 1 FROM aggregator.sequence s2 WHERE s2.to_batch_num = $2) + ` + e := p.getExecQuerier(dbTx) + var exists bool + err := e.QueryRow(ctx, getProofContainsCompleteSequencesSQL, proof.BatchNumber, proof.BatchNumberFinal).Scan(&exists) + if err != nil && !errors.Is(err, pgx.ErrNoRows) { + return exists, err + } + return exists, nil +} + +// GetProofReadyToVerify return the proof that is ready to verify +func (p *PostgresStorage) GetProofReadyToVerify(ctx context.Context, lastVerfiedBatchNumber uint64, dbTx pgx.Tx) (*state.Proof, error) { + const getProofReadyToVerifySQL = ` + SELECT + p.batch_num, + p.batch_num_final, + p.proof, + p.proof_id, + p.input_prover, + p.prover, + p.prover_id, + p.generating_since, + p.created_at, + p.updated_at + FROM aggregator.proof p + WHERE batch_num = $1 AND generating_since IS NULL AND + EXISTS (SELECT 1 FROM aggregator.sequence s1 WHERE s1.from_batch_num = p.batch_num) AND + EXISTS (SELECT 1 FROM aggregator.sequence s2 WHERE s2.to_batch_num = p.batch_num_final) + ` + + var proof *state.Proof = &state.Proof{} + + e := p.getExecQuerier(dbTx) + row := e.QueryRow(ctx, getProofReadyToVerifySQL, lastVerfiedBatchNumber+1) + err := row.Scan(&proof.BatchNumber, &proof.BatchNumberFinal, &proof.Proof, &proof.ProofID, &proof.InputProver, &proof.Prover, &proof.ProverID, &proof.GeneratingSince, &proof.CreatedAt, &proof.UpdatedAt) + + if errors.Is(err, pgx.ErrNoRows) { + return nil, state.ErrNotFound + } else if err != nil { + return nil, err + } + + return proof, err +} + +// GetProofsToAggregate return the next to proof that it is possible to aggregate +func (p *PostgresStorage) GetProofsToAggregate(ctx context.Context, dbTx pgx.Tx) (*state.Proof, *state.Proof, error) { + var ( + proof1 *state.Proof = &state.Proof{} + proof2 *state.Proof = &state.Proof{} + ) + + // TODO: add comments to explain the query + const getProofsToAggregateSQL = ` + SELECT + p1.batch_num as p1_batch_num, + p1.batch_num_final as p1_batch_num_final, + p1.proof as p1_proof, + p1.proof_id as p1_proof_id, + p1.input_prover as p1_input_prover, + p1.prover as p1_prover, + p1.prover_id as p1_prover_id, + p1.generating_since as p1_generating_since, + p1.created_at as p1_created_at, + p1.updated_at as p1_updated_at, + p2.batch_num as p2_batch_num, + p2.batch_num_final as p2_batch_num_final, + p2.proof as p2_proof, + p2.proof_id as p2_proof_id, + p2.input_prover as p2_input_prover, + p2.prover as p2_prover, + p2.prover_id as p2_prover_id, + p2.generating_since as p2_generating_since, + p2.created_at as p2_created_at, + p2.updated_at as p2_updated_at + FROM aggregator.proof p1 INNER JOIN aggregator.proof p2 ON p1.batch_num_final = p2.batch_num - 1 + WHERE p1.generating_since IS NULL AND p2.generating_since IS NULL AND + p1.proof IS NOT NULL AND p2.proof IS NOT NULL AND + ( + EXISTS ( + SELECT 1 FROM aggregator.sequence s + WHERE p1.batch_num >= s.from_batch_num AND p1.batch_num <= s.to_batch_num AND + p1.batch_num_final >= s.from_batch_num AND p1.batch_num_final <= s.to_batch_num AND + p2.batch_num >= s.from_batch_num AND p2.batch_num <= s.to_batch_num AND + p2.batch_num_final >= s.from_batch_num AND p2.batch_num_final <= s.to_batch_num + ) + OR + ( + EXISTS ( SELECT 1 FROM aggregator.sequence s WHERE p1.batch_num = s.from_batch_num) AND + EXISTS ( SELECT 1 FROM aggregator.sequence s WHERE p1.batch_num_final = s.to_batch_num) AND + EXISTS ( SELECT 1 FROM aggregator.sequence s WHERE p2.batch_num = s.from_batch_num) AND + EXISTS ( SELECT 1 FROM aggregator.sequence s WHERE p2.batch_num_final = s.to_batch_num) + ) + ) + ORDER BY p1.batch_num ASC + LIMIT 1 + ` + + e := p.getExecQuerier(dbTx) + row := e.QueryRow(ctx, getProofsToAggregateSQL) + err := row.Scan( + &proof1.BatchNumber, &proof1.BatchNumberFinal, &proof1.Proof, &proof1.ProofID, &proof1.InputProver, &proof1.Prover, &proof1.ProverID, &proof1.GeneratingSince, &proof1.CreatedAt, &proof1.UpdatedAt, + &proof2.BatchNumber, &proof2.BatchNumberFinal, &proof2.Proof, &proof2.ProofID, &proof2.InputProver, &proof2.Prover, &proof2.ProverID, &proof2.GeneratingSince, &proof2.CreatedAt, &proof2.UpdatedAt) + + if errors.Is(err, pgx.ErrNoRows) { + return nil, nil, state.ErrNotFound + } else if err != nil { + return nil, nil, err + } + + return proof1, proof2, err +} + +// AddGeneratedProof adds a generated proof to the storage +func (p *PostgresStorage) AddGeneratedProof(ctx context.Context, proof *state.Proof, dbTx pgx.Tx) error { + const addGeneratedProofSQL = "INSERT INTO aggregator.proof (batch_num, batch_num_final, proof, proof_id, input_prover, prover, prover_id, generating_since, created_at, updated_at) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)" + e := p.getExecQuerier(dbTx) + now := time.Now().UTC().Round(time.Microsecond) + _, err := e.Exec(ctx, addGeneratedProofSQL, proof.BatchNumber, proof.BatchNumberFinal, proof.Proof, proof.ProofID, proof.InputProver, proof.Prover, proof.ProverID, proof.GeneratingSince, now, now) + return err +} + +// UpdateGeneratedProof updates a generated proof in the storage +func (p *PostgresStorage) UpdateGeneratedProof(ctx context.Context, proof *state.Proof, dbTx pgx.Tx) error { + const addGeneratedProofSQL = "UPDATE aggregator.proof SET proof = $3, proof_id = $4, input_prover = $5, prover = $6, prover_id = $7, generating_since = $8, updated_at = $9 WHERE batch_num = $1 AND batch_num_final = $2" + e := p.getExecQuerier(dbTx) + now := time.Now().UTC().Round(time.Microsecond) + _, err := e.Exec(ctx, addGeneratedProofSQL, proof.BatchNumber, proof.BatchNumberFinal, proof.Proof, proof.ProofID, proof.InputProver, proof.Prover, proof.ProverID, proof.GeneratingSince, now) + return err +} + +// DeleteGeneratedProofs deletes from the storage the generated proofs falling +// inside the batch numbers range. +func (p *PostgresStorage) DeleteGeneratedProofs(ctx context.Context, batchNumber uint64, batchNumberFinal uint64, dbTx pgx.Tx) error { + const deleteGeneratedProofSQL = "DELETE FROM aggregator.proof WHERE batch_num >= $1 AND batch_num_final <= $2" + e := p.getExecQuerier(dbTx) + _, err := e.Exec(ctx, deleteGeneratedProofSQL, batchNumber, batchNumberFinal) + return err +} + +// CleanupGeneratedProofs deletes from the storage the generated proofs up to +// the specified batch number included. +func (p *PostgresStorage) CleanupGeneratedProofs(ctx context.Context, batchNumber uint64, dbTx pgx.Tx) error { + const deleteGeneratedProofSQL = "DELETE FROM aggregator.proof WHERE batch_num_final <= $1" + e := p.getExecQuerier(dbTx) + _, err := e.Exec(ctx, deleteGeneratedProofSQL, batchNumber) + return err +} + +// CleanupLockedProofs deletes from the storage the proofs locked in generating +// state for more than the provided threshold. +func (p *PostgresStorage) CleanupLockedProofs(ctx context.Context, duration string, dbTx pgx.Tx) (int64, error) { + interval, err := toPostgresInterval(duration) + if err != nil { + return 0, err + } + sql := fmt.Sprintf("DELETE FROM aggregator.proof WHERE generating_since < (NOW() - interval '%s')", interval) + e := p.getExecQuerier(dbTx) + ct, err := e.Exec(ctx, sql) + if err != nil { + return 0, err + } + return ct.RowsAffected(), nil +} + +// DeleteUngeneratedProofs deletes ungenerated proofs. +// This method is meant to be use during aggregator boot-up sequence +func (p *PostgresStorage) DeleteUngeneratedProofs(ctx context.Context, dbTx pgx.Tx) error { + const deleteUngeneratedProofsSQL = "DELETE FROM aggregator.proof WHERE generating_since IS NOT NULL" + e := p.getExecQuerier(dbTx) + _, err := e.Exec(ctx, deleteUngeneratedProofsSQL) + return err +} + +func toPostgresInterval(duration string) (string, error) { + unit := duration[len(duration)-1] + var pgUnit string + + switch unit { + case 's': + pgUnit = "second" + case 'm': + pgUnit = "minute" + case 'h': + pgUnit = "hour" + default: + return "", state.ErrUnsupportedDuration + } + + isMoreThanOne := duration[0] != '1' || len(duration) > 2 //nolint:gomnd + if isMoreThanOne { + pgUnit = pgUnit + "s" + } + + return fmt.Sprintf("%s %s", duration[:len(duration)-1], pgUnit), nil +} diff --git a/state/pgstatestorage/sequence.go b/state/pgstatestorage/sequence.go new file mode 100644 index 00000000..12b19f7e --- /dev/null +++ b/state/pgstatestorage/sequence.go @@ -0,0 +1,17 @@ +package pgstatestorage + +import ( + "context" + + "github.com/0xPolygon/cdk/state" + "github.com/jackc/pgx/v4" +) + +// AddSequence stores the sequence information to allow the aggregator verify sequences. +func (p *PostgresStorage) AddSequence(ctx context.Context, sequence state.Sequence, dbTx pgx.Tx) error { + const addSequenceSQL = "INSERT INTO aggregator.sequence (from_batch_num, to_batch_num) VALUES($1, $2) ON CONFLICT (from_batch_num) DO UPDATE SET to_batch_num = $2" + + e := p.getExecQuerier(dbTx) + _, err := e.Exec(ctx, addSequenceSQL, sequence.FromBatchNumber, sequence.ToBatchNumber) + return err +} diff --git a/state/state.go b/state/state.go new file mode 100644 index 00000000..c9235ce4 --- /dev/null +++ b/state/state.go @@ -0,0 +1,40 @@ +package state + +import ( + "context" + + "github.com/ethereum/go-ethereum/common" + "github.com/jackc/pgx/v4" +) + +var ( + // ZeroHash is the hash 0x0000000000000000000000000000000000000000000000000000000000000000 + ZeroHash = common.Hash{} + // ZeroAddress is the address 0x0000000000000000000000000000000000000000 + ZeroAddress = common.Address{} +) + +// State is an implementation of the state +type State struct { + cfg Config + storage +} + +// NewState creates a new State +func NewState(cfg Config, storage storage) *State { + state := &State{ + cfg: cfg, + storage: storage, + } + + return state +} + +// BeginStateTransaction starts a state transaction +func (s *State) BeginStateTransaction(ctx context.Context) (pgx.Tx, error) { + tx, err := s.Begin(ctx) + if err != nil { + return nil, err + } + return tx, nil +} diff --git a/state/transaction.go b/state/transaction.go new file mode 100644 index 00000000..14ec84a6 --- /dev/null +++ b/state/transaction.go @@ -0,0 +1,88 @@ +package state + +import ( + "math/big" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" +) + +// GetSender gets the sender from the transaction's signature +func GetSender(tx *types.Transaction) (common.Address, error) { + signer := types.NewEIP155Signer(tx.ChainId()) + sender, err := signer.Sender(tx) + if err != nil { + return common.Address{}, err + } + return sender, nil +} + +// RlpFieldsToLegacyTx parses the rlp fields slice into a type.LegacyTx +// in this specific order: +// +// required fields: +// [0] Nonce uint64 +// [1] GasPrice *big.Int +// [2] Gas uint64 +// [3] To *common.Address +// [4] Value *big.Int +// [5] Data []byte +// +// optional fields: +// [6] V *big.Int +// [7] R *big.Int +// [8] S *big.Int +func RlpFieldsToLegacyTx(fields [][]byte, v, r, s []byte) (tx *types.LegacyTx, err error) { + const ( + fieldsSizeWithoutChainID = 6 + fieldsSizeWithChainID = 7 + ) + + if len(fields) < fieldsSizeWithoutChainID { + return nil, types.ErrTxTypeNotSupported + } + + nonce := big.NewInt(0).SetBytes(fields[0]).Uint64() + gasPrice := big.NewInt(0).SetBytes(fields[1]) + gas := big.NewInt(0).SetBytes(fields[2]).Uint64() + var to *common.Address + + if fields[3] != nil && len(fields[3]) != 0 { + tmp := common.BytesToAddress(fields[3]) + to = &tmp + } + value := big.NewInt(0).SetBytes(fields[4]) + data := fields[5] + + txV := big.NewInt(0).SetBytes(v) + if len(fields) >= fieldsSizeWithChainID { + chainID := big.NewInt(0).SetBytes(fields[6]) + + // a = chainId * 2 + // b = v - 27 + // c = a + 35 + // v = b + c + // + // same as: + // v = v-27+chainId*2+35 + a := new(big.Int).Mul(chainID, big.NewInt(double)) + b := new(big.Int).Sub(new(big.Int).SetBytes(v), big.NewInt(ether155V)) + c := new(big.Int).Add(a, big.NewInt(etherPre155V)) + txV = new(big.Int).Add(b, c) + } + + txR := big.NewInt(0).SetBytes(r) + txS := big.NewInt(0).SetBytes(s) + + return &types.LegacyTx{ + Nonce: nonce, + GasPrice: gasPrice, + Gas: gas, + To: to, + Value: value, + Data: data, + V: txV, + R: txR, + S: txS, + }, nil +} diff --git a/state/types.go b/state/types.go new file mode 100644 index 00000000..40aaa88b --- /dev/null +++ b/state/types.go @@ -0,0 +1,49 @@ +package state + +import ( + "time" +) + +// ZKCounters counters for the tx +type ZKCounters struct { + GasUsed uint64 + UsedKeccakHashes uint32 + UsedPoseidonHashes uint32 + UsedPoseidonPaddings uint32 + UsedMemAligns uint32 + UsedArithmetics uint32 + UsedBinaries uint32 + UsedSteps uint32 + UsedSha256Hashes_V2 uint32 +} + +// BatchResources is a struct that contains the ZKEVM resources used by a batch/tx +type BatchResources struct { + ZKCounters ZKCounters + Bytes uint64 +} + +// Proof struct +type Proof struct { + BatchNumber uint64 + BatchNumberFinal uint64 + Proof string + InputProver string + ProofID *string + // Prover name, unique identifier across prover reboots. + Prover *string + // ProverID prover process identifier. + ProverID *string + // GeneratingSince holds the timestamp for the moment in which the + // proof generation has started by a prover. Nil if the proof is not + // currently generating. + GeneratingSince *time.Time + CreatedAt time.Time + UpdatedAt time.Time +} + +// Sequence represents the sequence interval +type Sequence struct { + FromBatchNumber uint64 + ToBatchNumber uint64 +} diff --git a/test/aggregator.keystore b/test/aggregator.keystore new file mode 100644 index 00000000..36adf8bc --- /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.config.toml b/test/config/test.config.toml new file mode 100644 index 00000000..f4b55677 --- /dev/null +++ b/test/config/test.config.toml @@ -0,0 +1,110 @@ +[SequenceSender] +IsValidiumMode = false +WaitPeriodSendSequence = "15s" +LastBatchVirtualizationTimeMaxWaitPeriod = "10s" +L1BlockTimestampMargin = "30s" +MaxTxSizeForL1 = 131072 +L2Coinbase = "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266" +PrivateKey = {Path = "./test/sequencer.keystore", Password = "testonly"} +SequencesTxFileName = "sequencesender.json" +GasOffset = 80000 +WaitPeriodPurgeTxFile = "60m" +MaxPendingTx = 1 + [SequenceSender.StreamClient] + Server = "127.0.0.1:6900" + [SequenceSender.EthTxManager] + FrequencyToMonitorTxs = "1s" + WaitTxToBeMined = "2m" + GetReceiptMaxTime = "250ms" + GetReceiptWaitInterval = "1s" + PrivateKeys = [ + {Path = "./test/sequencer.keystore", Password = "testonly"}, + ] + ForcedGas = 0 + GasPriceMarginFactor = 1 + MaxGasPriceLimit = 0 + PersistenceFilename = "ethtxmanager.json" + ReadPendingL1Txs = false + SafeStatusL1NumberOfBlocks = 5 + FinalizedStatusL1NumberOfBlocks = 10 + [SequenceSender.EthTxManager.Etherman] + URL = "http://127.0.0.1:8545" + MultiGasProvider = false + L1ChainID = 1337 + HTTPHeaders = [] + +[Aggregator] +Host = "0.0.0.0" +Port = 50081 +RetryTime = "5s" +VerifyProofInterval = "10s" +TxProfitabilityCheckerType = "acceptall" +TxProfitabilityMinReward = "1.1" +ProofStatePollingInterval = "5s" +SenderAddress = "0x3f2963d678442c4af27a797453b64ef6ce9443e9" +CleanupLockedProofsInterval = "2m" +GeneratingProofCleanupThreshold = "10m" +ForkId = 9 +GasOffset = 0 +WitnessURL = "http://zkevm-erigon-seq:8123" +UseL1BatchData = true +SettlementBackend = "l1" +AggLayerTxTimeout = "5m" +AggLayerURL = "" +SequencerPrivateKey = {} +UseFullWitness = false + [Aggregator.DB] + Name = "aggregator_db" + User = "aggregator_user" + Password = "aggregator_password" + Host = "cdk-aggregator-db" + Port = "5432" + EnableLog = false + MaxConns = 200 + [Aggregator.Log] + Environment = "development" # "production" or "development" + Level = "info" + Outputs = ["stderr"] + [Aggregator.StreamClient] + Server = "zkevm-erigon-seq:6900" + [Aggregator.EthTxManager] + FrequencyToMonitorTxs = "1s" + WaitTxToBeMined = "2m" + GetReceiptMaxTime = "250ms" + GetReceiptWaitInterval = "1s" + PrivateKeys = [ + {Path = "/pk/aggregator.keystore", Password = "testonly"}, + ] + ForcedGas = 0 + GasPriceMarginFactor = 1 + MaxGasPriceLimit = 0 + PersistenceFilename = "" + ReadPendingL1Txs = false + SafeStatusL1NumberOfBlocks = 0 + FinalizedStatusL1NumberOfBlocks = 0 + [Aggregator.EthTxManager.Etherman] + URL = "" + L1ChainID = 11155111 + HTTPHeaders = [] + [Aggregator.Synchronizer] + [Aggregator.Synchronizer.DB] + Name = "sync_db" + User = "sync_user" + Password = "sync_password" + Host = "cdk-l1-sync-db" + Port = "5432" + EnableLog = false + MaxConns = 10 + [Aggregator.Synchronizer.Synchronizer] + SyncInterval = "10s" + SyncChunkSize = 1000 + GenesisBlockNumber = 5511080 + SyncUpToBlock = "finalized" + BlockFinality = "finalized" + [Aggregator.Synchronizer.Etherman] + [Aggregator.Synchronizer.Etherman.Validium] + Enabled = false + TrustedSequencerURL = "" + DataSourcePriority = ["trusted", "external"] + [Aggregator.Synchronizer.Etherman.Validium.Translator] + FullMatchRules = [] diff --git a/test/config/test.genesis.json b/test/config/test.genesis.json new file mode 100644 index 00000000..9744f7b9 --- /dev/null +++ b/test/config/test.genesis.json @@ -0,0 +1,100 @@ +{ + "l1Config": { + "chainId": 1337, + "polygonZkEVMAddress": "0x8dAF17A20c9DBA35f005b6324F493785D239719d", + "polygonRollupManagerAddress": "0xB7f8BC63BbcaD18155201308C8f3540b07f84F5e", + "polTokenAddress": "0x5FbDB2315678afecb367f032d93F642f64180aa3", + "polygonZkEVMGlobalExitRootAddress": "0x8A791620dd6260079BF849Dc5567aDC3F2FdC318" + }, + "genesisBlockNumber": 67, + "root": "0xcc9ec17819f4ac7f282949ca8c379c4d3ee1b8b7908c51b9b405b6319af67b32", + "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": "0x493732fB136a380920C390a85fc27d79C7b70756", + "bytecode": "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" + }, + { + "contractName": "PolygonZkEVMBridge proxy", + "balance": "340282366920938463463374607431768211455", + "nonce": "1", + "address": "0xB7098a13a48EcE087d3DA15b2D28eCE0f89819B8", + "bytecode": "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", + "storage": { + "0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103": "0x000000000000000000000000e34fe58dda5b8c6d547e4857e987633aa86a5e90", + "0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc": "0x000000000000000000000000493732fb136a380920c390a85fc27d79c7b70756" + } + }, + { + "contractName": "PolygonZkEVMGlobalExitRootL2 implementation", + "balance": "0", + "nonce": "1", + "address": "0xDc64a140Aa3E981100a9becA4E685f962f0cF6C9", + "bytecode": "0x608060405234801561001057600080fd5b506004361061004c5760003560e01c806301fd904414610051578063257b36321461006d57806333d6247d1461008d578063a3c573eb146100a2575b600080fd5b61005a60015481565b6040519081526020015b60405180910390f35b61005a61007b366004610162565b60006020819052908152604090205481565b6100a061009b366004610162565b6100ee565b005b6100c97f000000000000000000000000b7098a13a48ece087d3da15b2d28ece0f89819b881565b60405173ffffffffffffffffffffffffffffffffffffffff9091168152602001610064565b3373ffffffffffffffffffffffffffffffffffffffff7f000000000000000000000000b7098a13a48ece087d3da15b2d28ece0f89819b8161461015d576040517fb49365dd00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600155565b60006020828403121561017457600080fd5b503591905056fea2646970667358221220ea2171e2c85c8bff947affc409ef6fc6a8fe82fb8c174ddeda988651e595d66564736f6c63430008140033" + }, + { + "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/config/test.prover.config.json b/test/config/test.prover.config.json new file mode 100644 index 00000000..810ddce6 --- /dev/null +++ b/test/config/test.prover.config.json @@ -0,0 +1,93 @@ +{ + "runExecutorServer": false, + "runExecutorClient": false, + "runExecutorClientMultithread": false, + + "runHashDBServer": false, + "runHashDBTest": false, + + "runAggregatorServer": false, + "runAggregatorClient": true, + "runAggregatorClientMock": false, + "aggregatorClientMockTimeout": 1, + "proverName": "stateless-prover-test", + + "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": true, + "saveProofToFile": true, + "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": "zkevm-aggregator", + "aggregatorClientWatchdogTimeout": 120000000, + + "mapConstPolsFile": false, + "mapConstantsTreeFile": false, + + "inputFile": "input_executor_0.json", + "inputFile2": "input_executor_1.json", + + "keccakScriptFile": "config/scripts/keccak_script.json", + "storageRomFile": "config/scripts/storage_sm_rom.json", + + "outputPath": "output", + "configPath": "config", + + "databaseURL": "local", + "dbNodesTableName": "state.nodes", + "dbProgramTableName": "state.program", + "dbMultiWrite": true, + "dbFlushInParallel": false, + "dbMTCacheSize": 1024, + "dbProgramCacheSize": 512, + "dbNumberOfPoolConnections": 30, + "dbGetTree": true, + "cleanerPollingPeriod": 600, + "requestsPersistence": 3600, + "maxExecutorThreads": 256, + "maxProverThreads": 8, + "maxHashDBThreads": 256, + "ECRecoverPrecalc": false, + "ECRecoverPrecalcNThreads": 32, + "stateManager": true, + "useAssociativeCache" : false, + "jsonLogs": false +} \ No newline at end of file diff --git a/test/docker-compose.yml b/test/docker-compose.yml new file mode 100644 index 00000000..a280d675 --- /dev/null +++ b/test/docker-compose.yml @@ -0,0 +1,91 @@ +networks: + default: + name: cdk + +services: + cdk-sequence-sender: + container_name: cdk-sequence-sender + restart: no + image: cdk + build: . + volumes: + - ./config/test.config.toml:/app/config.toml + - ./config/test.genesis.json:/app/genesis.json + - ./sequencer.keystore:/app/keystore/sequencer.keystore + command: + - "/bin/sh" + - "-c" + - "/app/cdk run --cfg /app/config.toml --network custom --custom-network-file /app/genesis.json --components sequence-sender" + + zkevm-prover: + container_name: zkevm-prover + restart: unless-stopped + image: hermeznetwork/zkevm-prover:v6.0.3-RC16 + volumes: + - ./config/test.prover.config.json:/usr/src/app/config.json + - ~/stateless-aggregator/prover/config:/app/config + command: > + zkProver -c /usr/src/app/config.json + + cdk-aggregator: + container_name: cdk-aggregator + image: cdk + ports: + - 50081:50081 + - 9093:9091 # needed if metrics enabled + environment: + - CDK_AGGREGATOR_DB_HOST=cdk-aggregator-db + - CDK_AGGREGATOR_SENDER_ADDRESS=0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266 + volumes: + - ./config/test.config.toml:/app/config.toml + - ./config/test.genesis.json:/app/genesis.json + - ./aggregator.keystore:/pk/aggregator.keystore + command: + - "/bin/sh" + - "-c" + - "/app/cdk run --cfg /app/config.toml --network custom --custom-network-file /app/genesis.json --components aggregator" + depends_on: + cdk-aggregator-db: + condition: service_started + cdk-l1-sync-db: + condition: service_started + + cdk-aggregator-db: + container_name: cdk-aggregator-db + image: postgres:15 + deploy: + resources: + limits: + memory: 2G + reservations: + memory: 1G + ports: + - 5434:5432 + environment: + - POSTGRES_USER=aggregator_user + - POSTGRES_PASSWORD=aggregator_password + - POSTGRES_DB=aggregator_db + command: + - "postgres" + - "-N" + - "500" + + cdk-l1-sync-db: + container_name: cdk-l1-sync-db + image: postgres:15 + deploy: + resources: + limits: + memory: 2G + reservations: + memory: 1G + ports: + - 5436:5432 + environment: + - POSTGRES_USER=test_user + - POSTGRES_PASSWORD=test_password + - POSTGRES_DB=sync + command: + - "postgres" + - "-N" + - "500" diff --git a/test/sequencer.keystore b/test/sequencer.keystore new file mode 100644 index 00000000..96b662b7 --- /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 00000000..2dbd8a0c --- /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 00000000..73db3b01 --- /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")