diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 094014e..c0c41cc 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -35,11 +35,10 @@ jobs: username: ${{ secrets.DOCKERHUB_USERNAME }} password: ${{ secrets.DOCKERHUB_TOKEN }} - - name: Run GoReleaser build - uses: goreleaser/goreleaser-action@v5 - with: - version: latest - args: build --clean --parallelism 3 --config build/.goreleaser-operatorcli.yml + - name: Build Operator CLI + run: | + make build-oprcli-arm64 + make build-oprcli-amd64 - name: Check if the release already exists id: check_release @@ -56,8 +55,14 @@ jobs: env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + - name: Build and push Docker images + run: | + make docker-build-arm64 + make docker-build-amd64 + make docker-push-no-latest + - name: Run GoReleaser Release - uses: goreleaser/goreleaser-action@v5 + uses: goreleaser/goreleaser-action@v6 with: version: latest args: release --clean --parallelism 3 --config build/.goreleaser-operatorcli.yml diff --git a/.gitignore b/.gitignore index ca05cc6..27080e0 100644 --- a/.gitignore +++ b/.gitignore @@ -29,3 +29,4 @@ go.work # configuration .docker .env +.idea diff --git a/.keystore-2/ecdsaAliasedEncryptedWallet.json b/.keystore-2/ecdsaAliasedEncryptedWallet.json new file mode 100644 index 0000000..f9a2930 --- /dev/null +++ b/.keystore-2/ecdsaAliasedEncryptedWallet.json @@ -0,0 +1 @@ +{"address":"69e325164976aae2e1af5557daf8036e98c04b9b","crypto":{"cipher":"aes-128-ctr","ciphertext":"e74de7442624ed2dd1522a60778c319e11d8c0aed72bfb8671b2db5a0bd12523","cipherparams":{"iv":"6e80dcf616c6b402e60cab7c00cc29b5"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":262144,"p":1,"r":8,"salt":"c65c7ba5c490d57b743f1a162e69a96f4c950563501618f0615e64ffc3e09d96"},"mac":"1797d26f819dec271d7bba1e13eaba97b10cea568d794e3858f0572ef5f99794"},"id":"ef281017-0517-4148-a5b0-7910d3edb722","version":3} diff --git a/.keystore-2/ecdsaEncryptedWallet.json b/.keystore-2/ecdsaEncryptedWallet.json new file mode 100644 index 0000000..dfe4267 --- /dev/null +++ b/.keystore-2/ecdsaEncryptedWallet.json @@ -0,0 +1 @@ +{"address":"a509bed120d3848df7455805db2564390bd5852c","crypto":{"cipher":"aes-128-ctr","ciphertext":"cf36c8cc9cbfecbb5b25c909664d8445df45c06e2df84d006349d1cc3d7259f1","cipherparams":{"iv":"98553092a256e5e3659ead968f4dbea3"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":262144,"p":1,"r":8,"salt":"a3e171292fd2364179c90d773278aba3f94cdba401005fed88da8a7b5e193fda"},"mac":"e61eaa04514b6960f31e1ddedeb11b0ac5b77288658743a17213fdd44956ed28"},"id":"495590e9-c211-46c7-9a9d-4a1dbef65a70","version":3} diff --git a/.keystore-3/blsEncryptedWallet.json b/.keystore-3/blsEncryptedWallet.json new file mode 100644 index 0000000..2e8c647 --- /dev/null +++ b/.keystore-3/blsEncryptedWallet.json @@ -0,0 +1 @@ +{"pubKey":"E([9172273515249731734406946876205214137883948624482428570959828029069873968033,14771426330773047970684652087013045110853390794807017138079961400417684864238])","crypto":{"cipher":"aes-128-ctr","ciphertext":"3597cdcfc808027324ec3b1420bfc618ab98b95b8950c3fe27cdd0fd67f5e4ce","cipherparams":{"iv":"46531756933c6573507e48d6d0a76992"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":262144,"p":1,"r":8,"salt":"27b6b3ab8f2c8f76a8e9de17e20e0a642ca6fec0896d3cf44f983a3b3381452d"},"mac":"95aef1162ce43a34f7e1b5dc085f6fdfe55112f534a468982e3fa6629319d89a"}} \ No newline at end of file diff --git a/.keystore-3/ecdsaAliasedEncryptedWallet.json b/.keystore-3/ecdsaAliasedEncryptedWallet.json new file mode 100644 index 0000000..a4b0a40 --- /dev/null +++ b/.keystore-3/ecdsaAliasedEncryptedWallet.json @@ -0,0 +1 @@ +{"address":"a52879833c1b851278e438acf18c1f042885bc53","crypto":{"cipher":"aes-128-ctr","ciphertext":"f8c3c384c56f2eb25be9e53cd2489ed76d2b0c341e2d96fdfa1abee7a2081755","cipherparams":{"iv":"8c7059bfbd2d7396796cfc2dbc2a65c6"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":262144,"p":1,"r":8,"salt":"77913dfa18659c7adf788e408f6b4ccb81c17b07a6979fed8a4b7014eb6388ef"},"mac":"51210190cd29edd72bdd2c51b76357b3eddbe70871250f1aa8cf8829d2a60a33"},"id":"d8658ee2-2f35-4c83-b5ad-b1b957efd7c1","version":3} \ No newline at end of file diff --git a/.keystore-3/ecdsaEncryptedWallet.json b/.keystore-3/ecdsaEncryptedWallet.json new file mode 100644 index 0000000..18da2bb --- /dev/null +++ b/.keystore-3/ecdsaEncryptedWallet.json @@ -0,0 +1 @@ +{"address":"e6ac50e8af2e86de74a2a9cf69c0091b620616a5","crypto":{"cipher":"aes-128-ctr","ciphertext":"4f458a3da7866c2a0cf339624d8627f1bebd6eb4a5f0e7606da322cefe102c05","cipherparams":{"iv":"b8af1d853bd7415da7b79a3382220fdc"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":262144,"p":1,"r":8,"salt":"05822845dae1c7e04e5d220e5681cbcc6565bc4f349fb06d851de8063173dd93"},"mac":"d0bc0adb367664d1d3a101207191198252c021183815173926364c200e3d0c50"},"id":"01433ed2-aec7-456e-aea6-65f727e4dadd","version":3} \ No newline at end of file diff --git a/.keystore-DV1-testnet/blsEncryptedWallet.json b/.keystore-DV1-testnet/blsEncryptedWallet.json new file mode 100644 index 0000000..717bf78 --- /dev/null +++ b/.keystore-DV1-testnet/blsEncryptedWallet.json @@ -0,0 +1 @@ +{"pubKey":"E([3708064820094048068358485847007916640873197021490267223605280954248682641629,18815806154197677394059406048253724850582811709039300688930704677888209538636])","crypto":{"cipher":"aes-128-ctr","ciphertext":"6cfd77dc0eca7f82a5102e775d11a2338f462b54a41e64f4d6e31d523a877eaf","cipherparams":{"iv":"c058672cb87afa3c547c70c690e8912e"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":262144,"p":1,"r":8,"salt":"45412d6f5d2aaa1dadfbf8d453c23ef49d43fe6f5bb1f42573343c5d816c5ae8"},"mac":"9dbf2d10c110e8c25479a6e72fe029cadcf5d0b5520b2f6eaf70a6a7b8154162"}} diff --git a/.keystore-DV1-testnet/ecdsaAliasedEncryptedWallet.json b/.keystore-DV1-testnet/ecdsaAliasedEncryptedWallet.json new file mode 100644 index 0000000..3b334c4 --- /dev/null +++ b/.keystore-DV1-testnet/ecdsaAliasedEncryptedWallet.json @@ -0,0 +1 @@ +{"address":"083870825c8459cebb175fccbbd82fbfd35f921a","crypto":{"cipher":"aes-128-ctr","ciphertext":"16dbc96fe112070315a653bcc5bc7a23c8fcc8eb06ec717f63c5731d6ce14a16","cipherparams":{"iv":"2500795695237e741e18583f585f23c6"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":262144,"p":1,"r":8,"salt":"89148a6e1857c45b18d677c515489d0df0c985bab3da3b7e25dea2068938259d"},"mac":"20793883a19d978fdb02e4d1c08095051ac15640926c341b4af252c8bc117303"},"id":"e33f0553-183d-4694-b357-a7fe5d5e21eb","version":3} diff --git a/.keystore-DV1-testnet/ecdsaEncryptedWallet.json b/.keystore-DV1-testnet/ecdsaEncryptedWallet.json new file mode 100644 index 0000000..29c2ab6 --- /dev/null +++ b/.keystore-DV1-testnet/ecdsaEncryptedWallet.json @@ -0,0 +1 @@ +{"address":"5ead9e655bd917b6129d8e5ea136493cd328f7da","crypto":{"cipher":"aes-128-ctr","ciphertext":"a9abcdc4dbeb3ed895c5703f3d1185c764b15a2984e7bf616e96b5d7c4e64a28","cipherparams":{"iv":"09589da5f970481d1aa83a84643cc40a"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":262144,"p":1,"r":8,"salt":"264fbf07e700b9e453aeebee907398e0c83495eeb3347ccb52709670b6f386d9"},"mac":"4e5aa267b6423231c88d9304e313518537f0157ff8d9e08643f1ab5f47b7e827"},"id":"fbc9934d-4d52-469e-ad54-c2f2cb36211a","version":3} diff --git a/Dockerfile-oprcli b/Dockerfile-oprcli deleted file mode 100644 index 47b2036..0000000 --- a/Dockerfile-oprcli +++ /dev/null @@ -1,69 +0,0 @@ -ARG GO_VERSION=alpine -ARG BASE=golang:1.21.7-alpine3.19 - -FROM ${BASE} as builder - -RUN apk update \ - && apk add --no-cache \ - linux-headers \ - gcc \ - libtool \ - openssl-dev \ - libffi \ - tini \ - git \ - 'su-exec>=0.2' \ - && apk add --no-cache --virtual .build_deps build-base libffi-dev - -# add our user and group first to make sure their IDs get assigned consistently, regardless of whatever dependencies get added -RUN addgroup -g 502 -S eodata \ - && adduser -u 502 -S -G eodata eodata \ - && mkdir -p /app/eodata/logs \ - && chown -R eodata:eodata /app/eodata - -# Move to working directory -WORKDIR /app/eodata - -# Download dependency using go mod -COPY go.mod . -COPY go.sum . -RUN go mod download -COPY --chown=eodata:eodata . . - -RUN platform=arm64 && \ - if [ $(uname -m) = x86_64 ]; then platform=amd64; fi && \ - make build-oprcli-${platform} && \ - mv ./bin/oprcli-${platform} ./bin/oprcli -RUN chown eodata:eodata ./bin/oprcli - -FROM golang:${GO_VERSION} - -RUN apk update \ - && apk add --no-cache \ - linux-headers \ - gcc \ - libtool \ - openssl-dev \ - libffi \ - tini \ - git \ - 'su-exec>=0.2' \ - && apk add --no-cache --virtual .build_deps build-base libffi-dev - -# add our user and group first to make sure their IDs get assigned consistently, regardless of whatever dependencies get added -RUN addgroup -g 502 -S eodata \ - && adduser -u 502 -S -G eodata eodata \ - && mkdir -p /app/eodata/logs \ - && mkdir -p /app/eodata/datadir \ - && chown -R eodata:eodata /app/eodata - -# Move to working directory -WORKDIR /app/eodata - -COPY --from=builder /app/eodata/bin/oprcli /app/eodata/bin/oprcli - -COPY docker-entrypoint-oprcli.sh /usr/local/bin/ - -ENV PATH="/app/eodata/bin:${PATH}" - -ENTRYPOINT ["/sbin/tini", "--", "/bin/sh", "/usr/local/bin/docker-entrypoint-oprcli.sh"] \ No newline at end of file diff --git a/Makefile b/Makefile index 379d8ef..7c07300 100644 --- a/Makefile +++ b/Makefile @@ -1,76 +1,140 @@ -COMMIT_HASH=$(shell git rev-parse HEAD) -VERSION ?= $(shell git describe --tags --always --dirty --match=v* 2> /dev/null || \ - grep -o '".*"' | sed 's/"//g' 2> /dev/null || echo v0.0.5) -BRANCH=$(shell git rev-parse --abbrev-ref HEAD | tr -d '\040\011\012\015\n') -TIME=$(shell date) +# Default commands and configurations +GO ?= go +V ?= 0 +Q = $(if $(filter 1,$V),,@) +M = $(shell printf "\033[34;1m▶\033[0m") -# Set the source directory -SRC_DIR=cmd/operatorcli +# Directories and files +MAKEFILE_PATH := $(abspath $(lastword $(MAKEFILE_LIST))) +BASE_DIR := $(patsubst %/,%,$(dir $(MAKEFILE_PATH))) +SRC_DIR = $(BASE_DIR) +VERSION = $(shell git describe --tags --always --dirty --match=v* 2> /dev/null || \ +- grep -o '".*"' | sed 's/"//g' 2> /dev/null || echo v0.0.5) -# Set the Docker image names -DOCKER_IMAGE_OPR_CLI_AMD64=eodata/opr_cli:v$(VERSION)-amd64 -DOCKER_IMAGE_OPR_CLI_ARM64=eodata/opr_cli:v$(VERSION)-arm64 +# Docker image +DOCKER_IMAGE = eoracle/opr-cli +# Linter version +GOLANGCI_LINT_VERSION = v1.62.0 -.PHONY: check-git -check-git: - @which git > /dev/null || (echo "git is not installed. Please install and try again."; exit 1) +.PHONY: help +help: ## Display this help message + @grep -hE '^[ a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | \ + awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-20s\033[0m %s\n", $$1, $$2}' + +# --- Dependency Checks --- +.PHONY: check-deps +check-deps: check-go check-git check-fmt ## Verify all required dependencies are installed .PHONY: check-go -check-go: - @which go > /dev/null || (echo "Go is not installed.. Please install and try again."; exit 1) +check-go: ## Ensure Go is installed + @which $(GO) > /dev/null || (echo "Go is not installed. Please install it and try again."; exit 1) + +.PHONY: check-git +check-git: ## Ensure Git is installed + @which git > /dev/null || (echo "Git is not installed. Please install it and try again."; exit 1) + +.PHONY: check-fmt +check-fmt: ## Ensure formatting tools are installed + @which gofmt > /dev/null || (echo "gofmt is not installed. Please install it and try again."; exit 1) + @which goimports > /dev/null || (echo "goimports is not installed. Please install it and try again."; exit 1) + +# --- Linting --- +.PHONY: lint +lint: fmt ## Run golangci-lint on all source files + $(info $(M) Running golangci-lint...) + @if ! command -v golangci-lint >/dev/null 2>&1; then \ + echo "golangci-lint not found, installing..."; \ + curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s -- -b $$(go env GOPATH)/bin $(GOLANGCI_LINT_VERSION); \ + fi + $Q golangci-lint run + +# --- Formatting --- +.PHONY: fmt +fmt: check-fmt ## Format source files using gofmt and goimports + $(info $(M) Running gofmt and goimports...) + @sh $(BASE_DIR)/build/goimports.sh + +# --- Testing --- +TIMEOUT ?= 15 +ARGS ?= # Optional test arguments +PKGS = $(or $(PKG),$(shell cd $(BASE_DIR) && env GO111MODULE=on $(GO) list ./...)) +TESTPKGS = $(shell cd $(BASE_DIR) && env GO111MODULE=on $(GO) list -f \ + '{{ if or .TestGoFiles .XTestGoFiles }}{{ .ImportPath }}{{ end }}' \ + $(PKGS)) + +TEST_TARGETS := test-verbose test-race +.PHONY: $(TEST_TARGETS) + +# General test rule +.PHONY: test +test: lint ## Run all tests + $(info $(M) Running $(NAME:%=% )tests...) + $Q $(GO) test -timeout $(TIMEOUT)s $(ARGS) $(TESTPKGS) + +# Test variants +test-verbose: ARGS=-v ## Run tests in verbose mode with coverage reporting +test-race: ARGS=-race ## Run tests with race detector + +$(TEST_TARGETS): NAME=$(MAKECMDGOALS:test-%=%) +$(TEST_TARGETS): test + +# --- Dependency Management --- +.PHONY: tidy +tidy: ; $(info $(M) Running go get -u ./... and go mod tidy) @ ## Run go get -u ./... and go mod tidy, then sync workspace. + @($(GO) get -u ./... && $(GO) mod tidy) || exit 1 + +# --- Build --- +.PHONY: version +version: ## Print the application version + @echo $(VERSION) + +.PHONY: build +build: build-oprcli ## Build the oprcli binary .PHONY: build-oprcli -build-oprcli: check-go check-git - go build -o bin/oprcli -ldflags="\ - -X 'github.com/Eoracle/core-go/versioning.Version=$(VERSION)' \ - -X 'github.com/Eoracle/core-go/versioning.Commit=$(COMMIT_HASH)'\ - -X 'github.com/Eoracle/core-go/versioning.Branch=$(BRANCH)'\ - -X 'github.com/Eoracle/core-go/versioning.BuildTime=$(TIME)'" \ - cmd/operatorcli/main.go - -.PHONY: build-oprcli-arm64 -build-oprcli-arm64: check-go check-git - GOOS=linux GOARCH=arm64 GOHOSTARCH="arm64" go build -o bin/oprcli-arm64 -ldflags="\ - -X 'github.com/Eoracle/core-go/versioning.Version=$(VERSION)' \ - -X 'github.com/Eoracle/core-go/versioning.Commit=$(COMMIT_HASH)'\ - -X 'github.com/Eoracle/core-go/versioning.Branch=$(BRANCH)'\ - -X 'github.com/Eoracle/core-go/versioning.BuildTime=$(TIME)'" \ - cmd/operatorcli/main.go - -.PHONY: build-oprcli-amd64 -build-oprcli-amd64: check-go check-git - GOOS=linux GOARCH=amd64 GOHOSTARCH="amd64" go build -o bin/oprcli-amd64 -ldflags="\ - -X 'github.com/Eoracle/core-go/versioning.Version=$(VERSION)' \ - -X 'github.com/Eoracle/core-go/versioning.Commit=$(COMMIT_HASH)'\ - -X 'github.com/Eoracle/core-go/versioning.Branch=$(BRANCH)'\ - -X 'github.com/Eoracle/core-go/versioning.BuildTime=$(TIME)'" \ - cmd/operatorcli/main.go - -# Build Docker images for AMD64 and ARM64 -.PHONY: docker-build-oprcli -docker-build-oprcli: docker-build-oprcli-amd64 docker-build-oprcli-arm64 - -.PHONY: docker-build-oprcli-amd64 -docker-build-oprcli-amd64: - docker build -t $(DOCKER_IMAGE_OPR_CLI_AMD64) --platform linux/amd64 . -f Dockerfile-oprcli - -.PHONY: docker-build-oprcli-arm64 -docker-build-oprcli-arm64: - docker build -t $(DOCKER_IMAGE_OPR_CLI_ARM64) --platform linux/arm64 . -f Dockerfile-oprcli +build-oprcli: check-go ## Build oprcli binary + $(info $(M) Building oprcli binary...) + $Q $(GO) build -o $(BASE_DIR)/bin/oprcli $(SRC_DIR)/main.go + +.PHONY: build-oprcli-% +build-oprcli-%: check-go ## Build oprcli binary for a specific platform + $(info $(M) Building oprcli binary for $*...) + $Q GOOS=linux GOARCH=$* $(GO) build -o $(BASE_DIR)/bin/oprcli-$* $(SRC_DIR)/main.go + +# --- Docker --- +.PHONY: docker-build +docker-build: docker-build-amd64 docker-build-arm64 ## Build Docker images for all platforms + +.PHONY: docker-build-% +docker-build-%: ## Build Docker image for a specific platform + $(info $(M) Building Docker image for $*...) + $Q DOCKER_BUILDKIT=1 docker build \ + --build-arg="BUILDPLATFORM=linux/$*" \ + -t $(DOCKER_IMAGE):$(VERSION)-$* --platform linux/$* . -f $(BASE_DIR)/build/Dockerfile # Push Docker images -.PHONY: docker-push-oprcli-no-latest -docker-push-oprcli-no-latest: - docker push $(DOCKER_IMAGE_OPR_CLI_AMD64) - docker push $(DOCKER_IMAGE_OPR_CLI_ARM64) - -.PHONY: docker-push-oprcli-latest -docker-push-oprcli-latest: - docker tag $(DOCKER_IMAGE_OPR_CLI_AMD64) eodata/opr_cli:latest - docker push eodata/opr_cli:latest +.PHONY: docker-push +docker-push: + docker push $(DOCKER_IMAGE):$(VERSION)-amd64 + docker push $(DOCKER_IMAGE):$(VERSION)-arm64 + docker manifest create $(DOCKER_IMAGE):$(VERSION) --amend $(DOCKER_IMAGE):$(VERSION)-amd64 --amend $(DOCKER_IMAGE):$(VERSION)-arm64 + docker manifest push $(DOCKER_IMAGE):$(VERSION) + +.PHONY: docker-push-latest +docker-push-latest: + docker tag $(DOCKER_IMAGE):$(VERSION)-amd64 $(DOCKER_IMAGE):latest-amd64 + docker tag $(DOCKER_IMAGE):$(VERSION)-arm64 $(DOCKER_IMAGE):latest-arm64 + docker push $(DOCKER_IMAGE):latest-amd64 + docker push $(DOCKER_IMAGE):latest-arm64 + docker manifest create $(DOCKER_IMAGE):latest --amend $(DOCKER_IMAGE):latest-amd64 --amend $(DOCKER_IMAGE):latest-arm64 + docker manifest push $(DOCKER_IMAGE):latest # Clean target, removes the binaries .PHONY: clean clean: rm -rf $(BINARY_DIR) + +generate-bindings: + @echo "Generating bindings" + @go generate ./... diff --git a/build/.goreleaser-operatorcli.yml b/build/.goreleaser-operatorcli.yml index fb097aa..a867ebf 100644 --- a/build/.goreleaser-operatorcli.yml +++ b/build/.goreleaser-operatorcli.yml @@ -8,7 +8,7 @@ builds: # Path to the main.go file or the directory containing the main package. # You can specify multiple paths if your project consists of multiple binaries. - main: ./cmd/operatorcli/main.go + main: ./main.go # Target platforms goos: @@ -18,23 +18,6 @@ builds: - amd64 - arm64 - # Custom build flags can be added here - # flags: - # - -tags=netgo - - # Environment variables to set during the build, such as Go modules on proxy settings - # env: - # - GO111MODULE=on - # - GOPROXY=https://proxy.golang.org - - # Indicates if the binary should be archived (default is true). - # If set to false, the binary will be placed in the dist folder without being zipped/tarred. - # archive: - # format: zip - - # Custom binary name template - # binary: "{{ .ProjectName }}_{{ .Version }}_{{ .Os }}_{{ .Arch }}" - checksum: # Specifies the name of the checksum file. You can include template directives. name_template: "{{ .ProjectName }}_{{ .Version }}_checksums.txt" @@ -49,15 +32,15 @@ dockers: - "eodata/opr_cli:{{ .Tag }}-amd64" # Path to the Dockerfile (relative to the project root) - dockerfile: "Dockerfile-oprcli" + dockerfile: "build/Dockerfile" extra_files: + - "build" - "cmd" - "contracts" - - "internal" - - "Makefile" - "go.mod" - "go.sum" - - "docker-entrypoint-oprcli.sh" + - "Makefile" + - "main.go" goos: linux goarch: amd64 build_flag_templates: @@ -73,13 +56,13 @@ dockers: # Path to the Dockerfile (relative to the project root) dockerfile: "Dockerfile-oprcli" extra_files: + - "build" - "cmd" - "contracts" - - "internal" - - "Makefile" - "go.mod" - "go.sum" - - "docker-entrypoint-oprcli.sh" + - "Makefile" + - "main.go" goos: linux goarch: arm64 build_flag_templates: @@ -87,6 +70,7 @@ dockers: - "linux/arm64" - "--build-arg" - "ARCH=arm64" + docker_manifests: - name_template: "eodata/opr_cli:{{ .Tag }}" diff --git a/build/Dockerfile b/build/Dockerfile new file mode 100644 index 0000000..254e909 --- /dev/null +++ b/build/Dockerfile @@ -0,0 +1,78 @@ +# Specify arguments for flexibility +ARG GO_VERSION=1.23-alpine +ARG BASE=golang:${GO_VERSION} +ARG BUILDPLATFORM=linux + +# Stage 1: Builder +FROM --platform=${BUILDPLATFORM} ${BASE} AS builder + +# Install dependencies +RUN apk update && apk add --no-cache \ + linux-headers \ + gcc \ + libtool \ + openssl-dev \ + libffi \ + tini \ + git \ + 'su-exec>=0.2' \ + build-base \ + libffi-dev \ + openssh-client + +# Add user and group +RUN addgroup -g 502 -S eoracle \ + && adduser -u 502 -S -G eoracle eoracle \ + && mkdir -p /app/eoracle/logs \ + && chown -R eoracle:eoracle /app/eoracle + +# Set the working directory +WORKDIR /app/eoracle + +# Copy and download dependencies +COPY go.mod go.sum ./ +RUN go mod download + +# Copy application code +COPY --chown=eoracle:eoracle . . + +# Build the binary +RUN platform=$(uname -m) && \ + [ "$platform" = "x86_64" ] && platform=amd64 || platform=arm64 && \ + make build-oprcli-${platform} && \ + mv ./bin/oprcli-${platform} ./bin/oprcli && \ + chown eoracle:eoracle ./bin/oprcli + +FROM --platform=$BUILDPLATFORM ${BASE} + +# Install runtime dependencies +RUN apk update \ + && apk add --no-cache \ + linux-headers \ + gcc \ + libtool \ + openssl-dev \ + libffi \ + tini \ + git \ + 'su-exec>=0.2' \ + && apk add --no-cache --virtual .build_deps build-base libffi-dev + + +# Add user and group +RUN addgroup -g 502 -S eoracle \ + && adduser -u 502 -S -G eoracle eoracle \ + && mkdir -p /app/eoracle/ \ + && chown -R eoracle:eoracle /app/eoracle + +# Set the working directory +WORKDIR /app/eoracle + +# Copy binary and entrypoint script +COPY --from=builder /app/eoracle/bin/oprcli /usr/local/bin/oprcli + +COPY build/docker-entrypoint.sh /usr/local/bin/ + +ENV PATH="/app/eoracle/bin:${PATH}" + +ENTRYPOINT ["/sbin/tini", "--", "/bin/sh", "/usr/local/bin/docker-entrypoint.sh"] diff --git a/docker-entrypoint-oprcli.sh b/build/docker-entrypoint.sh similarity index 100% rename from docker-entrypoint-oprcli.sh rename to build/docker-entrypoint.sh diff --git a/build/goimports.sh b/build/goimports.sh new file mode 100755 index 0000000..0e768f8 --- /dev/null +++ b/build/goimports.sh @@ -0,0 +1,17 @@ +#!/bin/sh + +find_files() { + find . ! \( \ + \( \ + -path '.github' \ + \) -prune \ + \) -name '*.go' \ + -not -name '*_gen.go' +} + +GOFMT="gofmt -s -w" +GOIMPORTS="goimports -w" + +find_files | xargs sed -i '' '/^import (/,/^)/{/^$/d;}' +find_files | xargs $GOFMT +find_files | xargs $GOIMPORTS diff --git a/cmd/config.go b/cmd/config.go new file mode 100644 index 0000000..69cb33d --- /dev/null +++ b/cmd/config.go @@ -0,0 +1,21 @@ +package cmd + +import ( + "github.com/Layr-Labs/eigensdk-go/logging" + gethcommon "github.com/ethereum/go-ethereum/common" +) + +var ( + profile *NetworkProfile + logger, _ = logging.NewZapLogger(logging.Production) +) + +type NetworkProfile struct { + NetworkName string + + EOConfigAddress gethcommon.Address + RegistryCoordinatorAddress gethcommon.Address + + EOChainRPCEndpoint string + EthRPCEndpoint string +} diff --git a/cmd/declare_alias.go b/cmd/declare_alias.go new file mode 100644 index 0000000..9f6105c --- /dev/null +++ b/cmd/declare_alias.go @@ -0,0 +1,114 @@ +package cmd + +import ( + "context" + "crypto/ecdsa" + + "github.com/Layr-Labs/eigensdk-go/chainio/clients/wallet" + "github.com/Layr-Labs/eigensdk-go/chainio/txmgr" + "github.com/Layr-Labs/eigensdk-go/signerv2" + eoconfig "github.com/eodata/operator-cli/contracts/bindings/EOConfig" + "github.com/ethereum/go-ethereum/cmd/utils" + "github.com/ethereum/go-ethereum/crypto" + "github.com/urfave/cli/v2" +) + +func NewDeclareAliasCommand() *cli.Command { + return &cli.Command{ + Name: "declare-alias", + Description: "Declare the alias in the eochain", + Before: setProfile, + Action: runDeclareAlias, + Flags: []cli.Flag{ + ProfileFlag, + PassphraseFlag, + KeyStorePathFlag, + EOChainRPCFlag, + EOConfigAddressFlag, + }, + } +} + +func runDeclareAlias(c *cli.Context) error { + if !c.IsSet(PassphraseFlag.Name) || !c.IsSet(KeyStorePathFlag.Name) { + utils.Fatalf("passphrase and keystore-path are required") + } + + ethEcdsaPair, aliasEcdsaPair, err := getOperatorAndAliasKeys(c) + if err != nil { + return err + } + + signerAddress := crypto.PubkeyToAddress(ethEcdsaPair.PublicKey) + logger.Infof("Declaring alias with signer: %s", signerAddress.String()) + + txMgr, contractEOConfig, err := getTxMgrForEOChain(ethEcdsaPair) + if err != nil { + return err + } + + noSendTxOpts, err := txMgr.GetNoSendTxOpts() + if err != nil { + utils.Fatalf("Error creating transaction object %v", err) + } + + tx, err := contractEOConfig.DeclareAlias( + noSendTxOpts, + crypto.PubkeyToAddress(aliasEcdsaPair.PublicKey), + ) + if err != nil { + utils.Fatalf("Failed to create EOConfig.declareAlias transaction %v", err) + } + + ctx := context.Background() + receipt, err := txMgr.Send(ctx, tx, true) + if err != nil { + utils.Fatalf("declareAlias transaction failed %s", err) + } + + if receipt.Status != 1 { + utils.Fatalf( + "declareAlias transaction %v for operator %v on eochain mainnet/testnet (%v) reverted", + receipt.TxHash.Hex(), + crypto.PubkeyToAddress(ethEcdsaPair.PublicKey), + profile.EOChainRPCEndpoint, + ) + } + + logger.Info( + "successfully declared an alias in the eochain", + "Ethereum address", crypto.PubkeyToAddress(ethEcdsaPair.PublicKey), + "eochain address", crypto.PubkeyToAddress(aliasEcdsaPair.PublicKey), + "tx hash", receipt.TxHash.Hex(), + ) + return nil +} + +func getTxMgrForEOChain(ethEcdsaPair *ecdsa.PrivateKey) (*txmgr.SimpleTxManager, *eoconfig.EOConfig, error) { + ethClient, err := createEthClient(profile.EOChainRPCEndpoint) + if err != nil { + return nil, nil, err + } + + chainIDBigInt, err := ethClient.ChainID(context.Background()) + if err != nil { + utils.Fatalf("cannot get chainId (%v): %v", profile.EOChainRPCEndpoint, err) + } + + signerV2, signerAddr, err := signerv2.SignerFromConfig(signerv2.Config{PrivateKey: ethEcdsaPair}, chainIDBigInt) + if err != nil { + utils.Fatalf("Error creating the signer function for %v %v", crypto.PubkeyToAddress(ethEcdsaPair.PublicKey), err) + } + txSender, err := wallet.NewPrivateKeyWallet(ethClient, signerV2, signerAddr, logger) + if err != nil { + utils.Fatalf("Failed to create transaction sender for declaring alias of operator %v on eoChain (%v) %v", + crypto.PubkeyToAddress(ethEcdsaPair.PublicKey), profile.EOChainRPCEndpoint, err) + } + + contractEOConfig, err := eoconfig.NewEOConfig(profile.EOConfigAddress, ethClient) + if err != nil { + utils.Fatalf("Failed to bind the eoconfig contract %v", err) + } + + return txmgr.NewSimpleTxManager(txSender, ethClient, logger, signerAddr), contractEOConfig, nil +} diff --git a/cmd/decrypt.go b/cmd/decrypt.go new file mode 100644 index 0000000..4af0402 --- /dev/null +++ b/cmd/decrypt.go @@ -0,0 +1,53 @@ +package cmd + +import ( + "encoding/hex" + "errors" + "fmt" + "os" + "path/filepath" + + eigensdkecdsa "github.com/Layr-Labs/eigensdk-go/crypto/ecdsa" + "github.com/ethereum/go-ethereum/cmd/utils" + "github.com/ethereum/go-ethereum/crypto" + "github.com/urfave/cli/v2" +) + +func NewDecryptCommand() *cli.Command { + return &cli.Command{ + Name: "decrypt", + Description: "Decrypt the ecdsa and bls private keys", + Action: runDecrypt, + Flags: []cli.Flag{ + PassphraseFlag, + KeyStorePathFlag, + }, + } +} + +func runDecrypt(c *cli.Context) error { + ecdsaPair, err := getECDSAPrivateKey(c) + if err != nil { + utils.Fatalf("Error reading the ecdsaEncryptedWallet.json file %v", err) + } + fmt.Println("ecdsa address ", crypto.PubkeyToAddress(ecdsaPair.PublicKey), "private key", hex.EncodeToString(ecdsaPair.D.Bytes())) + + ecdsaEOChainPair, err := eigensdkecdsa.ReadKey(filepath.Join(c.String(KeyStorePathFlag.Name), "ecdsaAliasedEncryptedWallet.json"), c.String(PassphraseFlag.Name)) + if err != nil { + if errors.Is(err, os.ErrNotExist) { + fmt.Println("eochain alias was not set in the system") + return nil + } + utils.Fatalf("Error reading the ecdsaAliasedEncryptedWallet.json file %v", err) + } + fmt.Println("EOChain ecdsa address ", crypto.PubkeyToAddress(ecdsaEOChainPair.PublicKey), "private key", hex.EncodeToString(ecdsaEOChainPair.D.Bytes())) + + blsKeyPair, err := getBLSPrivateKey(c) + if err != nil { + utils.Fatalf("Error reading the blsEncryptedWallet.json file %v", err) + } + + fmt.Println("bls address G1, G2 ", blsKeyPair.GetPubKeyG1().String(), ", ", blsKeyPair.GetPubKeyG2().String(), "private key", blsKeyPair.PrivKey.String()) + + return nil +} diff --git a/cmd/deregister.go b/cmd/deregister.go new file mode 100644 index 0000000..872f930 --- /dev/null +++ b/cmd/deregister.go @@ -0,0 +1,125 @@ +package cmd + +import ( + "context" + + "github.com/Layr-Labs/eigensdk-go/chainio/clients/wallet" + "github.com/Layr-Labs/eigensdk-go/chainio/txmgr" + "github.com/Layr-Labs/eigensdk-go/signerv2" + "github.com/ethereum/go-ethereum/cmd/utils" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/crypto" + "github.com/urfave/cli/v2" +) + +func NewDeregisterCommand() *cli.Command { + return &cli.Command{ + Name: "deregister", + Description: "Deregister the operator", + Before: setProfile, + Action: runDeregister, + Flags: []cli.Flag{ + ProfileFlag, + EthRPCFlag, + RegistryCoordinatorFlag, + PassphraseFlag, + KeyStorePathFlag, + EcdsaPrivateKeyFlag, + QuorumNumberFlag, + }, + } +} + +func runDeregister(c *cli.Context) error { + if !c.IsSet(PassphraseFlag.Name) || !c.IsSet(KeyStorePathFlag.Name) { + utils.Fatalf("passphrase and keystore-path are required") + } + + ecdsaPair, err := getECDSAPrivateKey(c) + if err != nil { + return err + } + + ethClient, err := createEthClient(profile.EthRPCEndpoint) + if err != nil { + return err + } + + chainIDBigInt, err := ethClient.ChainID(context.Background()) + if err != nil { + utils.Fatalf("cannot get chainId (%v): %v", profile.EthRPCEndpoint, err) + } + + avsClient, err := buildAVSClient(ethClient) + if err != nil { + utils.Fatalf("Error creating AVS client %v", err) + } + + signerV2, signerAddr, err := signerv2.SignerFromConfig(signerv2.Config{PrivateKey: ecdsaPair}, chainIDBigInt) + if err != nil { + utils.Fatalf( + "Error creating the deregister transaction signer for operator %v on Ethereum mainnet/Holesky (%v) %v", + crypto.PubkeyToAddress(ecdsaPair.PublicKey), + profile.EthRPCEndpoint, + err, + ) + } + + txSender, err := wallet.NewPrivateKeyWallet(ethClient, signerV2, signerAddr, logger) + if err != nil { + utils.Fatalf( + "Error creating the deregister transaction sender for operator %v on Ethereum mainnet/Holesky (%v) %v", + crypto.PubkeyToAddress(ecdsaPair.PublicKey), + profile.EthRPCEndpoint, + err, + ) + } + + txMgr := txmgr.NewSimpleTxManager(txSender, ethClient, logger, signerAddr) + noSendTxOpts, err := txMgr.GetNoSendTxOpts() + if err != nil { + utils.Fatalf("Error creating transaction object %v", err) + } + + tx, err := avsClient.registryCoordinator.DeregisterOperator( + noSendTxOpts, + crypto.PubkeyToAddress(ecdsaPair.PublicKey), + common.Address{}, + []uint32{0}, + ) + if err != nil { + utils.Fatalf( + "Error creating the deregister transaction for operator %v on Ethereum mainnet/Holesky (%v) %v", + crypto.PubkeyToAddress(ecdsaPair.PublicKey), + profile.EthRPCEndpoint, + err, + ) + } + + ctx := context.Background() + receipt, err := txMgr.Send(ctx, tx, true) + if err != nil { + utils.Fatalf( + "deregister transaction for operator %v on Ethereum mainnet/Holesky (%v) failed %v", + crypto.PubkeyToAddress(ecdsaPair.PublicKey), + profile.EthRPCEndpoint, + err, + ) + } + if receipt.Status != 1 { + utils.Fatalf( + "deregister transaction %v for operator %v on Ethereum mainnet/Holesky (%v) reverted", + receipt.TxHash.Hex(), + crypto.PubkeyToAddress(ecdsaPair.PublicKey), + profile.EthRPCEndpoint, + ) + } + + logger.Info( + "successfully deregistered from eoracle AVS", + "address", signerAddr, + "tx hash", receipt.TxHash.Hex(), + ) + + return nil +} diff --git a/cmd/encrypt.go b/cmd/encrypt.go new file mode 100644 index 0000000..5cf2cb0 --- /dev/null +++ b/cmd/encrypt.go @@ -0,0 +1,53 @@ +package cmd + +import ( + "fmt" + "path/filepath" + + eigensdkecdsa "github.com/Layr-Labs/eigensdk-go/crypto/ecdsa" + "github.com/ethereum/go-ethereum/cmd/utils" + "github.com/ethereum/go-ethereum/crypto" + "github.com/urfave/cli/v2" +) + +func NewEncryptCommand() *cli.Command { + return &cli.Command{ + Name: "encrypt", + Description: "Encrypt the ecdsa and bls private keys", + Action: runEncrypt, + Flags: []cli.Flag{ + EcdsaPrivateKeyFlag, + BlsPrivateKeyFlag, + PassphraseFlag, + KeyStorePathFlag, + }, + } +} + +func runEncrypt(c *cli.Context) error { + // Encrypt the ecdsa private key and save it to a file + ecdsaPair, err := getECDSAPrivateKey(c) + if err != nil { + utils.Fatalf("Invalid ECDSA private key %v", err) + } + + if err = eigensdkecdsa.WriteKey(filepath.Join(c.String(KeyStorePathFlag.Name), "ecdsaEncryptedWallet.json"), ecdsaPair, c.String(PassphraseFlag.Name)); err != nil { + utils.Fatalf("Error writing the ecdsaEncryptedWallet.json file %v", err) + } + + fmt.Println("ecdsa address ", crypto.PubkeyToAddress(ecdsaPair.PublicKey), "saved") + + // Encrypt the bls private key and save it to a file + blsKeyPair, err := getBLSPrivateKey(c) + if err != nil { + utils.Fatalf("Invalid BLS private key %v", err) + } + + if err = blsKeyPair.SaveToFile(filepath.Join(c.String(KeyStorePathFlag.Name), "blsEncryptedWallet.json"), c.String(PassphraseFlag.Name)); err != nil { + utils.Fatalf("Error writing the blsEncryptedWallet.json file %v", err) + } + + fmt.Println("bls address G1, G2 ", blsKeyPair.GetPubKeyG1().String(), ", ", blsKeyPair.GetPubKeyG2().String(), "saved") + + return nil +} diff --git a/cmd/flags.go b/cmd/flags.go new file mode 100644 index 0000000..65e1d45 --- /dev/null +++ b/cmd/flags.go @@ -0,0 +1,89 @@ +package cmd + +import ( + "github.com/urfave/cli/v2" +) + +var ( + KeyStorePathFlag = &cli.StringFlag{ + Name: "keystore-path", + Usage: "location of the keystore folder", + EnvVars: []string{"EO_KEYSTORE_PATH"}, + Value: ".keystore", + } + EthRPCFlag = &cli.StringFlag{ + Name: "eth-rpc-endpoint", + Usage: "ethereum rpc url", + EnvVars: []string{"ETH_RPC_ENDPOINT"}, + } + RegistryCoordinatorFlag = &cli.StringFlag{ + Name: "registry-coordinator", + Usage: "registry coordinator contract address", + EnvVars: []string{"EO_REGISTRY_COORDINATOR"}, + } + EcdsaPrivateKeyFlag = &cli.StringFlag{ + Name: "ecdsa-private-key", + Usage: "ecdsa private key", + EnvVars: []string{"EO_ECDSA_PRIVATE_KEY"}, + } + BlsPrivateKeyFlag = &cli.StringFlag{ + Name: "bls-private-key", + Usage: "bls private key", + EnvVars: []string{"EO_BLS_PRIVATE_KEY"}, + } + SaltFlag = &cli.StringFlag{ + Name: "salt", + Usage: "salt", + EnvVars: []string{"EO_SALT"}, + Value: "0x01", + } + ExpiryFlag = &cli.StringFlag{ + Name: "expiry", + Usage: "expiry", + EnvVars: []string{"EO_EXPIRY"}, + Value: "115792089237316195423570985008687907853269984665640564039457584007913129639935", + } + PassphraseFlag = &cli.StringFlag{ + Name: "passphrase", + Usage: "passphrase to open the encrypted private key", + EnvVars: []string{"EO_PASSPHRASE"}, + } + ValidatorRoleFlag = &cli.StringFlag{ + Name: "validator-role", + Usage: "role of the operator", + EnvVars: []string{"EO_VALIDATOR_ROLE"}, + Value: "DATA_VALIDATOR", + } + ChainValidatorG1PointSignatureFlag = &cli.StringSliceFlag{ + Name: "chain-validator-g1-point-signature", + Usage: "G1Point signature of the chain operator", + EnvVars: []string{"EO_CHAIN_VALIDATOR_G1_POINT_SIGNATURE"}, + } + QuorumNumberFlag = &cli.IntFlag{ + Name: "quorum-number", + Usage: "quorum number", + EnvVars: []string{"EO_QUORUM_NUMBER"}, + Value: 0, + } + EOChainRPCFlag = &cli.StringFlag{ + Name: "eochain-rpc-endpoint", + Usage: "eochain rpc url", + EnvVars: []string{"EO_CHAIN_RPC_ENDPOINT"}, + } + OverrideFlag = &cli.BoolFlag{ + Name: "alias-override", + Usage: "Indication if a new alias key should be created", + EnvVars: []string{"EO_ALIAS_OVERRIDE"}, + } + EOConfigAddressFlag = &cli.StringFlag{ + Name: "eoconfig-address", + Usage: "eoconfig contract address", + EnvVars: []string{"EO_CONFIG_ADDRESS"}, + } + ProfileFlag = &cli.StringFlag{ + Name: "profile", + Usage: "Network to use: mainnet or testnet.", + EnvVars: []string{"EO_PROFILE"}, + Value: TestnetProfileName, + } +) diff --git a/cmd/generate_alias.go b/cmd/generate_alias.go new file mode 100644 index 0000000..664ad7f --- /dev/null +++ b/cmd/generate_alias.go @@ -0,0 +1,78 @@ +package cmd + +import ( + "crypto/ecdsa" + "encoding/hex" + "fmt" + "path/filepath" + + eigensdkecdsa "github.com/Layr-Labs/eigensdk-go/crypto/ecdsa" + "github.com/ethereum/go-ethereum/cmd/utils" + "github.com/ethereum/go-ethereum/crypto" + "github.com/urfave/cli/v2" +) + +func NewGenerateAliasCommand() *cli.Command { + return &cli.Command{ + Name: "generate-alias", + Description: "Create or Import an ECDSA private key only for oracle chain", + Action: runGenerateAlias, + Flags: []cli.Flag{ + EcdsaPrivateKeyFlag, + PassphraseFlag, + KeyStorePathFlag, + OverrideFlag, + }, + } +} + +func runGenerateAlias(c *cli.Context) error { + if !c.IsSet(PassphraseFlag.Name) || !c.IsSet(KeyStorePathFlag.Name) { + utils.Fatalf("passphrase and keystore-path are required") + } + + aliasEcdsaPair, err := getAliasECDSAPrivateKey(c) + if err != nil { + return err + } + + if err = eigensdkecdsa.WriteKey( + filepath.Join(c.String(KeyStorePathFlag.Name), "ecdsaAliasedEncryptedWallet.json"), + aliasEcdsaPair, + c.String(PassphraseFlag.Name), + ); err != nil { + utils.Fatalf("Error writing the ecdsaAliasedEncryptedWallet.json file %v", err) + } + + fmt.Println("alias ecdsa address ", crypto.PubkeyToAddress(aliasEcdsaPair.PublicKey), "encrypted and saved") + return nil +} + +func getAliasECDSAPrivateKey(c *cli.Context) (*ecdsa.PrivateKey, error) { + aliasEcdsaPair, err := eigensdkecdsa.ReadKey(filepath.Join(c.String(KeyStorePathFlag.Name), "ecdsaAliasedEncryptedWallet.json"), c.String(PassphraseFlag.Name)) + if err != nil { + if c.String(EcdsaPrivateKeyFlag.Name) != "" { + aliasEcdsaPair, err = crypto.HexToECDSA(c.String(EcdsaPrivateKeyFlag.Name)) + if err != nil { + utils.Fatalf("Invalid ECDSA private key %v", err) + } + } else { + aliasEcdsaPair, err = crypto.GenerateKey() + if err != nil { + utils.Fatalf("Failed to generate ECDSA key %v", err) + } + fmt.Println("a new alias ecdsa was generated address ", crypto.PubkeyToAddress(aliasEcdsaPair.PublicKey), "private key", hex.EncodeToString(aliasEcdsaPair.D.Bytes())) + } + } else { + if c.String(EcdsaPrivateKeyFlag.Name) != "" { + if !c.Bool(OverrideFlag.Name) { + utils.Fatalf("alias already exists, use --override to replace it") + } + aliasEcdsaPair, err = crypto.HexToECDSA(c.String(EcdsaPrivateKeyFlag.Name)) + if err != nil { + utils.Fatalf("Invalid ECDSA private key %v", err) + } + } + } + return aliasEcdsaPair, nil +} diff --git a/cmd/generate_bls_key.go b/cmd/generate_bls_key.go new file mode 100644 index 0000000..c390aa9 --- /dev/null +++ b/cmd/generate_bls_key.go @@ -0,0 +1,29 @@ +package cmd + +import ( + "fmt" + + eigensdkbls "github.com/Layr-Labs/eigensdk-go/crypto/bls" + "github.com/ethereum/go-ethereum/cmd/utils" + "github.com/urfave/cli/v2" +) + +func NewGenerateBLSKeyCommand() *cli.Command { + return &cli.Command{ + Name: "generate-bls-key", + Description: "Generate the BLS key", + Action: runGenerateBLSKey, + Flags: []cli.Flag{}, + } +} + +func runGenerateBLSKey(_ *cli.Context) error { + keyPair, err := eigensdkbls.GenRandomBlsKeys() + if err != nil { + utils.Fatalf("Failed to generate BLS key pair %v", err) + } + fmt.Println("BLS private key", keyPair.PrivKey.String()) + fmt.Println("BLS public key G1", keyPair.GetPubKeyG1().String()) + fmt.Println("BLS public key G2", keyPair.GetPubKeyG2().String()) + return nil +} diff --git a/cmd/operatorcli/main.go b/cmd/operatorcli/main.go deleted file mode 100644 index 25bfff4..0000000 --- a/cmd/operatorcli/main.go +++ /dev/null @@ -1,182 +0,0 @@ -package main - -import ( - "fmt" - "os" - - "github.com/eodata/operator-cli/internal/flag" - "github.com/eodata/operator-cli/internal/operatorcli" - "github.com/urfave/cli/v2" -) - -var commandEncrypt = &cli.Command{ - Name: "encrypt", - Description: "Encrypt the ecdsa and bls private keys", - Action: runEncrypt, - Flags: []cli.Flag{ - flag.EcdsaPrivateKeyFlag, - flag.BlsPrivateKeyFlag, - flag.PassphraseFlag, - flag.KeyStorePathFlag, - }, -} -var commandDecrypt = &cli.Command{ - Name: "decrypt", - Description: "Decrypt the ecdsa and bls private keys", - Action: runDecrypt, - Flags: []cli.Flag{ - flag.PassphraseFlag, - flag.KeyStorePathFlag, - }, -} - -var commandRegister = &cli.Command{ - Name: "register", - Description: "Register the operator", - Action: runRegister, - Flags: []cli.Flag{ - flag.EthRPCFlag, - flag.RegistryCoordinatorFlag, - flag.PassphraseFlag, - flag.KeyStorePathFlag, - flag.SaltFlag, - flag.ExpiryFlag, - flag.EcdsaPrivateKeyFlag, - flag.BlsPrivateKeyFlag, - flag.ChainValidatorG1PointSignatureFlag, - flag.ValidatorRoleFlag, - flag.QuorumNumberFlag, - }, -} - -var commandDeregister = &cli.Command{ - Name: "deregister", - Description: "Deregister the operator", - Action: runDeregister, - Flags: []cli.Flag{ - flag.EthRPCFlag, - flag.RegistryCoordinatorFlag, - flag.PassphraseFlag, - flag.KeyStorePathFlag, - flag.EcdsaPrivateKeyFlag, - flag.QuorumNumberFlag, - }, -} - -var commandPrintStatus = &cli.Command{ - Name: "print-status", - Description: "Print the operator status", - Action: runPrintStatus, - Flags: []cli.Flag{ - flag.EthRPCFlag, - flag.EOChainEthRPCFlag, - flag.EOConfigAddressFlag, - flag.RegistryCoordinatorFlag, - flag.PassphraseFlag, - flag.KeyStorePathFlag, - flag.QuorumNumberFlag, - }, -} - -var commandGenerateBLSKey = &cli.Command{ - Name: "generate-bls-key", - Description: "Generate the BLS key", - Action: runGenerateBLSKey, - Flags: []cli.Flag{}, -} - -var commandGenerateAlias = &cli.Command{ - Name: "generate-alias", - Description: "Create or Import an ECDSA private key only for oracle chain", - Action: runGenerateAlias, - Flags: []cli.Flag{ - flag.EcdsaPrivateKeyFlag, - flag.PassphraseFlag, - flag.KeyStorePathFlag, - flag.OverrideFlag, - }, -} - -var commandDeclareAlias = &cli.Command{ - Name: "declare-alias", - Description: "Declare the alias in the eochain", - Action: runDeclareAlias, - Flags: []cli.Flag{ - flag.PassphraseFlag, - flag.KeyStorePathFlag, - flag.EOChainEthRPCFlag, - flag.EOConfigAddressFlag, - }, -} - -var commandResetConfiguration = &cli.Command{ - Name: "reset-configuration", - Description: "Reset configuration in EO chain", - Action: runResetConfiguration, - Flags: []cli.Flag{ - flag.EthRPCFlag, - flag.EOChainEthRPCFlag, - flag.EOConfigAddressFlag, - flag.PassphraseFlag, - flag.KeyStorePathFlag, - }, -} - -func main() { - app := cli.NewApp() - app.Name = "operatorCli" - app.Description = "EO generate operator signature and message for registration" - app.Usage = "Used to create operator signature and message for registration" - app.Commands = []*cli.Command{ - commandEncrypt, - commandDecrypt, - commandRegister, - commandDeregister, - commandPrintStatus, - commandGenerateBLSKey, - commandGenerateAlias, - commandDeclareAlias, - commandResetConfiguration, - } - - if err := app.Run(os.Args); err != nil { - fmt.Println("Error: ", err) - os.Exit(1) - } -} - -func runEncrypt(c *cli.Context) error { - return operatorcli.RunEncrypt(c) -} - -func runDecrypt(c *cli.Context) error { - return operatorcli.RunDecrypt(c) -} - -func runRegister(c *cli.Context) error { - return operatorcli.RunRegister(c) -} - -func runDeregister(c *cli.Context) error { - return operatorcli.RunDeregister(c) -} - -func runPrintStatus(c *cli.Context) error { - return operatorcli.RunPrintStatus(c) -} - -func runGenerateBLSKey(c *cli.Context) error { - return operatorcli.RunGenerateBLSKey(c) -} - -func runGenerateAlias(c *cli.Context) error { - return operatorcli.RunGenerateAlias(c) -} - -func runDeclareAlias(c *cli.Context) error { - return operatorcli.RunDeclareAlias(c) -} - -func runResetConfiguration(c *cli.Context) error { - return operatorcli.RunResetConfiguration(c) -} diff --git a/cmd/print_status.go b/cmd/print_status.go new file mode 100644 index 0000000..8ed9efd --- /dev/null +++ b/cmd/print_status.go @@ -0,0 +1,148 @@ +package cmd + +import ( + "context" + "fmt" + "math/big" + + eoconfig "github.com/eodata/operator-cli/contracts/bindings/EOConfig" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/cmd/utils" + gethcommon "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/ethclient" + "github.com/urfave/cli/v2" +) + +func NewPrintStatusCommand() *cli.Command { + return &cli.Command{ + Name: "print-status", + Description: "Print the operator status", + Before: setProfile, + Action: runPrintStatus, + Flags: []cli.Flag{ + ProfileFlag, + EthRPCFlag, + EOChainRPCFlag, + EOConfigAddressFlag, + RegistryCoordinatorFlag, + PassphraseFlag, + KeyStorePathFlag, + QuorumNumberFlag, + }, + } +} + +func runPrintStatus(c *cli.Context) error { + if !c.IsSet(PassphraseFlag.Name) || !c.IsSet(KeyStorePathFlag.Name) { + utils.Fatalf("passphrase and keystore-path are required") + } + + ecdsaOperatorPair, ecdsaAliasPair, err := getOperatorAndAliasKeys(c) + if err != nil { + return err + } + + ethClient, err := createEthClient(profile.EthRPCEndpoint) + if err != nil { + return err + } + + avsClient, err := buildAVSClient(ethClient) + if err != nil { + utils.Fatalf("Failed to create AVS client %v", err) + } + + operatorAddress := crypto.PubkeyToAddress(ecdsaOperatorPair.PublicKey) + operatorAliasAddress := crypto.PubkeyToAddress(ecdsaAliasPair.PublicKey) + + operatorIsEOA, err := isEOA(ethClient, operatorAddress) + if err != nil { + return err + } + + eoChainEthClient, err := createEthClient(profile.EOChainRPCEndpoint) + if err != nil { + return err + } + + contractEOConfig, err := eoconfig.NewEOConfig(profile.EOConfigAddress, eoChainEthClient) + if err != nil { + utils.Fatalf("Failed to load EOConfig contract %v", err) + } + + operatorAlias, err := contractEOConfig.OperatorToAlias(&bind.CallOpts{Context: context.Background()}, operatorAddress) + if err != nil || operatorAlias == (gethcommon.Address{}) { + utils.Fatalf("Failed to get operator %v alias %v", operatorAddress, err) + } + + logger.Info( + "operator details", + "operator address", operatorAddress, + "alias address", operatorAliasAddress, + "operator is EOA", operatorIsEOA, + ) + + if operatorAlias != operatorAliasAddress { + utils.Fatalf( + "Operator (%v) alias (%v) does not match the expected alias (%v)", + operatorAddress, + operatorAlias, + operatorAliasAddress, + ) + } + + id, err := avsClient.registryCoordinator.GetOperatorId(&bind.CallOpts{Context: context.Background()}, operatorAddress) + if err != nil || id == [32]byte{} { + utils.Fatalf("Error while GetOperatorId %v", err) + } + + status, err := avsClient.registryCoordinator.GetOperatorStatus(&bind.CallOpts{Context: context.Background()}, operatorAddress) + if err != nil { + utils.Fatalf("Error while GetOperatorStatus %v", err) + } + + switch status { + case 0: + logger.Info("Operator Status", "status", "NEVER REGISTERED") + case 1: + logger.Info("Operator Status", "status", "REGISTERED") + case 2: + logger.Info("Operator Status", "status", "DEREGISTERED") + default: + utils.Fatalf("Unknown operator status %v", status) + } + + stake, err := avsClient.stakeRegistry.GetLatestStakeUpdate( + &bind.CallOpts{Context: context.Background()}, + id, + uint8(c.Int(QuorumNumberFlag.Name)), + ) + if err != nil { + utils.Fatalf("Error while GetLatestStakeUpdate %v", err) + } + + logger.Info("Operator stake update", "stake", stake.Stake, "block number", stake.UpdateBlockNumber) + + printBalance(eoChainEthClient, operatorAddress, "operator address") + printBalance(eoChainEthClient, operatorAliasAddress, "operator alias address") + + return nil +} + +func isEOA(ethClient *ethclient.Client, address gethcommon.Address) (bool, error) { + code, err := ethClient.CodeAt(context.Background(), address, nil) + if err != nil { + utils.Fatalf("Error checking if address is EOA %v", err) + } + return len(code) == 0, nil +} + +func printBalance(ethClient *ethclient.Client, address gethcommon.Address, label string) { + balance, err := ethClient.BalanceAt(context.Background(), address, nil) + if err != nil { + utils.Fatalf("Error while getting the %s balance %v", label, err) + } + balanceInEth := new(big.Float).Quo(new(big.Float).SetInt(balance), new(big.Float).SetInt(big.NewInt(1e18))) + logger.Info(fmt.Sprintf("%s balance", label), "address", address.Hex(), "balance", balanceInEth.String()) +} diff --git a/cmd/profile.go b/cmd/profile.go new file mode 100644 index 0000000..d8904dc --- /dev/null +++ b/cmd/profile.go @@ -0,0 +1,123 @@ +package cmd + +import ( + "encoding/hex" + "fmt" + "net/url" + "strings" + + gethcommon "github.com/ethereum/go-ethereum/common" + "github.com/urfave/cli/v2" +) + +const ( + MainnetProfileName = "mainnet" + TestnetProfileName = "testnet" +) + +var ( + MainnetProfile = NetworkProfile{ + NetworkName: MainnetProfileName, + + EOConfigAddress: gethcommon.HexToAddress("0x05a6f762f64Ac2ccE0588677317a0Ed8af9d0c16"), + RegistryCoordinatorAddress: gethcommon.HexToAddress("0x757E6f572AfD8E111bD913d35314B5472C051cA8"), + + EOChainRPCEndpoint: "https://rpc.eoracle.network", + EthRPCEndpoint: "https://rpc.flashbots.net", + } + + TestnetProfile = NetworkProfile{ + NetworkName: TestnetProfileName, + + EOConfigAddress: gethcommon.HexToAddress("0xf735Ad57952906a672eEEaDbef3bC69ECD24E50C"), + RegistryCoordinatorAddress: gethcommon.HexToAddress("0xc4A6E362e8Bd89F28Eb405F9Aa533784884B9c4F"), + + EOChainRPCEndpoint: "https://rpc.testnet.eoracle.network", + EthRPCEndpoint: "https://holesky.gateway.tenderly.com", + } +) + +func setProfile(context *cli.Context) error { + profileName := context.String(ProfileFlag.Name) + + switch profileName { + case MainnetProfileName: + profile = &MainnetProfile + case TestnetProfileName: + profile = &TestnetProfile + default: + return fmt.Errorf("invalid profile name: %s", profileName) + } + + if err := overrideAddress(context, EOConfigAddressFlag.Name, &profile.EOConfigAddress); err != nil { + return err + } + + if err := overrideAddress(context, RegistryCoordinatorFlag.Name, &profile.RegistryCoordinatorAddress); err != nil { + return err + } + + if err := overrideURL(context, EOChainRPCFlag.Name, &profile.EOChainRPCEndpoint); err != nil { + return err + } + + if err := overrideURL(context, EthRPCFlag.Name, &profile.EthRPCEndpoint); err != nil { + return err + } + + return nil +} + +func overrideAddress(c *cli.Context, flagName string, address *gethcommon.Address) error { + if c.IsSet(flagName) { + addressOverride := c.String(flagName) + if err := isValidAddress(addressOverride); err != nil { + return fmt.Errorf("invalid %s: %v", flagName, err) + } + *address = gethcommon.HexToAddress(addressOverride) + } + return nil +} + +func overrideURL(c *cli.Context, flagName string, urlStr *string) error { + if c.IsSet(flagName) { + urlOverride := c.String(flagName) + if err := isValidHttpURL(urlOverride); err != nil { + return fmt.Errorf("invalid %s: %v", flagName, err) + } + *urlStr = urlOverride + } + return nil +} + +// IsValidAddress checks if provided string is a valid Ethereum address +func isValidAddress(address string) error { + // remove 0x prefix if it exists + address = strings.TrimPrefix(address, "0x") + + // decode the address + decodedAddress, err := hex.DecodeString(address) + if err != nil { + return fmt.Errorf("address %s contains invalid characters", address) + } + + // check if the address has the correct length + if len(decodedAddress) != gethcommon.AddressLength { + return fmt.Errorf("address %s has invalid length", string(decodedAddress)) + } + + return nil +} + +func isValidHttpURL(u string) error { + parsedURL, err := url.ParseRequestURI(u) + if err != nil { + return err + } + + if parsedURL.Scheme != "http" && parsedURL.Scheme != "https" { + return fmt.Errorf("invalid scheme: %s", parsedURL.Scheme) + } + + return nil +} diff --git a/cmd/profiles_test.go b/cmd/profiles_test.go new file mode 100644 index 0000000..5b07ebe --- /dev/null +++ b/cmd/profiles_test.go @@ -0,0 +1,145 @@ +package cmd + +import ( + flaglib "flag" + "testing" + + gethcommon "github.com/ethereum/go-ethereum/common" + "github.com/stretchr/testify/assert" + "github.com/urfave/cli/v2" +) + +func TestFromArgs(t *testing.T) { + tests := []struct { + name string + args []string + expectedError bool + expectedProfile *NetworkProfile + }{ + { + name: "valid mainnet profile", + args: []string{"--" + ProfileFlag.Name, MainnetProfileName}, + expectedError: false, + expectedProfile: &MainnetProfile, + }, + { + name: "valid testnet profile", + args: []string{"--" + ProfileFlag.Name, TestnetProfileName}, + expectedError: false, + expectedProfile: &TestnetProfile, + }, + { + name: "invalid profile", + args: []string{"--" + ProfileFlag.Name, "invalid"}, + expectedError: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + set := flaglib.NewFlagSet("test", flaglib.ContinueOnError) + set.String(ProfileFlag.Name, "", "profile name") + c := cli.NewContext(nil, set, nil) + err := set.Parse(tt.args) + assert.NoError(t, err) + err = setProfile(c) + assert.NoError(t, err) + + if tt.expectedError { + assert.Error(t, err) + } else { + assert.NoError(t, err) + assert.Equal(t, tt.expectedProfile, profile) + } + }) + } +} + +func TestOverrideAddress(t *testing.T) { + tests := []struct { + name string + args []string + flagName string + expectedError bool + expectedAddress gethcommon.Address + }{ + { + name: "valid address", + args: []string{"--" + EOConfigAddressFlag.Name, "0xf735Ad57952906a672eEEaDbef3bC69ECD24E50C"}, + flagName: EOConfigAddressFlag.Name, + expectedError: false, + expectedAddress: gethcommon.HexToAddress("0xf735Ad57952906a672eEEaDbef3bC69ECD24E50C"), + }, + { + name: "invalid address", + args: []string{"--" + EOConfigAddressFlag.Name, "invalid"}, + flagName: EOConfigAddressFlag.Name, + expectedError: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + set := flaglib.NewFlagSet("test", flaglib.ContinueOnError) + set.String(tt.flagName, "", "address") + set.String(ProfileFlag.Name, "testnet", "profile name") + c := cli.NewContext(nil, set, nil) + err := set.Parse(tt.args) + assert.NoError(t, err) + + err = setProfile(c) + assert.NoError(t, err) + + if tt.expectedError { + assert.Error(t, err) + } else { + assert.NoError(t, err) + assert.Equal(t, tt.expectedAddress, profile.EOConfigAddress) + } + }) + } +} + +func TestOverrideURL(t *testing.T) { + tests := []struct { + name string + args []string + flagName string + expectedError bool + expectedURL string + }{ + { + name: "valid URL", + args: []string{"--" + EOChainRPCFlag.Name, "https://rpc.eoracle.network"}, + flagName: EOChainRPCFlag.Name, + expectedError: false, + expectedURL: "https://rpc.eoracle.network", + }, + { + name: "invalid URL", + args: []string{"--" + EOChainRPCFlag.Name, "invalid"}, + flagName: EOChainRPCFlag.Name, + expectedError: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + set := flaglib.NewFlagSet("test", flaglib.ContinueOnError) + set.String(tt.flagName, "", "URL") + set.String(ProfileFlag.Name, "testnet", "profile name") + c := cli.NewContext(nil, set, nil) + err := set.Parse(tt.args) + assert.NoError(t, err) + err = setProfile(c) + assert.NoError(t, err) + + if tt.expectedError { + assert.Error(t, err) + } else { + assert.NoError(t, err) + assert.Equal(t, tt.expectedURL, profile.EOChainRPCEndpoint) + } + }) + } +} diff --git a/cmd/register.go b/cmd/register.go new file mode 100644 index 0000000..610462f --- /dev/null +++ b/cmd/register.go @@ -0,0 +1,294 @@ +package cmd + +import ( + "context" + "crypto/ecdsa" + "encoding/hex" + "math/big" + "path/filepath" + "strings" + + "github.com/Layr-Labs/eigensdk-go/chainio/clients/wallet" + "github.com/Layr-Labs/eigensdk-go/chainio/txmgr" + eigensdkbls "github.com/Layr-Labs/eigensdk-go/crypto/bls" + eigensdkecdsa "github.com/Layr-Labs/eigensdk-go/crypto/ecdsa" + "github.com/Layr-Labs/eigensdk-go/signerv2" + "github.com/consensys/gnark-crypto/ecc/bn254" + regcoord "github.com/eodata/operator-cli/contracts/bindings/EORegistryCoordinator" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/cmd/utils" + "github.com/ethereum/go-ethereum/crypto" + "github.com/urfave/cli/v2" +) + +func NewRegisterCommand() *cli.Command { + return &cli.Command{ + Name: "register", + Description: "Register the operator", + Before: setProfile, + Action: runRegister, + Flags: []cli.Flag{ + ProfileFlag, + EthRPCFlag, + EOChainRPCFlag, + RegistryCoordinatorFlag, + EOConfigAddressFlag, + PassphraseFlag, + KeyStorePathFlag, + SaltFlag, + ExpiryFlag, + EcdsaPrivateKeyFlag, + BlsPrivateKeyFlag, + ChainValidatorG1PointSignatureFlag, + ValidatorRoleFlag, + QuorumNumberFlag, + }, + } +} + +func runRegister(c *cli.Context) error { + if (!c.IsSet(PassphraseFlag.Name) || !c.IsSet(KeyStorePathFlag.Name)) && (!c.IsSet(EcdsaPrivateKeyFlag.Name) || !c.IsSet(BlsPrivateKeyFlag.Name)) { + utils.Fatalf("either passphrase and keystore-path or ecdsa-private-key and bls-private-key are required") + } + + ecdsaPair, blsKeyPair, err := getKeys(c) + if err != nil { + return err + } + + ethClient, err := createEthClient(profile.EthRPCEndpoint) + if err != nil { + return err + } + + chainIDBigInt, err := ethClient.ChainID(context.Background()) + if err != nil { + utils.Fatalf("Error getting chainId (%v): %v", profile.EthRPCEndpoint, err) + } + + signerV2, signerAddr, err := signerv2.SignerFromConfig(signerv2.Config{PrivateKey: ecdsaPair}, chainIDBigInt) + if err != nil { + utils.Fatalf("Error creating the register transaction signer for operator %v on Ethereum mainnet/holesky (%v) %v", + crypto.PubkeyToAddress(ecdsaPair.PublicKey), profile.EthRPCEndpoint, err, + ) + } + + saltBytes, err := getSaltBytes(c) + if err != nil { + return err + } + + expiry, err := getExpiry(c) + if err != nil { + return err + } + + avsClient, err := buildAVSClient(ethClient) + if err != nil { + utils.Fatalf("Error creating AVS client %v", err) + } + + g1HashedMsgToSign, err := avsClient.registryCoordinator.PubkeyRegistrationMessageHash(&bind.CallOpts{}, signerAddr) + if err != nil { + utils.Fatalf("Error getting PubkeyRegistrationMessageHash from registryCoordinator contract %v", err) + } + + signedMsg := convertToBN254G1Point( + blsKeyPair.SignHashedToCurveMessage(convertBn254GethToGnark(g1HashedMsgToSign)).G1Point, + ) + G1pubkeyBN254 := convertToBN254G1Point(blsKeyPair.GetPubKeyG1()) + G2pubkeyBN254 := convertToBN254G2Point(blsKeyPair.GetPubKeyG2()) + + pubkeyRegParams := regcoord.IBLSApkRegistryTypesPubkeyRegistrationParams{ + PubkeyRegistrationSignature: signedMsg, + PubkeyG1: G1pubkeyBN254, + PubkeyG2: G2pubkeyBN254, + } + + msgToSign, err := avsClient.elReader.CalculateOperatorAVSRegistrationDigestHash( + context.Background(), + signerAddr, + avsClient.serviceManagerAddr, + saltBytes, + expiry, + ) + if err != nil { + utils.Fatalf( + "Error generating message to sign by operator %v on Ethereum mainnet/Holeskey (%v) using CalculateOperatorAVSRegistrationDigestHash %v", + crypto.PubkeyToAddress(ecdsaPair.PublicKey), + profile.EthRPCEndpoint, + err, + ) + } + + operatorSignature, err := crypto.Sign(msgToSign[:], ecdsaPair) + if err != nil { + utils.Fatalf( + "Error signing the message using CalculateOperatorAVSRegistrationDigestHash for operator %v on Ethereum mainnet/Holeskey (%v) %v", + crypto.PubkeyToAddress(ecdsaPair.PublicKey), + profile.EthRPCEndpoint, + err, + ) + } + + operatorSignature[64] += 27 + operatorSignatureWithSaltAndExpiry := regcoord.ISignatureUtilsMixinTypesSignatureWithSaltAndExpiry{ + Signature: operatorSignature, + Salt: saltBytes, + Expiry: expiry, + } + + txSender, err := wallet.NewPrivateKeyWallet(ethClient, signerV2, signerAddr, logger) + if err != nil { + utils.Fatalf( + "Error creating the register transaction sender for operator %v on Ethereum mainnet/Holesky (%v) %v", + crypto.PubkeyToAddress(ecdsaPair.PublicKey), + profile.EthRPCEndpoint, + err, + ) + } + + address, err := txSender.SenderAddress(context.Background()) + if err != nil { + return err + } + + addr := address.String() + logger.Info("sender address", "address", addr) + + txMgr := txmgr.NewSimpleTxManager(txSender, ethClient, logger, signerAddr) + noSendTxOpts, err := txMgr.GetNoSendTxOpts() + if err != nil { + utils.Fatalf("error creating transaction object %v", err) + } + + noSendTxOpts.GasLimit = 2_000_000 + + tx, err := avsClient.registryCoordinator.RegisterOperator( + noSendTxOpts, + []byte{0}, + "0.0.0.0:0", + pubkeyRegParams, + operatorSignatureWithSaltAndExpiry, + ) + if err != nil { + utils.Fatalf( + "Error creating the register transaction for operator %v on Ethereum mainnet/Holeskey (%v) %v", + crypto.PubkeyToAddress(ecdsaPair.PublicKey), + profile.EthRPCEndpoint, + err, + ) + } + + ctx := context.Background() + receipt, err := txMgr.Send(ctx, tx, true) + if err != nil { + utils.Fatalf( + "register transaction for operator %v on Ethereum mainnet/Holeskey (%v) failed %v", + crypto.PubkeyToAddress(ecdsaPair.PublicKey), + profile, + err, + ) + } + if receipt.Status != 1 { + utils.Fatalf( + "register transaction %v for operator %v on Ethereum mainnet/Holeskey (%v) reverted", + receipt.TxHash.Hex(), + crypto.PubkeyToAddress(ecdsaPair.PublicKey), + profile.EthRPCEndpoint, + ) + } + + logger.Info("successfully registered to eoracle AVS", "address", signerAddr, "tx hash", receipt.TxHash.Hex()) + + return nil +} + +func convertBn254GethToGnark(input regcoord.BN254G1Point) *bn254.G1Affine { + return eigensdkbls.NewG1Point(input.X, input.Y).G1Affine +} + +func convertToBN254G2Point(input *eigensdkbls.G2Point) regcoord.BN254G2Point { + output := regcoord.BN254G2Point{ + X: [2]*big.Int{input.X.A1.BigInt(big.NewInt(0)), input.X.A0.BigInt(big.NewInt(0))}, + Y: [2]*big.Int{input.Y.A1.BigInt(big.NewInt(0)), input.Y.A0.BigInt(big.NewInt(0))}, + } + return output +} +func convertToBN254G1Point(input *eigensdkbls.G1Point) regcoord.BN254G1Point { + output := regcoord.BN254G1Point{ + X: input.X.BigInt(big.NewInt(0)), + Y: input.Y.BigInt(big.NewInt(0)), + } + return output +} + +func getExpiry(c *cli.Context) (*big.Int, error) { + expiry, ok := big.NewInt(0).SetString(c.String(ExpiryFlag.Name), 10) + if !ok { + utils.Fatalf("Invalid expiry") + } + return expiry, nil +} + +func getKeys(c *cli.Context) (*ecdsa.PrivateKey, *eigensdkbls.KeyPair, error) { + var ecdsaPair *ecdsa.PrivateKey + var blsKeyPair *eigensdkbls.KeyPair + var err error + + if !c.IsSet(PassphraseFlag.Name) || !c.IsSet(KeyStorePathFlag.Name) { + ecdsaPair, err = crypto.HexToECDSA(c.String(EcdsaPrivateKeyFlag.Name)) + if err != nil { + utils.Fatalf("Invalid EDCSA private key %v", err) + } + blsKeyPair, err = eigensdkbls.NewKeyPairFromString(c.String(BlsPrivateKeyFlag.Name)) + if err != nil { + utils.Fatalf("Invalid BLS private key %v", err) + } + } else { + ecdsaPair, err = eigensdkecdsa.ReadKey( + filepath.Join(c.String(KeyStorePathFlag.Name), "ecdsaEncryptedWallet.json"), + c.String(PassphraseFlag.Name), + ) + if err != nil { + utils.Fatalf("Failed to read ecdsaEncryptedWallet.json file %v", err) + } + blsKeyPair, err = eigensdkbls.ReadPrivateKeyFromFile( + filepath.Join(c.String(KeyStorePathFlag.Name), "blsEncryptedWallet.json"), + c.String(PassphraseFlag.Name), + ) + if err != nil { + utils.Fatalf("Failed to read blsEncryptedWallet.json file %v", err) + } + } + return ecdsaPair, blsKeyPair, nil +} + +func getSaltBytes(c *cli.Context) ([32]byte, error) { + var saltBytes [32]byte + inputBytes, err := hex.DecodeString(strings.TrimPrefix(c.String(SaltFlag.Name), "0x")) + if err != nil { + utils.Fatalf("Invalid salt %v", err) + } + copy(saltBytes[:], inputBytes) + return saltBytes, nil +} + +func getChainValidatorG1PointSignature(c *cli.Context) (regcoord.BN254G1Point, error) { + chainValidatorG1PointSignature := convertToBN254G1Point(eigensdkbls.NewG1Point(big.NewInt(0), big.NewInt(0))) + if c.String(ValidatorRoleFlag.Name) != "DATA_VALIDATOR" { + if len(c.StringSlice(ChainValidatorG1PointSignatureFlag.Name)) != 2 { + utils.Fatalf("chain-validator-g1-point-signature is required or has too many values") + } + x, ok := new(big.Int).SetString(c.StringSlice(ChainValidatorG1PointSignatureFlag.Name)[0][2:], 16) + if !ok { + utils.Fatalf("Invalid chain-validator-g1-point-signature (x)") + } + y, ok := new(big.Int).SetString(c.StringSlice(ChainValidatorG1PointSignatureFlag.Name)[1][2:], 16) + if !ok { + utils.Fatalf("Invalid chain-validator-g1-point-signature (y)") + } + chainValidatorG1PointSignature = convertToBN254G1Point(eigensdkbls.NewG1Point(x, y)) + } + return chainValidatorG1PointSignature, nil +} diff --git a/cmd/reset_configuration.go b/cmd/reset_configuration.go new file mode 100644 index 0000000..29abc7a --- /dev/null +++ b/cmd/reset_configuration.go @@ -0,0 +1,137 @@ +package cmd + +import ( + "context" + "math/big" + + "github.com/Layr-Labs/eigensdk-go/chainio/clients/wallet" + "github.com/Layr-Labs/eigensdk-go/chainio/txmgr" + "github.com/Layr-Labs/eigensdk-go/signerv2" + eoconfig "github.com/eodata/operator-cli/contracts/bindings/EOConfig" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/cmd/utils" + gethcommon "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/ethclient" + "github.com/urfave/cli/v2" +) + +func NewResetConfigurationCommand() *cli.Command { + return &cli.Command{ + Name: "reset-configuration", + Description: "Reset configuration in eOracle chain", + Before: setProfile, + Action: runResetConfiguration, + Flags: []cli.Flag{ + ProfileFlag, + EthRPCFlag, + EOChainRPCFlag, + EOConfigAddressFlag, + PassphraseFlag, + KeyStorePathFlag, + }, + } +} + +func runResetConfiguration(c *cli.Context) error { + if !c.IsSet(PassphraseFlag.Name) || !c.IsSet(KeyStorePathFlag.Name) { + utils.Fatalf("passphrase and keystore-path are required") + } + + ecdsaOperatorPair, ecdsaAliasPair, err := getOperatorAndAliasKeys(c) + if err != nil { + return err + } + + operatorAddress := crypto.PubkeyToAddress(ecdsaOperatorPair.PublicKey) + operatorAliasAddress := crypto.PubkeyToAddress(ecdsaAliasPair.PublicKey) + + eoChainEthClient, err := createEthClient(c.String(EOChainRPCFlag.Name)) + if err != nil { + return err + } + + contractEOConfig, err := getEOConfigContract(eoChainEthClient) + if err != nil { + return err + } + + operatorAlias, err := contractEOConfig.OperatorToAlias(&bind.CallOpts{Context: context.Background()}, operatorAddress) + if err != nil || operatorAlias == (gethcommon.Address{}) { + utils.Fatalf("Failed to get operator %v alias %v", operatorAddress, err) + } + + logger.Info("operator details", + "operator address", operatorAddress.Hex(), + "alias address", operatorAliasAddress.Hex(), + "operator is EOA", true, + ) + + if operatorAlias != operatorAliasAddress { + utils.Fatalf("Operator (%v) alias (%v) does not match the expected alias (%v), please contact eOracle support", + operatorAddress.Hex(), operatorAlias.Hex(), operatorAliasAddress.Hex()) + } + + balance, err := eoChainEthClient.BalanceAt(context.Background(), operatorAddress, nil) + if err != nil { + utils.Fatalf("Error while getting the operator (%v) balance %v on eoChain", operatorAddress, err) + } + + if balance.Cmp(big.NewInt(500000000000000000)) > 0 { + eochainChainIDBigInt, err := eoChainEthClient.ChainID(context.Background()) + if err != nil { + utils.Fatalf("Error getting chainId (%v): %v", c.String(EOChainRPCFlag.Name), err) + } + + returnBalance := balance.Sub(balance, big.NewInt(500000000000000000)) + signerV2, signerAddr, err := signerv2.SignerFromConfig(signerv2.Config{PrivateKey: ecdsaOperatorPair}, eochainChainIDBigInt) + if err != nil { + utils.Fatalf("Error creating the signer function for operator %v on eoChain (%v) %v", + crypto.PubkeyToAddress(ecdsaOperatorPair.PublicKey), c.String(EOChainRPCFlag.Name), err) + } + + txSender, err := wallet.NewPrivateKeyWallet(eoChainEthClient, signerV2, signerAddr, logger) + if err != nil { + utils.Fatalf("Error creating the transaction sender for operator %v on eoChain (%v) %v", + crypto.PubkeyToAddress(ecdsaOperatorPair.PublicKey), c.String(EOChainRPCFlag.Name), err) + } + txMgr := txmgr.NewSimpleTxManager(txSender, eoChainEthClient, logger, signerAddr) + txOpts, err := txMgr.GetNoSendTxOpts() + if err != nil { + utils.Fatalf("Error generating transaction for resetting eochain gas balance of operator %v on eoChain (%v) %v", + operatorAddress.Hex(), c.String(EOChainRPCFlag.Name), err) + } + txOpts.Value = returnBalance + + contractEOConfigRaw := eoconfig.EOConfigRaw{Contract: contractEOConfig} + tx, err := contractEOConfigRaw.Transfer(txOpts) + if err != nil { + utils.Fatalf("Error reseting the operator %v balance on eochain (%v) %v", operatorAddress.Hex(), c.String(EOChainRPCFlag.Name), err) + } + + ctx := context.Background() + receipt, err := txMgr.Send(ctx, tx, true) + if err != nil { + utils.Fatalf("Error sending the reset balance transaction of operator %v on eochain (%v) %v", + operatorAddress.Hex(), c.String(EOChainRPCFlag.Name), err) + } + + if receipt.Status != 1 { + utils.Fatalf("The transaction %v to reset the operator %v balance on eochain (%v) reverted", + receipt.TxHash.Hex(), operatorAddress.Hex(), c.String(EOChainRPCFlag.Name)) + } + + balance, err = eoChainEthClient.BalanceAt(context.Background(), operatorAddress, nil) + if err != nil { + utils.Fatalf("Error while getting the operator (%v) balance %v on eoChain", operatorAddress, err) + } + } + balanceInEth := new(big.Float).Quo(new(big.Float).SetInt(balance), new(big.Float).SetInt(big.NewInt(1e18))) + logger.Info("Operator balance", "operator address", operatorAddress.Hex(), "balance", balanceInEth.String()) + + return nil +} + +func getEOConfigContract(ethClient *ethclient.Client) (*eoconfig.EOConfig, error) { + return eoconfig.NewEOConfig(profile.EOConfigAddress, ethClient) +} diff --git a/cmd/utils.go b/cmd/utils.go new file mode 100644 index 0000000..e81ad28 --- /dev/null +++ b/cmd/utils.go @@ -0,0 +1,141 @@ +package cmd + +import ( + "crypto/ecdsa" + "fmt" + "path/filepath" + + "github.com/Layr-Labs/eigensdk-go/chainio/clients/elcontracts" + smbase "github.com/Layr-Labs/eigensdk-go/contracts/bindings/ServiceManagerBase" + eigensdkbls "github.com/Layr-Labs/eigensdk-go/crypto/bls" + eigensdkecdsa "github.com/Layr-Labs/eigensdk-go/crypto/ecdsa" + regcoord "github.com/eodata/operator-cli/contracts/bindings/EORegistryCoordinator" + stakeregistry "github.com/eodata/operator-cli/contracts/bindings/EOStakeRegistry" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/cmd/utils" + gethcommon "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/ethclient" + "github.com/ethereum/go-ethereum/rpc" + "github.com/urfave/cli/v2" +) + +type avsClient struct { + registryCoordinatorAddr gethcommon.Address + serviceManagerAddr gethcommon.Address + delegationManagerAddr gethcommon.Address + avsDirectoryAddr gethcommon.Address + registryCoordinator *regcoord.EORegistryCoordinator + serviceManager *smbase.ContractServiceManagerBase + stakeRegistry *stakeregistry.EOStakeRegistry + elReader *elcontracts.ChainReader +} + +func buildAVSClient( + ethClient *ethclient.Client, +) (*avsClient, error) { + + avsClient := &avsClient{ + registryCoordinatorAddr: profile.RegistryCoordinatorAddress, + } + + registryCoordinator, err := regcoord.NewEORegistryCoordinator( + profile.RegistryCoordinatorAddress, + ethClient, + ) + + if err != nil { + return nil, fmt.Errorf("failed to create RegistryCoordinator contract %v", err) + } + avsClient.registryCoordinator = registryCoordinator + + serviceManagerAddr, err := registryCoordinator.ServiceManager(&bind.CallOpts{}) + if err != nil { + return nil, fmt.Errorf("failed to get ServiceManager from registryCoordinator contract %v", err) + } + avsClient.serviceManagerAddr = serviceManagerAddr + + serviceManager, err := smbase.NewContractServiceManagerBase(serviceManagerAddr, ethClient) + if err != nil { + return nil, fmt.Errorf("failed to create serviceManager contract %v", err) + } + avsClient.serviceManager = serviceManager + + stakeRegistryAddr, err := registryCoordinator.StakeRegistry(&bind.CallOpts{}) + if err != nil { + return nil, fmt.Errorf("failed to get stakeRegistryAddr %v", err) + } + stakeRegistry, err := stakeregistry.NewEOStakeRegistry(stakeRegistryAddr, ethClient) + if err != nil { + return nil, fmt.Errorf("failed to create stakeRegistry contract %v", err) + } + avsClient.stakeRegistry = stakeRegistry + + delegationManagerAddr, err := stakeRegistry.Delegation(&bind.CallOpts{}) + if err != nil { + return nil, fmt.Errorf("failed to get delegationManagerAddr %v", err) + } + avsClient.delegationManagerAddr = delegationManagerAddr + + avsDirectoryAddr, err := serviceManager.AvsDirectory(&bind.CallOpts{}) + if err != nil { + return nil, fmt.Errorf("failed to get avsDirectoryAddr %v", err) + } + avsClient.avsDirectoryAddr = avsDirectoryAddr + + elConfig := elcontracts.Config{ + AvsDirectoryAddress: avsDirectoryAddr, + RewardsCoordinatorAddress: gethcommon.Address{}, + PermissionControllerAddress: gethcommon.Address{}, + DontUseAllocationManager: true, + } + elReader, _, err := elcontracts.BuildReadClients(elConfig, ethClient, logger, nil) + if err != nil { + return nil, fmt.Errorf("failed to create ELChainReader %v", err) + } + avsClient.elReader = elReader + + return avsClient, nil +} + +func createEthClient(rpcEndpoint string) (*ethclient.Client, error) { + rpcClient, err := rpc.Dial(rpcEndpoint) + if err != nil { + utils.Fatalf("failed to create Eth client %v %v", rpcEndpoint, err) + } + return ethclient.NewClient(rpcClient), nil +} + +func getECDSAPrivateKey(c *cli.Context) (*ecdsa.PrivateKey, error) { + if !c.IsSet(PassphraseFlag.Name) { + utils.Fatalf("passphrase is required") + } + if !c.IsSet(KeyStorePathFlag.Name) { + utils.Fatalf("keystore-path is required") + } + if c.IsSet(EcdsaPrivateKeyFlag.Name) { + return crypto.HexToECDSA(c.String(EcdsaPrivateKeyFlag.Name)) + } + return eigensdkecdsa.ReadKey( + filepath.Join(c.String(KeyStorePathFlag.Name), "ecdsaEncryptedWallet.json"), + c.String(PassphraseFlag.Name), + ) +} + +func getBLSPrivateKey(c *cli.Context) (*eigensdkbls.KeyPair, error) { + return eigensdkbls.NewKeyPairFromString(c.String(BlsPrivateKeyFlag.Name)) +} + +func getOperatorAndAliasKeys(c *cli.Context) (*ecdsa.PrivateKey, *ecdsa.PrivateKey, error) { + ecdsaOperatorPair, err := eigensdkecdsa.ReadKey(filepath.Join(c.String(KeyStorePathFlag.Name), "ecdsaEncryptedWallet.json"), c.String(PassphraseFlag.Name)) + if err != nil { + utils.Fatalf("Failed to read ecdsaEncryptedWallet.json file %v", err) + } + + ecdsaAliasPair, err := eigensdkecdsa.ReadKey(filepath.Join(c.String(KeyStorePathFlag.Name), "ecdsaAliasedEncryptedWallet.json"), c.String(PassphraseFlag.Name)) + if err != nil { + utils.Fatalf("Failed to read ecdsaAliasedEncryptedWallet.json file %v", err) + } + + return ecdsaOperatorPair, ecdsaAliasPair, nil +} diff --git a/contracts/abi/EOConfig.json b/contracts/abi/EOConfig.json new file mode 100644 index 0000000..9cb960d --- /dev/null +++ b/contracts/abi/EOConfig.json @@ -0,0 +1,864 @@ +[ + { + "type": "receive", + "stateMutability": "payable" + }, + { + "type": "function", + "name": "addSource", + "inputs": [ + { + "name": "name", + "type": "bytes24", + "internalType": "bytes24" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "addSources", + "inputs": [ + { + "name": "names", + "type": "bytes24[]", + "internalType": "bytes24[]" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "addSymbol", + "inputs": [ + { + "name": "name", + "type": "bytes8", + "internalType": "bytes8" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "addSymbols", + "inputs": [ + { + "name": "names", + "type": "bytes8[]", + "internalType": "bytes8[]" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "aggregator", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IEOAggregator" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "aliasToOperator", + "inputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "assignAlias", + "inputs": [ + { + "name": "operator", + "type": "address", + "internalType": "address" + }, + { + "name": "operatorAlias", + "type": "address", + "internalType": "address" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "chainManager", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "changeAlias", + "inputs": [ + { + "name": "operator", + "type": "address", + "internalType": "address" + }, + { + "name": "newAlias", + "type": "address", + "internalType": "address" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "declareAlias", + "inputs": [ + { + "name": "operatorAlias", + "type": "address", + "internalType": "address" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "evmSourceConfig", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getSourceSymbolId", + "inputs": [ + { + "name": "source", + "type": "uint16", + "internalType": "uint16" + }, + { + "name": "symbol", + "type": "uint16", + "internalType": "uint16" + } + ], + "outputs": [ + { + "name": "", + "type": "string", + "internalType": "string" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getSourceSymbols", + "inputs": [ + { + "name": "id", + "type": "uint16", + "internalType": "uint16" + } + ], + "outputs": [ + { + "name": "", + "type": "uint16[]", + "internalType": "uint16[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getSymbolSources", + "inputs": [ + { + "name": "id", + "type": "uint16", + "internalType": "uint16" + } + ], + "outputs": [ + { + "name": "", + "type": "uint16[]", + "internalType": "uint16[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "initialize", + "inputs": [], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "isIdAllowed", + "inputs": [ + { + "name": "", + "type": "bytes4", + "internalType": "bytes4" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "notify", + "inputs": [], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "onStateReceive", + "inputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "sender", + "type": "address", + "internalType": "address" + }, + { + "name": "data", + "type": "bytes", + "internalType": "bytes" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "operatorToAlias", + "inputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "operatorToRegistrationData", + "inputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "bytes", + "internalType": "bytes" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "owner", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "packPair", + "inputs": [ + { + "name": "source", + "type": "uint16", + "internalType": "uint16" + }, + { + "name": "symbol", + "type": "uint16", + "internalType": "uint16" + } + ], + "outputs": [ + { + "name": "id", + "type": "bytes4", + "internalType": "bytes4" + } + ], + "stateMutability": "pure" + }, + { + "type": "function", + "name": "removeSource", + "inputs": [ + { + "name": "id", + "type": "uint16", + "internalType": "uint16" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "removeSymbol", + "inputs": [ + { + "name": "id", + "type": "uint16", + "internalType": "uint16" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "renounceOwnership", + "inputs": [], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "setAggregator", + "inputs": [ + { + "name": "_aggregator", + "type": "address", + "internalType": "address" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "setChainManager", + "inputs": [ + { + "name": "_chainManager", + "type": "address", + "internalType": "address" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "setEvmSourceConfig", + "inputs": [ + { + "name": "_evmSourceConfig", + "type": "address", + "internalType": "address" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "setSourceSymbolIds", + "inputs": [ + { + "name": "source", + "type": "uint16", + "internalType": "uint16" + }, + { + "name": "symbols", + "type": "uint16[]", + "internalType": "uint16[]" + }, + { + "name": "names", + "type": "string[]", + "internalType": "string[]" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "sourceById", + "inputs": [ + { + "name": "", + "type": "uint16", + "internalType": "uint16" + } + ], + "outputs": [ + { + "name": "name", + "type": "bytes24", + "internalType": "bytes24" + }, + { + "name": "id", + "type": "uint16", + "internalType": "uint16" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "sourceId", + "inputs": [ + { + "name": "", + "type": "bytes24", + "internalType": "bytes24" + } + ], + "outputs": [ + { + "name": "", + "type": "uint16", + "internalType": "uint16" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "sourceIds", + "inputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "uint16", + "internalType": "uint16" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "sourceIdsLength", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint16", + "internalType": "uint16" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "sourceSymbolOverrides", + "inputs": [ + { + "name": "", + "type": "uint16", + "internalType": "uint16" + }, + { + "name": "", + "type": "uint16", + "internalType": "uint16" + } + ], + "outputs": [ + { + "name": "", + "type": "string", + "internalType": "string" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "subscribe", + "inputs": [ + { + "name": "listener", + "type": "address", + "internalType": "address" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "symbolById", + "inputs": [ + { + "name": "", + "type": "uint16", + "internalType": "uint16" + } + ], + "outputs": [ + { + "name": "name", + "type": "bytes8", + "internalType": "bytes8" + }, + { + "name": "id", + "type": "uint16", + "internalType": "uint16" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "symbolId", + "inputs": [ + { + "name": "", + "type": "bytes8", + "internalType": "bytes8" + } + ], + "outputs": [ + { + "name": "", + "type": "uint16", + "internalType": "uint16" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "symbolIds", + "inputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "uint16", + "internalType": "uint16" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "symbolIdsLength", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint16", + "internalType": "uint16" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "transferOwnership", + "inputs": [ + { + "name": "newOwner", + "type": "address", + "internalType": "address" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "unsubscribe", + "inputs": [ + { + "name": "listener", + "type": "address", + "internalType": "address" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "updateSource", + "inputs": [ + { + "name": "_sourceId", + "type": "uint16", + "internalType": "uint16" + }, + { + "name": "name", + "type": "bytes24", + "internalType": "bytes24" + }, + { + "name": "_symbols", + "type": "uint16[]", + "internalType": "uint16[]" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "updateSymbol", + "inputs": [ + { + "name": "_symbolId", + "type": "uint16", + "internalType": "uint16" + }, + { + "name": "name", + "type": "bytes8", + "internalType": "bytes8" + }, + { + "name": "_sources", + "type": "uint16[]", + "internalType": "uint16[]" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "event", + "name": "Initialized", + "inputs": [ + { + "name": "version", + "type": "uint8", + "indexed": false, + "internalType": "uint8" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "OnConfigChange", + "inputs": [], + "anonymous": false + }, + { + "type": "event", + "name": "OnSourceAdded", + "inputs": [ + { + "name": "id", + "type": "uint16", + "indexed": false, + "internalType": "uint16" + }, + { + "name": "name", + "type": "bytes24", + "indexed": false, + "internalType": "bytes24" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "OnSourceRemoved", + "inputs": [ + { + "name": "id", + "type": "uint16", + "indexed": false, + "internalType": "uint16" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "OnSourceUpdated", + "inputs": [ + { + "name": "id", + "type": "uint16", + "indexed": false, + "internalType": "uint16" + }, + { + "name": "name", + "type": "bytes24", + "indexed": false, + "internalType": "bytes24" + }, + { + "name": "symbols", + "type": "uint16[]", + "indexed": false, + "internalType": "uint16[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "OnSymbolAdded", + "inputs": [ + { + "name": "id", + "type": "uint16", + "indexed": false, + "internalType": "uint16" + }, + { + "name": "name", + "type": "bytes8", + "indexed": false, + "internalType": "bytes8" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "OnSymbolRemoved", + "inputs": [ + { + "name": "id", + "type": "uint16", + "indexed": false, + "internalType": "uint16" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "OnSymbolUpdated", + "inputs": [ + { + "name": "id", + "type": "uint16", + "indexed": false, + "internalType": "uint16" + }, + { + "name": "name", + "type": "bytes8", + "indexed": false, + "internalType": "bytes8" + }, + { + "name": "sources", + "type": "uint16[]", + "indexed": false, + "internalType": "uint16[]" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "OwnershipTransferred", + "inputs": [ + { + "name": "previousOwner", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "newOwner", + "type": "address", + "indexed": true, + "internalType": "address" + } + ], + "anonymous": false + } +] diff --git a/contracts/abi/EORegistryCoordinator.json b/contracts/abi/EORegistryCoordinator.json new file mode 100644 index 0000000..e864db8 --- /dev/null +++ b/contracts/abi/EORegistryCoordinator.json @@ -0,0 +1,2093 @@ +[ + { + "type": "constructor", + "inputs": [ + { + "name": "params", + "type": "tuple", + "internalType": "struct IRegistryCoordinatorTypes.RegistryCoordinatorParams", + "components": [ + { + "name": "serviceManager", + "type": "address", + "internalType": "contract IServiceManager" + }, + { + "name": "slashingParams", + "type": "tuple", + "internalType": "struct IRegistryCoordinatorTypes.SlashingRegistryParams", + "components": [ + { + "name": "stakeRegistry", + "type": "address", + "internalType": "contract IStakeRegistry" + }, + { + "name": "blsApkRegistry", + "type": "address", + "internalType": "contract IBLSApkRegistry" + }, + { + "name": "indexRegistry", + "type": "address", + "internalType": "contract IIndexRegistry" + }, + { + "name": "socketRegistry", + "type": "address", + "internalType": "contract ISocketRegistry" + }, + { + "name": "allocationManager", + "type": "address", + "internalType": "contract IAllocationManager" + }, + { + "name": "pauserRegistry", + "type": "address", + "internalType": "contract IPauserRegistry" + } + ] + } + ] + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "OPERATOR_CHURN_APPROVAL_TYPEHASH", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bytes32", + "internalType": "bytes32" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "PUBKEY_REGISTRATION_TYPEHASH", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bytes32", + "internalType": "bytes32" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "allocationManager", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IAllocationManager" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "avs", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "blsApkRegistry", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IBLSApkRegistry" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "calculateOperatorChurnApprovalDigestHash", + "inputs": [ + { + "name": "registeringOperator", + "type": "address", + "internalType": "address" + }, + { + "name": "registeringOperatorId", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "operatorKickParams", + "type": "tuple[]", + "internalType": "struct ISlashingRegistryCoordinatorTypes.OperatorKickParam[]", + "components": [ + { + "name": "quorumNumber", + "type": "uint8", + "internalType": "uint8" + }, + { + "name": "operator", + "type": "address", + "internalType": "address" + } + ] + }, + { + "name": "salt", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "expiry", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "bytes32", + "internalType": "bytes32" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "calculatePubkeyRegistrationMessageHash", + "inputs": [ + { + "name": "operator", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "bytes32", + "internalType": "bytes32" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "chainManager", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IEOChainManager" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "churnApprover", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "createSlashableStakeQuorum", + "inputs": [ + { + "name": "operatorSetParams", + "type": "tuple", + "internalType": "struct ISlashingRegistryCoordinatorTypes.OperatorSetParam", + "components": [ + { + "name": "maxOperatorCount", + "type": "uint32", + "internalType": "uint32" + }, + { + "name": "kickBIPsOfOperatorStake", + "type": "uint16", + "internalType": "uint16" + }, + { + "name": "kickBIPsOfTotalStake", + "type": "uint16", + "internalType": "uint16" + } + ] + }, + { + "name": "minimumStake", + "type": "uint96", + "internalType": "uint96" + }, + { + "name": "strategyParams", + "type": "tuple[]", + "internalType": "struct IStakeRegistryTypes.StrategyParams[]", + "components": [ + { + "name": "strategy", + "type": "address", + "internalType": "contract IStrategy" + }, + { + "name": "multiplier", + "type": "uint96", + "internalType": "uint96" + } + ] + }, + { + "name": "lookAheadPeriod", + "type": "uint32", + "internalType": "uint32" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "createTotalDelegatedStakeQuorum", + "inputs": [ + { + "name": "operatorSetParams", + "type": "tuple", + "internalType": "struct ISlashingRegistryCoordinatorTypes.OperatorSetParam", + "components": [ + { + "name": "maxOperatorCount", + "type": "uint32", + "internalType": "uint32" + }, + { + "name": "kickBIPsOfOperatorStake", + "type": "uint16", + "internalType": "uint16" + }, + { + "name": "kickBIPsOfTotalStake", + "type": "uint16", + "internalType": "uint16" + } + ] + }, + { + "name": "minimumStake", + "type": "uint96", + "internalType": "uint96" + }, + { + "name": "strategyParams", + "type": "tuple[]", + "internalType": "struct IStakeRegistryTypes.StrategyParams[]", + "components": [ + { + "name": "strategy", + "type": "address", + "internalType": "contract IStrategy" + }, + { + "name": "multiplier", + "type": "uint96", + "internalType": "uint96" + } + ] + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "deregisterOperator", + "inputs": [ + { + "name": "operator", + "type": "address", + "internalType": "address" + }, + { + "name": "avs", + "type": "address", + "internalType": "address" + }, + { + "name": "operatorSetIds", + "type": "uint32[]", + "internalType": "uint32[]" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "deregisterOperator", + "inputs": [ + { + "name": "quorumNumbers", + "type": "bytes", + "internalType": "bytes" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "disableM2QuorumRegistration", + "inputs": [], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "domainSeparator", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bytes32", + "internalType": "bytes32" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "eip712Domain", + "inputs": [], + "outputs": [ + { + "name": "fields", + "type": "bytes1", + "internalType": "bytes1" + }, + { + "name": "name", + "type": "string", + "internalType": "string" + }, + { + "name": "version", + "type": "string", + "internalType": "string" + }, + { + "name": "chainId", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "verifyingContract", + "type": "address", + "internalType": "address" + }, + { + "name": "salt", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "extensions", + "type": "uint256[]", + "internalType": "uint256[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "ejectOperator", + "inputs": [ + { + "name": "operator", + "type": "address", + "internalType": "address" + }, + { + "name": "quorumNumbers", + "type": "bytes", + "internalType": "bytes" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "ejectionCooldown", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "ejector", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getCurrentQuorumBitmap", + "inputs": [ + { + "name": "operatorId", + "type": "bytes32", + "internalType": "bytes32" + } + ], + "outputs": [ + { + "name": "", + "type": "uint192", + "internalType": "uint192" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getOperator", + "inputs": [ + { + "name": "operator", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "tuple", + "internalType": "struct ISlashingRegistryCoordinatorTypes.OperatorInfo", + "components": [ + { + "name": "operatorId", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "status", + "type": "uint8", + "internalType": "enum ISlashingRegistryCoordinatorTypes.OperatorStatus" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getOperatorFromId", + "inputs": [ + { + "name": "operatorId", + "type": "bytes32", + "internalType": "bytes32" + } + ], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getOperatorId", + "inputs": [ + { + "name": "operator", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "bytes32", + "internalType": "bytes32" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getOperatorSetParams", + "inputs": [ + { + "name": "quorumNumber", + "type": "uint8", + "internalType": "uint8" + } + ], + "outputs": [ + { + "name": "", + "type": "tuple", + "internalType": "struct ISlashingRegistryCoordinatorTypes.OperatorSetParam", + "components": [ + { + "name": "maxOperatorCount", + "type": "uint32", + "internalType": "uint32" + }, + { + "name": "kickBIPsOfOperatorStake", + "type": "uint16", + "internalType": "uint16" + }, + { + "name": "kickBIPsOfTotalStake", + "type": "uint16", + "internalType": "uint16" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getOperatorStatus", + "inputs": [ + { + "name": "operator", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "uint8", + "internalType": "enum ISlashingRegistryCoordinatorTypes.OperatorStatus" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getQuorumBitmapAtBlockNumberByIndex", + "inputs": [ + { + "name": "operatorId", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "blockNumber", + "type": "uint32", + "internalType": "uint32" + }, + { + "name": "index", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "uint192", + "internalType": "uint192" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getQuorumBitmapHistoryLength", + "inputs": [ + { + "name": "operatorId", + "type": "bytes32", + "internalType": "bytes32" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getQuorumBitmapIndicesAtBlockNumber", + "inputs": [ + { + "name": "blockNumber", + "type": "uint32", + "internalType": "uint32" + }, + { + "name": "operatorIds", + "type": "bytes32[]", + "internalType": "bytes32[]" + } + ], + "outputs": [ + { + "name": "", + "type": "uint32[]", + "internalType": "uint32[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getQuorumBitmapUpdateByIndex", + "inputs": [ + { + "name": "operatorId", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "index", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "tuple", + "internalType": "struct ISlashingRegistryCoordinatorTypes.QuorumBitmapUpdate", + "components": [ + { + "name": "updateBlockNumber", + "type": "uint32", + "internalType": "uint32" + }, + { + "name": "nextUpdateBlockNumber", + "type": "uint32", + "internalType": "uint32" + }, + { + "name": "quorumBitmap", + "type": "uint192", + "internalType": "uint192" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "indexRegistry", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IIndexRegistry" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "initialize", + "inputs": [ + { + "name": "initialOwner", + "type": "address", + "internalType": "address" + }, + { + "name": "churnApprover", + "type": "address", + "internalType": "address" + }, + { + "name": "ejector", + "type": "address", + "internalType": "address" + }, + { + "name": "initialPausedStatus", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "avs", + "type": "address", + "internalType": "address" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "isChurnApproverSaltUsed", + "inputs": [ + { + "name": "", + "type": "bytes32", + "internalType": "bytes32" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "isM2Quorum", + "inputs": [ + { + "name": "quorumNumber", + "type": "uint8", + "internalType": "uint8" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "isM2QuorumRegistrationDisabled", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "lastEjectionTimestamp", + "inputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "m2QuorumBitmap", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "operatorSetsEnabled", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "owner", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "pause", + "inputs": [ + { + "name": "newPausedStatus", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "pauseAll", + "inputs": [], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "paused", + "inputs": [ + { + "name": "index", + "type": "uint8", + "internalType": "uint8" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "paused", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "pauserRegistry", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IPauserRegistry" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "pubkeyRegistrationMessageHash", + "inputs": [ + { + "name": "operator", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "tuple", + "internalType": "struct BN254.G1Point", + "components": [ + { + "name": "X", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "Y", + "type": "uint256", + "internalType": "uint256" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "quorumCount", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint8", + "internalType": "uint8" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "quorumUpdateBlockNumber", + "inputs": [ + { + "name": "", + "type": "uint8", + "internalType": "uint8" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "registerOperator", + "inputs": [ + { + "name": "quorumNumbers", + "type": "bytes", + "internalType": "bytes" + }, + { + "name": "socket", + "type": "string", + "internalType": "string" + }, + { + "name": "params", + "type": "tuple", + "internalType": "struct IBLSApkRegistryTypes.PubkeyRegistrationParams", + "components": [ + { + "name": "pubkeyRegistrationSignature", + "type": "tuple", + "internalType": "struct BN254.G1Point", + "components": [ + { + "name": "X", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "Y", + "type": "uint256", + "internalType": "uint256" + } + ] + }, + { + "name": "pubkeyG1", + "type": "tuple", + "internalType": "struct BN254.G1Point", + "components": [ + { + "name": "X", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "Y", + "type": "uint256", + "internalType": "uint256" + } + ] + }, + { + "name": "pubkeyG2", + "type": "tuple", + "internalType": "struct BN254.G2Point", + "components": [ + { + "name": "X", + "type": "uint256[2]", + "internalType": "uint256[2]" + }, + { + "name": "Y", + "type": "uint256[2]", + "internalType": "uint256[2]" + } + ] + } + ] + }, + { + "name": "operatorSignature", + "type": "tuple", + "internalType": "struct ISignatureUtilsMixinTypes.SignatureWithSaltAndExpiry", + "components": [ + { + "name": "signature", + "type": "bytes", + "internalType": "bytes" + }, + { + "name": "salt", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "expiry", + "type": "uint256", + "internalType": "uint256" + } + ] + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "registerOperator", + "inputs": [ + { + "name": "operator", + "type": "address", + "internalType": "address" + }, + { + "name": "avs", + "type": "address", + "internalType": "address" + }, + { + "name": "operatorSetIds", + "type": "uint32[]", + "internalType": "uint32[]" + }, + { + "name": "data", + "type": "bytes", + "internalType": "bytes" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "registerOperatorWithChurn", + "inputs": [ + { + "name": "quorumNumbers", + "type": "bytes", + "internalType": "bytes" + }, + { + "name": "socket", + "type": "string", + "internalType": "string" + }, + { + "name": "params", + "type": "tuple", + "internalType": "struct IBLSApkRegistryTypes.PubkeyRegistrationParams", + "components": [ + { + "name": "pubkeyRegistrationSignature", + "type": "tuple", + "internalType": "struct BN254.G1Point", + "components": [ + { + "name": "X", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "Y", + "type": "uint256", + "internalType": "uint256" + } + ] + }, + { + "name": "pubkeyG1", + "type": "tuple", + "internalType": "struct BN254.G1Point", + "components": [ + { + "name": "X", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "Y", + "type": "uint256", + "internalType": "uint256" + } + ] + }, + { + "name": "pubkeyG2", + "type": "tuple", + "internalType": "struct BN254.G2Point", + "components": [ + { + "name": "X", + "type": "uint256[2]", + "internalType": "uint256[2]" + }, + { + "name": "Y", + "type": "uint256[2]", + "internalType": "uint256[2]" + } + ] + } + ] + }, + { + "name": "operatorKickParams", + "type": "tuple[]", + "internalType": "struct ISlashingRegistryCoordinatorTypes.OperatorKickParam[]", + "components": [ + { + "name": "quorumNumber", + "type": "uint8", + "internalType": "uint8" + }, + { + "name": "operator", + "type": "address", + "internalType": "address" + } + ] + }, + { + "name": "churnApproverSignature", + "type": "tuple", + "internalType": "struct ISignatureUtilsMixinTypes.SignatureWithSaltAndExpiry", + "components": [ + { + "name": "signature", + "type": "bytes", + "internalType": "bytes" + }, + { + "name": "salt", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "expiry", + "type": "uint256", + "internalType": "uint256" + } + ] + }, + { + "name": "operatorSignature", + "type": "tuple", + "internalType": "struct ISignatureUtilsMixinTypes.SignatureWithSaltAndExpiry", + "components": [ + { + "name": "signature", + "type": "bytes", + "internalType": "bytes" + }, + { + "name": "salt", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "expiry", + "type": "uint256", + "internalType": "uint256" + } + ] + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "renounceOwnership", + "inputs": [], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "serviceManager", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IServiceManager" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "setAVS", + "inputs": [ + { + "name": "_avs", + "type": "address", + "internalType": "address" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "setChainManager", + "inputs": [ + { + "name": "newChainManager", + "type": "address", + "internalType": "contract IEOChainManager" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "setChurnApprover", + "inputs": [ + { + "name": "_churnApprover", + "type": "address", + "internalType": "address" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "setEjectionCooldown", + "inputs": [ + { + "name": "_ejectionCooldown", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "setEjector", + "inputs": [ + { + "name": "_ejector", + "type": "address", + "internalType": "address" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "setOperatorSetParams", + "inputs": [ + { + "name": "quorumNumber", + "type": "uint8", + "internalType": "uint8" + }, + { + "name": "operatorSetParams", + "type": "tuple", + "internalType": "struct ISlashingRegistryCoordinatorTypes.OperatorSetParam", + "components": [ + { + "name": "maxOperatorCount", + "type": "uint32", + "internalType": "uint32" + }, + { + "name": "kickBIPsOfOperatorStake", + "type": "uint16", + "internalType": "uint16" + }, + { + "name": "kickBIPsOfTotalStake", + "type": "uint16", + "internalType": "uint16" + } + ] + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "socketRegistry", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract ISocketRegistry" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "stakeRegistry", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IStakeRegistry" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "supportsAVS", + "inputs": [ + { + "name": "_avs", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "bool", + "internalType": "bool" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "transferOwnership", + "inputs": [ + { + "name": "newOwner", + "type": "address", + "internalType": "address" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "unpause", + "inputs": [ + { + "name": "newPausedStatus", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "updateOperators", + "inputs": [ + { + "name": "operators", + "type": "address[]", + "internalType": "address[]" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "updateOperatorsForQuorum", + "inputs": [ + { + "name": "operatorsPerQuorum", + "type": "address[][]", + "internalType": "address[][]" + }, + { + "name": "quorumNumbers", + "type": "bytes", + "internalType": "bytes" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "updateSocket", + "inputs": [ + { + "name": "socket", + "type": "string", + "internalType": "string" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "version", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "string", + "internalType": "string" + } + ], + "stateMutability": "view" + }, + { + "type": "event", + "name": "AVSUpdated", + "inputs": [ + { + "name": "prevAVS", + "type": "address", + "indexed": false, + "internalType": "address" + }, + { + "name": "newAVS", + "type": "address", + "indexed": false, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "ChainManagerUpdated", + "inputs": [ + { + "name": "prevChainManager", + "type": "address", + "indexed": false, + "internalType": "address" + }, + { + "name": "newChainManager", + "type": "address", + "indexed": false, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "ChurnApproverUpdated", + "inputs": [ + { + "name": "prevChurnApprover", + "type": "address", + "indexed": false, + "internalType": "address" + }, + { + "name": "newChurnApprover", + "type": "address", + "indexed": false, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "EIP712DomainChanged", + "inputs": [], + "anonymous": false + }, + { + "type": "event", + "name": "EjectionCooldownUpdated", + "inputs": [ + { + "name": "prevEjectionCooldown", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + }, + { + "name": "newEjectionCooldown", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "EjectorUpdated", + "inputs": [ + { + "name": "prevEjector", + "type": "address", + "indexed": false, + "internalType": "address" + }, + { + "name": "newEjector", + "type": "address", + "indexed": false, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "Initialized", + "inputs": [ + { + "name": "version", + "type": "uint8", + "indexed": false, + "internalType": "uint8" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "M2QuorumRegistrationDisabled", + "inputs": [], + "anonymous": false + }, + { + "type": "event", + "name": "OperatorDeregistered", + "inputs": [ + { + "name": "operator", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "operatorId", + "type": "bytes32", + "indexed": true, + "internalType": "bytes32" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "OperatorRegistered", + "inputs": [ + { + "name": "operator", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "operatorId", + "type": "bytes32", + "indexed": true, + "internalType": "bytes32" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "OperatorSetParamsUpdated", + "inputs": [ + { + "name": "quorumNumber", + "type": "uint8", + "indexed": true, + "internalType": "uint8" + }, + { + "name": "operatorSetParams", + "type": "tuple", + "indexed": false, + "internalType": "struct ISlashingRegistryCoordinatorTypes.OperatorSetParam", + "components": [ + { + "name": "maxOperatorCount", + "type": "uint32", + "internalType": "uint32" + }, + { + "name": "kickBIPsOfOperatorStake", + "type": "uint16", + "internalType": "uint16" + }, + { + "name": "kickBIPsOfTotalStake", + "type": "uint16", + "internalType": "uint16" + } + ] + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "OperatorSetsEnabled", + "inputs": [], + "anonymous": false + }, + { + "type": "event", + "name": "OperatorSocketUpdate", + "inputs": [ + { + "name": "operatorId", + "type": "bytes32", + "indexed": true, + "internalType": "bytes32" + }, + { + "name": "socket", + "type": "string", + "indexed": false, + "internalType": "string" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "OwnershipTransferred", + "inputs": [ + { + "name": "previousOwner", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "newOwner", + "type": "address", + "indexed": true, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "Paused", + "inputs": [ + { + "name": "account", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "newPausedStatus", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "QuorumBlockNumberUpdated", + "inputs": [ + { + "name": "quorumNumber", + "type": "uint8", + "indexed": true, + "internalType": "uint8" + }, + { + "name": "blocknumber", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "QuorumCreated", + "inputs": [ + { + "name": "quorumNumber", + "type": "uint8", + "indexed": true, + "internalType": "uint8" + }, + { + "name": "operatorSetParams", + "type": "tuple", + "indexed": false, + "internalType": "struct ISlashingRegistryCoordinatorTypes.OperatorSetParam", + "components": [ + { + "name": "maxOperatorCount", + "type": "uint32", + "internalType": "uint32" + }, + { + "name": "kickBIPsOfOperatorStake", + "type": "uint16", + "internalType": "uint16" + }, + { + "name": "kickBIPsOfTotalStake", + "type": "uint16", + "internalType": "uint16" + } + ] + }, + { + "name": "minimumStake", + "type": "uint96", + "indexed": false, + "internalType": "uint96" + }, + { + "name": "strategyParams", + "type": "tuple[]", + "indexed": false, + "internalType": "struct IStakeRegistryTypes.StrategyParams[]", + "components": [ + { + "name": "strategy", + "type": "address", + "internalType": "contract IStrategy" + }, + { + "name": "multiplier", + "type": "uint96", + "internalType": "uint96" + } + ] + }, + { + "name": "stakeType", + "type": "uint8", + "indexed": false, + "internalType": "enum IStakeRegistryTypes.StakeType" + }, + { + "name": "lookAheadPeriod", + "type": "uint32", + "indexed": false, + "internalType": "uint32" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "Unpaused", + "inputs": [ + { + "name": "account", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "newPausedStatus", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "error", + "name": "AlreadyRegisteredForQuorums", + "inputs": [] + }, + { + "type": "error", + "name": "BitmapCannotBeZero", + "inputs": [] + }, + { + "type": "error", + "name": "BitmapEmpty", + "inputs": [] + }, + { + "type": "error", + "name": "BitmapValueTooLarge", + "inputs": [] + }, + { + "type": "error", + "name": "BytesArrayLengthTooLong", + "inputs": [] + }, + { + "type": "error", + "name": "BytesArrayNotOrdered", + "inputs": [] + }, + { + "type": "error", + "name": "CannotChurnSelf", + "inputs": [] + }, + { + "type": "error", + "name": "CannotKickOperatorAboveThreshold", + "inputs": [] + }, + { + "type": "error", + "name": "CannotReregisterYet", + "inputs": [] + }, + { + "type": "error", + "name": "ChurnApproverSaltUsed", + "inputs": [] + }, + { + "type": "error", + "name": "CurrentlyPaused", + "inputs": [] + }, + { + "type": "error", + "name": "ExpModFailed", + "inputs": [] + }, + { + "type": "error", + "name": "InputAddressZero", + "inputs": [] + }, + { + "type": "error", + "name": "InputLengthMismatch", + "inputs": [] + }, + { + "type": "error", + "name": "InsufficientStakeForChurn", + "inputs": [] + }, + { + "type": "error", + "name": "InvalidAVS", + "inputs": [] + }, + { + "type": "error", + "name": "InvalidNewPausedStatus", + "inputs": [] + }, + { + "type": "error", + "name": "InvalidRegistrationType", + "inputs": [] + }, + { + "type": "error", + "name": "InvalidSignature", + "inputs": [] + }, + { + "type": "error", + "name": "LookAheadPeriodTooLong", + "inputs": [] + }, + { + "type": "error", + "name": "M2QuorumRegistrationIsDisabled", + "inputs": [] + }, + { + "type": "error", + "name": "MaxOperatorCountReached", + "inputs": [] + }, + { + "type": "error", + "name": "MaxQuorumsReached", + "inputs": [] + }, + { + "type": "error", + "name": "NotRegistered", + "inputs": [] + }, + { + "type": "error", + "name": "NotRegisteredForQuorum", + "inputs": [] + }, + { + "type": "error", + "name": "NotSorted", + "inputs": [] + }, + { + "type": "error", + "name": "OnlyAllocationManager", + "inputs": [] + }, + { + "type": "error", + "name": "OnlyEjector", + "inputs": [] + }, + { + "type": "error", + "name": "OnlyM2QuorumsAllowed", + "inputs": [] + }, + { + "type": "error", + "name": "OnlyPauser", + "inputs": [] + }, + { + "type": "error", + "name": "OnlyUnpauser", + "inputs": [] + }, + { + "type": "error", + "name": "OperatorNotRegistered", + "inputs": [] + }, + { + "type": "error", + "name": "OperatorNotRegisteredForQuorum", + "inputs": [] + }, + { + "type": "error", + "name": "OperatorSetQuorum", + "inputs": [] + }, + { + "type": "error", + "name": "OperatorSetsAlreadyEnabled", + "inputs": [] + }, + { + "type": "error", + "name": "OperatorSetsNotEnabled", + "inputs": [] + }, + { + "type": "error", + "name": "QuorumDoesNotExist", + "inputs": [] + }, + { + "type": "error", + "name": "QuorumOperatorCountMismatch", + "inputs": [] + }, + { + "type": "error", + "name": "SignatureExpired", + "inputs": [] + }, + { + "type": "error", + "name": "StringTooLong", + "inputs": [ + { + "name": "str", + "type": "string", + "internalType": "string" + } + ] + } +] diff --git a/contracts/abi/EOStakeRegistry.json b/contracts/abi/EOStakeRegistry.json new file mode 100644 index 0000000..6b56dea --- /dev/null +++ b/contracts/abi/EOStakeRegistry.json @@ -0,0 +1,1235 @@ +[ + { + "type": "constructor", + "inputs": [ + { + "name": "_slashingRegistryCoordinator", + "type": "address", + "internalType": "contract ISlashingRegistryCoordinator" + }, + { + "name": "_delegationManager", + "type": "address", + "internalType": "contract IDelegationManager" + }, + { + "name": "_avsDirectory", + "type": "address", + "internalType": "contract IAVSDirectory" + }, + { + "name": "_allocationManager", + "type": "address", + "internalType": "contract IAllocationManager" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "MAX_WEIGHING_FUNCTION_LENGTH", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint8", + "internalType": "uint8" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "WEIGHTING_DIVISOR", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "addStrategies", + "inputs": [ + { + "name": "quorumNumber", + "type": "uint8", + "internalType": "uint8" + }, + { + "name": "_strategyParams", + "type": "tuple[]", + "internalType": "struct IStakeRegistryTypes.StrategyParams[]", + "components": [ + { + "name": "strategy", + "type": "address", + "internalType": "contract IStrategy" + }, + { + "name": "multiplier", + "type": "uint96", + "internalType": "uint96" + } + ] + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "allocationManager", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IAllocationManager" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "avsDirectory", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IAVSDirectory" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "chainManager", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IEOChainManager" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "delegation", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IDelegationManager" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "deregisterOperator", + "inputs": [ + { + "name": "operatorId", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "quorumNumbers", + "type": "bytes", + "internalType": "bytes" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "getCurrentStake", + "inputs": [ + { + "name": "operatorId", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "quorumNumber", + "type": "uint8", + "internalType": "uint8" + } + ], + "outputs": [ + { + "name": "", + "type": "uint96", + "internalType": "uint96" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getCurrentTotalStake", + "inputs": [ + { + "name": "quorumNumber", + "type": "uint8", + "internalType": "uint8" + } + ], + "outputs": [ + { + "name": "", + "type": "uint96", + "internalType": "uint96" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getLatestStakeUpdate", + "inputs": [ + { + "name": "operatorId", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "quorumNumber", + "type": "uint8", + "internalType": "uint8" + } + ], + "outputs": [ + { + "name": "", + "type": "tuple", + "internalType": "struct IStakeRegistryTypes.StakeUpdate", + "components": [ + { + "name": "updateBlockNumber", + "type": "uint32", + "internalType": "uint32" + }, + { + "name": "nextUpdateBlockNumber", + "type": "uint32", + "internalType": "uint32" + }, + { + "name": "stake", + "type": "uint96", + "internalType": "uint96" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getStakeAtBlockNumber", + "inputs": [ + { + "name": "operatorId", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "quorumNumber", + "type": "uint8", + "internalType": "uint8" + }, + { + "name": "blockNumber", + "type": "uint32", + "internalType": "uint32" + } + ], + "outputs": [ + { + "name": "", + "type": "uint96", + "internalType": "uint96" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getStakeAtBlockNumberAndIndex", + "inputs": [ + { + "name": "quorumNumber", + "type": "uint8", + "internalType": "uint8" + }, + { + "name": "blockNumber", + "type": "uint32", + "internalType": "uint32" + }, + { + "name": "operatorId", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "index", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "uint96", + "internalType": "uint96" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getStakeHistory", + "inputs": [ + { + "name": "operatorId", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "quorumNumber", + "type": "uint8", + "internalType": "uint8" + } + ], + "outputs": [ + { + "name": "", + "type": "tuple[]", + "internalType": "struct IStakeRegistryTypes.StakeUpdate[]", + "components": [ + { + "name": "updateBlockNumber", + "type": "uint32", + "internalType": "uint32" + }, + { + "name": "nextUpdateBlockNumber", + "type": "uint32", + "internalType": "uint32" + }, + { + "name": "stake", + "type": "uint96", + "internalType": "uint96" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getStakeHistoryLength", + "inputs": [ + { + "name": "operatorId", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "quorumNumber", + "type": "uint8", + "internalType": "uint8" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getStakeUpdateAtIndex", + "inputs": [ + { + "name": "quorumNumber", + "type": "uint8", + "internalType": "uint8" + }, + { + "name": "operatorId", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "index", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "tuple", + "internalType": "struct IStakeRegistryTypes.StakeUpdate", + "components": [ + { + "name": "updateBlockNumber", + "type": "uint32", + "internalType": "uint32" + }, + { + "name": "nextUpdateBlockNumber", + "type": "uint32", + "internalType": "uint32" + }, + { + "name": "stake", + "type": "uint96", + "internalType": "uint96" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getStakeUpdateIndexAtBlockNumber", + "inputs": [ + { + "name": "operatorId", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "quorumNumber", + "type": "uint8", + "internalType": "uint8" + }, + { + "name": "blockNumber", + "type": "uint32", + "internalType": "uint32" + } + ], + "outputs": [ + { + "name": "", + "type": "uint32", + "internalType": "uint32" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getTotalStakeAtBlockNumberFromIndex", + "inputs": [ + { + "name": "quorumNumber", + "type": "uint8", + "internalType": "uint8" + }, + { + "name": "blockNumber", + "type": "uint32", + "internalType": "uint32" + }, + { + "name": "index", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "uint96", + "internalType": "uint96" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getTotalStakeHistoryLength", + "inputs": [ + { + "name": "quorumNumber", + "type": "uint8", + "internalType": "uint8" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getTotalStakeIndicesAtBlockNumber", + "inputs": [ + { + "name": "blockNumber", + "type": "uint32", + "internalType": "uint32" + }, + { + "name": "quorumNumbers", + "type": "bytes", + "internalType": "bytes" + } + ], + "outputs": [ + { + "name": "", + "type": "uint32[]", + "internalType": "uint32[]" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "getTotalStakeUpdateAtIndex", + "inputs": [ + { + "name": "quorumNumber", + "type": "uint8", + "internalType": "uint8" + }, + { + "name": "index", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "tuple", + "internalType": "struct IStakeRegistryTypes.StakeUpdate", + "components": [ + { + "name": "updateBlockNumber", + "type": "uint32", + "internalType": "uint32" + }, + { + "name": "nextUpdateBlockNumber", + "type": "uint32", + "internalType": "uint32" + }, + { + "name": "stake", + "type": "uint96", + "internalType": "uint96" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "initializeDelegatedStakeQuorum", + "inputs": [ + { + "name": "quorumNumber", + "type": "uint8", + "internalType": "uint8" + }, + { + "name": "minimumStake", + "type": "uint96", + "internalType": "uint96" + }, + { + "name": "_strategyParams", + "type": "tuple[]", + "internalType": "struct IStakeRegistryTypes.StrategyParams[]", + "components": [ + { + "name": "strategy", + "type": "address", + "internalType": "contract IStrategy" + }, + { + "name": "multiplier", + "type": "uint96", + "internalType": "uint96" + } + ] + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "initializeSlashableStakeQuorum", + "inputs": [ + { + "name": "quorumNumber", + "type": "uint8", + "internalType": "uint8" + }, + { + "name": "minimumStake", + "type": "uint96", + "internalType": "uint96" + }, + { + "name": "lookAheadPeriod", + "type": "uint32", + "internalType": "uint32" + }, + { + "name": "_strategyParams", + "type": "tuple[]", + "internalType": "struct IStakeRegistryTypes.StrategyParams[]", + "components": [ + { + "name": "strategy", + "type": "address", + "internalType": "contract IStrategy" + }, + { + "name": "multiplier", + "type": "uint96", + "internalType": "uint96" + } + ] + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "minimumStakeForQuorum", + "inputs": [ + { + "name": "", + "type": "uint8", + "internalType": "uint8" + } + ], + "outputs": [ + { + "name": "", + "type": "uint96", + "internalType": "uint96" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "modifyStrategyParams", + "inputs": [ + { + "name": "quorumNumber", + "type": "uint8", + "internalType": "uint8" + }, + { + "name": "strategyIndices", + "type": "uint256[]", + "internalType": "uint256[]" + }, + { + "name": "newMultipliers", + "type": "uint96[]", + "internalType": "uint96[]" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "registerOperator", + "inputs": [ + { + "name": "operator", + "type": "address", + "internalType": "address" + }, + { + "name": "operatorId", + "type": "bytes32", + "internalType": "bytes32" + }, + { + "name": "quorumNumbers", + "type": "bytes", + "internalType": "bytes" + } + ], + "outputs": [ + { + "name": "", + "type": "uint96[]", + "internalType": "uint96[]" + }, + { + "name": "", + "type": "uint96[]", + "internalType": "uint96[]" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "registryCoordinator", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract ISlashingRegistryCoordinator" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "removeStrategies", + "inputs": [ + { + "name": "quorumNumber", + "type": "uint8", + "internalType": "uint8" + }, + { + "name": "indicesToRemove", + "type": "uint256[]", + "internalType": "uint256[]" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "setChainManager", + "inputs": [ + { + "name": "newChainManager", + "type": "address", + "internalType": "contract IEOChainManager" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "setMinimumStakeForQuorum", + "inputs": [ + { + "name": "quorumNumber", + "type": "uint8", + "internalType": "uint8" + }, + { + "name": "minimumStake", + "type": "uint96", + "internalType": "uint96" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "setSlashableStakeLookahead", + "inputs": [ + { + "name": "quorumNumber", + "type": "uint8", + "internalType": "uint8" + }, + { + "name": "_lookAheadBlocks", + "type": "uint32", + "internalType": "uint32" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "slashableStakeLookAheadPerQuorum", + "inputs": [ + { + "name": "quorumNumber", + "type": "uint8", + "internalType": "uint8" + } + ], + "outputs": [ + { + "name": "", + "type": "uint32", + "internalType": "uint32" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "stakeTypePerQuorum", + "inputs": [ + { + "name": "quorumNumber", + "type": "uint8", + "internalType": "uint8" + } + ], + "outputs": [ + { + "name": "", + "type": "uint8", + "internalType": "enum IStakeRegistryTypes.StakeType" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "strategiesPerQuorum", + "inputs": [ + { + "name": "quorumNumber", + "type": "uint8", + "internalType": "uint8" + }, + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "contract IStrategy" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "strategyParams", + "inputs": [ + { + "name": "quorumNumber", + "type": "uint8", + "internalType": "uint8" + }, + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "strategy", + "type": "address", + "internalType": "contract IStrategy" + }, + { + "name": "multiplier", + "type": "uint96", + "internalType": "uint96" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "strategyParamsByIndex", + "inputs": [ + { + "name": "quorumNumber", + "type": "uint8", + "internalType": "uint8" + }, + { + "name": "index", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [ + { + "name": "", + "type": "tuple", + "internalType": "struct IStakeRegistryTypes.StrategyParams", + "components": [ + { + "name": "strategy", + "type": "address", + "internalType": "contract IStrategy" + }, + { + "name": "multiplier", + "type": "uint96", + "internalType": "uint96" + } + ] + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "strategyParamsLength", + "inputs": [ + { + "name": "quorumNumber", + "type": "uint8", + "internalType": "uint8" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "updateOperatorsStake", + "inputs": [ + { + "name": "operators", + "type": "address[]", + "internalType": "address[]" + }, + { + "name": "operatorIds", + "type": "bytes32[]", + "internalType": "bytes32[]" + }, + { + "name": "quorumNumber", + "type": "uint8", + "internalType": "uint8" + } + ], + "outputs": [ + { + "name": "", + "type": "bool[]", + "internalType": "bool[]" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "updateOperatorsStake", + "inputs": [ + { + "name": "operators", + "type": "address[]", + "internalType": "address[]" + }, + { + "name": "operatorIds", + "type": "bytes32[]", + "internalType": "bytes32[]" + }, + { + "name": "quorumNumber", + "type": "uint8", + "internalType": "uint8" + }, + { + "name": "operatorSetId", + "type": "uint32", + "internalType": "uint32" + } + ], + "outputs": [ + { + "name": "", + "type": "bool[]", + "internalType": "bool[]" + } + ], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "weightOfOperatorForQuorum", + "inputs": [ + { + "name": "quorumNumber", + "type": "uint8", + "internalType": "uint8" + }, + { + "name": "operator", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "uint96", + "internalType": "uint96" + } + ], + "stateMutability": "view" + }, + { + "type": "event", + "name": "LookAheadPeriodChanged", + "inputs": [ + { + "name": "oldLookAheadBlocks", + "type": "uint32", + "indexed": false, + "internalType": "uint32" + }, + { + "name": "newLookAheadBlocks", + "type": "uint32", + "indexed": false, + "internalType": "uint32" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "MinimumStakeForQuorumUpdated", + "inputs": [ + { + "name": "quorumNumber", + "type": "uint8", + "indexed": true, + "internalType": "uint8" + }, + { + "name": "minimumStake", + "type": "uint96", + "indexed": false, + "internalType": "uint96" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "OperatorStakeUpdate", + "inputs": [ + { + "name": "operatorId", + "type": "bytes32", + "indexed": true, + "internalType": "bytes32" + }, + { + "name": "quorumNumber", + "type": "uint8", + "indexed": false, + "internalType": "uint8" + }, + { + "name": "stake", + "type": "uint96", + "indexed": false, + "internalType": "uint96" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "QuorumCreated", + "inputs": [ + { + "name": "quorumNumber", + "type": "uint8", + "indexed": true, + "internalType": "uint8" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "StakeTypeSet", + "inputs": [ + { + "name": "newStakeType", + "type": "uint8", + "indexed": false, + "internalType": "enum IStakeRegistryTypes.StakeType" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "StrategyAddedToQuorum", + "inputs": [ + { + "name": "quorumNumber", + "type": "uint8", + "indexed": true, + "internalType": "uint8" + }, + { + "name": "strategy", + "type": "address", + "indexed": false, + "internalType": "contract IStrategy" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "StrategyMultiplierUpdated", + "inputs": [ + { + "name": "quorumNumber", + "type": "uint8", + "indexed": true, + "internalType": "uint8" + }, + { + "name": "strategy", + "type": "address", + "indexed": false, + "internalType": "contract IStrategy" + }, + { + "name": "multiplier", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "StrategyRemovedFromQuorum", + "inputs": [ + { + "name": "quorumNumber", + "type": "uint8", + "indexed": true, + "internalType": "uint8" + }, + { + "name": "strategy", + "type": "address", + "indexed": false, + "internalType": "contract IStrategy" + } + ], + "anonymous": false + }, + { + "type": "error", + "name": "BelowMinimumStakeRequirement", + "inputs": [] + }, + { + "type": "error", + "name": "EmptyStakeHistory", + "inputs": [] + }, + { + "type": "error", + "name": "InputArrayLengthMismatch", + "inputs": [] + }, + { + "type": "error", + "name": "InputArrayLengthZero", + "inputs": [] + }, + { + "type": "error", + "name": "InputDuplicateStrategy", + "inputs": [] + }, + { + "type": "error", + "name": "InputMultiplierZero", + "inputs": [] + }, + { + "type": "error", + "name": "InvalidBlockNumber", + "inputs": [] + }, + { + "type": "error", + "name": "LookAheadPeriodTooLong", + "inputs": [] + }, + { + "type": "error", + "name": "OnlySlashingRegistryCoordinator", + "inputs": [] + }, + { + "type": "error", + "name": "OnlySlashingRegistryCoordinatorOwner", + "inputs": [] + }, + { + "type": "error", + "name": "QuorumAlreadyExists", + "inputs": [] + }, + { + "type": "error", + "name": "QuorumDoesNotExist", + "inputs": [] + }, + { + "type": "error", + "name": "QuorumNotSlashable", + "inputs": [] + } +] diff --git a/contracts/bindings/AVSDirectory/binding.go b/contracts/bindings/AVSDirectory/binding.go deleted file mode 100644 index 167acbe..0000000 --- a/contracts/bindings/AVSDirectory/binding.go +++ /dev/null @@ -1,1870 +0,0 @@ -// Code generated - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package contractAVSDirectory - -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 -) - -// ISignatureUtilsSignatureWithSaltAndExpiry is an auto generated low-level Go binding around an user-defined struct. -type ISignatureUtilsSignatureWithSaltAndExpiry struct { - Signature []byte - Salt [32]byte - Expiry *big.Int -} - -// ContractAVSDirectoryMetaData contains all meta data concerning the ContractAVSDirectory contract. -var ContractAVSDirectoryMetaData = &bind.MetaData{ - ABI: "[{\"type\":\"constructor\",\"inputs\":[{\"name\":\"_delegation\",\"type\":\"address\",\"internalType\":\"contractIDelegationManager\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"DOMAIN_TYPEHASH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"OPERATOR_AVS_REGISTRATION_TYPEHASH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"avsOperatorStatus\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint8\",\"internalType\":\"enumIAVSDirectory.OperatorAVSRegistrationStatus\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"calculateOperatorAVSRegistrationDigestHash\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"salt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"delegation\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIDelegationManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"deregisterOperatorFromAVS\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"domainSeparator\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[{\"name\":\"initialOwner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"_pauserRegistry\",\"type\":\"address\",\"internalType\":\"contractIPauserRegistry\"},{\"name\":\"initialPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"operatorSaltIsSpent\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"owner\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pause\",\"inputs\":[{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"pauseAll\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[{\"name\":\"index\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pauserRegistry\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIPauserRegistry\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"registerOperatorToAVS\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSignature\",\"type\":\"tuple\",\"internalType\":\"structISignatureUtils.SignatureWithSaltAndExpiry\",\"components\":[{\"name\":\"signature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"salt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"renounceOwnership\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setPauserRegistry\",\"inputs\":[{\"name\":\"newPauserRegistry\",\"type\":\"address\",\"internalType\":\"contractIPauserRegistry\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"transferOwnership\",\"inputs\":[{\"name\":\"newOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"unpause\",\"inputs\":[{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"updateAVSMetadataURI\",\"inputs\":[{\"name\":\"metadataURI\",\"type\":\"string\",\"internalType\":\"string\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"AVSMetadataURIUpdated\",\"inputs\":[{\"name\":\"avs\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"metadataURI\",\"type\":\"string\",\"indexed\":false,\"internalType\":\"string\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Initialized\",\"inputs\":[{\"name\":\"version\",\"type\":\"uint8\",\"indexed\":false,\"internalType\":\"uint8\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorAVSRegistrationStatusUpdated\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"avs\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"status\",\"type\":\"uint8\",\"indexed\":false,\"internalType\":\"enumIAVSDirectory.OperatorAVSRegistrationStatus\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OwnershipTransferred\",\"inputs\":[{\"name\":\"previousOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Paused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"PauserRegistrySet\",\"inputs\":[{\"name\":\"pauserRegistry\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIPauserRegistry\"},{\"name\":\"newPauserRegistry\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIPauserRegistry\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Unpaused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false}]", - Bin: "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", -} - -// ContractAVSDirectoryABI is the input ABI used to generate the binding from. -// Deprecated: Use ContractAVSDirectoryMetaData.ABI instead. -var ContractAVSDirectoryABI = ContractAVSDirectoryMetaData.ABI - -// ContractAVSDirectoryBin is the compiled bytecode used for deploying new contracts. -// Deprecated: Use ContractAVSDirectoryMetaData.Bin instead. -var ContractAVSDirectoryBin = ContractAVSDirectoryMetaData.Bin - -// DeployContractAVSDirectory deploys a new Ethereum contract, binding an instance of ContractAVSDirectory to it. -func DeployContractAVSDirectory(auth *bind.TransactOpts, backend bind.ContractBackend, _delegation common.Address) (common.Address, *types.Transaction, *ContractAVSDirectory, error) { - parsed, err := ContractAVSDirectoryMetaData.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(ContractAVSDirectoryBin), backend, _delegation) - if err != nil { - return common.Address{}, nil, nil, err - } - return address, tx, &ContractAVSDirectory{ContractAVSDirectoryCaller: ContractAVSDirectoryCaller{contract: contract}, ContractAVSDirectoryTransactor: ContractAVSDirectoryTransactor{contract: contract}, ContractAVSDirectoryFilterer: ContractAVSDirectoryFilterer{contract: contract}}, nil -} - -// ContractAVSDirectoryMethods is an auto generated interface around an Ethereum contract. -type ContractAVSDirectoryMethods interface { - ContractAVSDirectoryCalls - ContractAVSDirectoryTransacts - ContractAVSDirectoryFilters -} - -// ContractAVSDirectoryCalls is an auto generated interface that defines the call methods available for an Ethereum contract. -type ContractAVSDirectoryCalls interface { - DOMAINTYPEHASH(opts *bind.CallOpts) ([32]byte, error) - - OPERATORAVSREGISTRATIONTYPEHASH(opts *bind.CallOpts) ([32]byte, error) - - AvsOperatorStatus(opts *bind.CallOpts, arg0 common.Address, arg1 common.Address) (uint8, error) - - CalculateOperatorAVSRegistrationDigestHash(opts *bind.CallOpts, operator common.Address, avs common.Address, salt [32]byte, expiry *big.Int) ([32]byte, error) - - Delegation(opts *bind.CallOpts) (common.Address, error) - - DomainSeparator(opts *bind.CallOpts) ([32]byte, error) - - OperatorSaltIsSpent(opts *bind.CallOpts, arg0 common.Address, arg1 [32]byte) (bool, error) - - Owner(opts *bind.CallOpts) (common.Address, error) - - Paused(opts *bind.CallOpts, index uint8) (bool, error) - - Paused0(opts *bind.CallOpts) (*big.Int, error) - - PauserRegistry(opts *bind.CallOpts) (common.Address, error) -} - -// ContractAVSDirectoryTransacts is an auto generated interface that defines the transact methods available for an Ethereum contract. -type ContractAVSDirectoryTransacts interface { - DeregisterOperatorFromAVS(opts *bind.TransactOpts, operator common.Address) (*types.Transaction, error) - - Initialize(opts *bind.TransactOpts, initialOwner common.Address, _pauserRegistry common.Address, initialPausedStatus *big.Int) (*types.Transaction, error) - - Pause(opts *bind.TransactOpts, newPausedStatus *big.Int) (*types.Transaction, error) - - PauseAll(opts *bind.TransactOpts) (*types.Transaction, error) - - RegisterOperatorToAVS(opts *bind.TransactOpts, operator common.Address, operatorSignature ISignatureUtilsSignatureWithSaltAndExpiry) (*types.Transaction, error) - - RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) - - SetPauserRegistry(opts *bind.TransactOpts, newPauserRegistry common.Address) (*types.Transaction, error) - - TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) - - Unpause(opts *bind.TransactOpts, newPausedStatus *big.Int) (*types.Transaction, error) - - UpdateAVSMetadataURI(opts *bind.TransactOpts, metadataURI string) (*types.Transaction, error) -} - -// ContractAVSDirectoryFilterer is an auto generated interface that defines the log filtering methods available for an Ethereum contract. -type ContractAVSDirectoryFilters interface { - FilterAVSMetadataURIUpdated(opts *bind.FilterOpts, avs []common.Address) (*ContractAVSDirectoryAVSMetadataURIUpdatedIterator, error) - WatchAVSMetadataURIUpdated(opts *bind.WatchOpts, sink chan<- *ContractAVSDirectoryAVSMetadataURIUpdated, avs []common.Address) (event.Subscription, error) - ParseAVSMetadataURIUpdated(log types.Log) (*ContractAVSDirectoryAVSMetadataURIUpdated, error) - - FilterInitialized(opts *bind.FilterOpts) (*ContractAVSDirectoryInitializedIterator, error) - WatchInitialized(opts *bind.WatchOpts, sink chan<- *ContractAVSDirectoryInitialized) (event.Subscription, error) - ParseInitialized(log types.Log) (*ContractAVSDirectoryInitialized, error) - - FilterOperatorAVSRegistrationStatusUpdated(opts *bind.FilterOpts, operator []common.Address, avs []common.Address) (*ContractAVSDirectoryOperatorAVSRegistrationStatusUpdatedIterator, error) - WatchOperatorAVSRegistrationStatusUpdated(opts *bind.WatchOpts, sink chan<- *ContractAVSDirectoryOperatorAVSRegistrationStatusUpdated, operator []common.Address, avs []common.Address) (event.Subscription, error) - ParseOperatorAVSRegistrationStatusUpdated(log types.Log) (*ContractAVSDirectoryOperatorAVSRegistrationStatusUpdated, error) - - FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*ContractAVSDirectoryOwnershipTransferredIterator, error) - WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *ContractAVSDirectoryOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) - ParseOwnershipTransferred(log types.Log) (*ContractAVSDirectoryOwnershipTransferred, error) - - FilterPaused(opts *bind.FilterOpts, account []common.Address) (*ContractAVSDirectoryPausedIterator, error) - WatchPaused(opts *bind.WatchOpts, sink chan<- *ContractAVSDirectoryPaused, account []common.Address) (event.Subscription, error) - ParsePaused(log types.Log) (*ContractAVSDirectoryPaused, error) - - FilterPauserRegistrySet(opts *bind.FilterOpts) (*ContractAVSDirectoryPauserRegistrySetIterator, error) - WatchPauserRegistrySet(opts *bind.WatchOpts, sink chan<- *ContractAVSDirectoryPauserRegistrySet) (event.Subscription, error) - ParsePauserRegistrySet(log types.Log) (*ContractAVSDirectoryPauserRegistrySet, error) - - FilterUnpaused(opts *bind.FilterOpts, account []common.Address) (*ContractAVSDirectoryUnpausedIterator, error) - WatchUnpaused(opts *bind.WatchOpts, sink chan<- *ContractAVSDirectoryUnpaused, account []common.Address) (event.Subscription, error) - ParseUnpaused(log types.Log) (*ContractAVSDirectoryUnpaused, error) -} - -// ContractAVSDirectory is an auto generated Go binding around an Ethereum contract. -type ContractAVSDirectory struct { - ContractAVSDirectoryCaller // Read-only binding to the contract - ContractAVSDirectoryTransactor // Write-only binding to the contract - ContractAVSDirectoryFilterer // Log filterer for contract events -} - -// ContractAVSDirectory implements the ContractAVSDirectoryMethods interface. -var _ ContractAVSDirectoryMethods = (*ContractAVSDirectory)(nil) - -// ContractAVSDirectoryCaller is an auto generated read-only Go binding around an Ethereum contract. -type ContractAVSDirectoryCaller struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// ContractAVSDirectoryCaller implements the ContractAVSDirectoryCalls interface. -var _ ContractAVSDirectoryCalls = (*ContractAVSDirectoryCaller)(nil) - -// ContractAVSDirectoryTransactor is an auto generated write-only Go binding around an Ethereum contract. -type ContractAVSDirectoryTransactor struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// ContractAVSDirectoryTransactor implements the ContractAVSDirectoryTransacts interface. -var _ ContractAVSDirectoryTransacts = (*ContractAVSDirectoryTransactor)(nil) - -// ContractAVSDirectoryFilterer is an auto generated log filtering Go binding around an Ethereum contract events. -type ContractAVSDirectoryFilterer struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// ContractAVSDirectoryFilterer implements the ContractAVSDirectoryFilters interface. -var _ ContractAVSDirectoryFilters = (*ContractAVSDirectoryFilterer)(nil) - -// ContractAVSDirectorySession is an auto generated Go binding around an Ethereum contract, -// with pre-set call and transact options. -type ContractAVSDirectorySession struct { - Contract *ContractAVSDirectory // 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 -} - -// ContractAVSDirectoryCallerSession is an auto generated read-only Go binding around an Ethereum contract, -// with pre-set call options. -type ContractAVSDirectoryCallerSession struct { - Contract *ContractAVSDirectoryCaller // Generic contract caller binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session -} - -// ContractAVSDirectoryTransactorSession is an auto generated write-only Go binding around an Ethereum contract, -// with pre-set transact options. -type ContractAVSDirectoryTransactorSession struct { - Contract *ContractAVSDirectoryTransactor // Generic contract transactor binding to set the session for - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session -} - -// ContractAVSDirectoryRaw is an auto generated low-level Go binding around an Ethereum contract. -type ContractAVSDirectoryRaw struct { - Contract *ContractAVSDirectory // Generic contract binding to access the raw methods on -} - -// ContractAVSDirectoryCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. -type ContractAVSDirectoryCallerRaw struct { - Contract *ContractAVSDirectoryCaller // Generic read-only contract binding to access the raw methods on -} - -// ContractAVSDirectoryTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. -type ContractAVSDirectoryTransactorRaw struct { - Contract *ContractAVSDirectoryTransactor // Generic write-only contract binding to access the raw methods on -} - -// NewContractAVSDirectory creates a new instance of ContractAVSDirectory, bound to a specific deployed contract. -func NewContractAVSDirectory(address common.Address, backend bind.ContractBackend) (*ContractAVSDirectory, error) { - contract, err := bindContractAVSDirectory(address, backend, backend, backend) - if err != nil { - return nil, err - } - return &ContractAVSDirectory{ContractAVSDirectoryCaller: ContractAVSDirectoryCaller{contract: contract}, ContractAVSDirectoryTransactor: ContractAVSDirectoryTransactor{contract: contract}, ContractAVSDirectoryFilterer: ContractAVSDirectoryFilterer{contract: contract}}, nil -} - -// NewContractAVSDirectoryCaller creates a new read-only instance of ContractAVSDirectory, bound to a specific deployed contract. -func NewContractAVSDirectoryCaller(address common.Address, caller bind.ContractCaller) (*ContractAVSDirectoryCaller, error) { - contract, err := bindContractAVSDirectory(address, caller, nil, nil) - if err != nil { - return nil, err - } - return &ContractAVSDirectoryCaller{contract: contract}, nil -} - -// NewContractAVSDirectoryTransactor creates a new write-only instance of ContractAVSDirectory, bound to a specific deployed contract. -func NewContractAVSDirectoryTransactor(address common.Address, transactor bind.ContractTransactor) (*ContractAVSDirectoryTransactor, error) { - contract, err := bindContractAVSDirectory(address, nil, transactor, nil) - if err != nil { - return nil, err - } - return &ContractAVSDirectoryTransactor{contract: contract}, nil -} - -// NewContractAVSDirectoryFilterer creates a new log filterer instance of ContractAVSDirectory, bound to a specific deployed contract. -func NewContractAVSDirectoryFilterer(address common.Address, filterer bind.ContractFilterer) (*ContractAVSDirectoryFilterer, error) { - contract, err := bindContractAVSDirectory(address, nil, nil, filterer) - if err != nil { - return nil, err - } - return &ContractAVSDirectoryFilterer{contract: contract}, nil -} - -// bindContractAVSDirectory binds a generic wrapper to an already deployed contract. -func bindContractAVSDirectory(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { - parsed, err := ContractAVSDirectoryMetaData.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 (_ContractAVSDirectory *ContractAVSDirectoryRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _ContractAVSDirectory.Contract.ContractAVSDirectoryCaller.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 (_ContractAVSDirectory *ContractAVSDirectoryRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _ContractAVSDirectory.Contract.ContractAVSDirectoryTransactor.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_ContractAVSDirectory *ContractAVSDirectoryRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _ContractAVSDirectory.Contract.ContractAVSDirectoryTransactor.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 (_ContractAVSDirectory *ContractAVSDirectoryCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _ContractAVSDirectory.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 (_ContractAVSDirectory *ContractAVSDirectoryTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _ContractAVSDirectory.Contract.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_ContractAVSDirectory *ContractAVSDirectoryTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _ContractAVSDirectory.Contract.contract.Transact(opts, method, params...) -} - -// DOMAINTYPEHASH is a free data retrieval call binding the contract method 0x20606b70. -// -// Solidity: function DOMAIN_TYPEHASH() view returns(bytes32) -func (_ContractAVSDirectory *ContractAVSDirectoryCaller) DOMAINTYPEHASH(opts *bind.CallOpts) ([32]byte, error) { - var out []interface{} - err := _ContractAVSDirectory.contract.Call(opts, &out, "DOMAIN_TYPEHASH") - - if err != nil { - return *new([32]byte), err - } - - out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) - - return out0, err - -} - -// DOMAINTYPEHASH is a free data retrieval call binding the contract method 0x20606b70. -// -// Solidity: function DOMAIN_TYPEHASH() view returns(bytes32) -func (_ContractAVSDirectory *ContractAVSDirectorySession) DOMAINTYPEHASH() ([32]byte, error) { - return _ContractAVSDirectory.Contract.DOMAINTYPEHASH(&_ContractAVSDirectory.CallOpts) -} - -// DOMAINTYPEHASH is a free data retrieval call binding the contract method 0x20606b70. -// -// Solidity: function DOMAIN_TYPEHASH() view returns(bytes32) -func (_ContractAVSDirectory *ContractAVSDirectoryCallerSession) DOMAINTYPEHASH() ([32]byte, error) { - return _ContractAVSDirectory.Contract.DOMAINTYPEHASH(&_ContractAVSDirectory.CallOpts) -} - -// OPERATORAVSREGISTRATIONTYPEHASH is a free data retrieval call binding the contract method 0xd79aceab. -// -// Solidity: function OPERATOR_AVS_REGISTRATION_TYPEHASH() view returns(bytes32) -func (_ContractAVSDirectory *ContractAVSDirectoryCaller) OPERATORAVSREGISTRATIONTYPEHASH(opts *bind.CallOpts) ([32]byte, error) { - var out []interface{} - err := _ContractAVSDirectory.contract.Call(opts, &out, "OPERATOR_AVS_REGISTRATION_TYPEHASH") - - if err != nil { - return *new([32]byte), err - } - - out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) - - return out0, err - -} - -// OPERATORAVSREGISTRATIONTYPEHASH is a free data retrieval call binding the contract method 0xd79aceab. -// -// Solidity: function OPERATOR_AVS_REGISTRATION_TYPEHASH() view returns(bytes32) -func (_ContractAVSDirectory *ContractAVSDirectorySession) OPERATORAVSREGISTRATIONTYPEHASH() ([32]byte, error) { - return _ContractAVSDirectory.Contract.OPERATORAVSREGISTRATIONTYPEHASH(&_ContractAVSDirectory.CallOpts) -} - -// OPERATORAVSREGISTRATIONTYPEHASH is a free data retrieval call binding the contract method 0xd79aceab. -// -// Solidity: function OPERATOR_AVS_REGISTRATION_TYPEHASH() view returns(bytes32) -func (_ContractAVSDirectory *ContractAVSDirectoryCallerSession) OPERATORAVSREGISTRATIONTYPEHASH() ([32]byte, error) { - return _ContractAVSDirectory.Contract.OPERATORAVSREGISTRATIONTYPEHASH(&_ContractAVSDirectory.CallOpts) -} - -// AvsOperatorStatus is a free data retrieval call binding the contract method 0x49075da3. -// -// Solidity: function avsOperatorStatus(address , address ) view returns(uint8) -func (_ContractAVSDirectory *ContractAVSDirectoryCaller) AvsOperatorStatus(opts *bind.CallOpts, arg0 common.Address, arg1 common.Address) (uint8, error) { - var out []interface{} - err := _ContractAVSDirectory.contract.Call(opts, &out, "avsOperatorStatus", arg0, arg1) - - if err != nil { - return *new(uint8), err - } - - out0 := *abi.ConvertType(out[0], new(uint8)).(*uint8) - - return out0, err - -} - -// AvsOperatorStatus is a free data retrieval call binding the contract method 0x49075da3. -// -// Solidity: function avsOperatorStatus(address , address ) view returns(uint8) -func (_ContractAVSDirectory *ContractAVSDirectorySession) AvsOperatorStatus(arg0 common.Address, arg1 common.Address) (uint8, error) { - return _ContractAVSDirectory.Contract.AvsOperatorStatus(&_ContractAVSDirectory.CallOpts, arg0, arg1) -} - -// AvsOperatorStatus is a free data retrieval call binding the contract method 0x49075da3. -// -// Solidity: function avsOperatorStatus(address , address ) view returns(uint8) -func (_ContractAVSDirectory *ContractAVSDirectoryCallerSession) AvsOperatorStatus(arg0 common.Address, arg1 common.Address) (uint8, error) { - return _ContractAVSDirectory.Contract.AvsOperatorStatus(&_ContractAVSDirectory.CallOpts, arg0, arg1) -} - -// CalculateOperatorAVSRegistrationDigestHash is a free data retrieval call binding the contract method 0xa1060c88. -// -// Solidity: function calculateOperatorAVSRegistrationDigestHash(address operator, address avs, bytes32 salt, uint256 expiry) view returns(bytes32) -func (_ContractAVSDirectory *ContractAVSDirectoryCaller) CalculateOperatorAVSRegistrationDigestHash(opts *bind.CallOpts, operator common.Address, avs common.Address, salt [32]byte, expiry *big.Int) ([32]byte, error) { - var out []interface{} - err := _ContractAVSDirectory.contract.Call(opts, &out, "calculateOperatorAVSRegistrationDigestHash", operator, avs, salt, expiry) - - if err != nil { - return *new([32]byte), err - } - - out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) - - return out0, err - -} - -// CalculateOperatorAVSRegistrationDigestHash is a free data retrieval call binding the contract method 0xa1060c88. -// -// Solidity: function calculateOperatorAVSRegistrationDigestHash(address operator, address avs, bytes32 salt, uint256 expiry) view returns(bytes32) -func (_ContractAVSDirectory *ContractAVSDirectorySession) CalculateOperatorAVSRegistrationDigestHash(operator common.Address, avs common.Address, salt [32]byte, expiry *big.Int) ([32]byte, error) { - return _ContractAVSDirectory.Contract.CalculateOperatorAVSRegistrationDigestHash(&_ContractAVSDirectory.CallOpts, operator, avs, salt, expiry) -} - -// CalculateOperatorAVSRegistrationDigestHash is a free data retrieval call binding the contract method 0xa1060c88. -// -// Solidity: function calculateOperatorAVSRegistrationDigestHash(address operator, address avs, bytes32 salt, uint256 expiry) view returns(bytes32) -func (_ContractAVSDirectory *ContractAVSDirectoryCallerSession) CalculateOperatorAVSRegistrationDigestHash(operator common.Address, avs common.Address, salt [32]byte, expiry *big.Int) ([32]byte, error) { - return _ContractAVSDirectory.Contract.CalculateOperatorAVSRegistrationDigestHash(&_ContractAVSDirectory.CallOpts, operator, avs, salt, expiry) -} - -// Delegation is a free data retrieval call binding the contract method 0xdf5cf723. -// -// Solidity: function delegation() view returns(address) -func (_ContractAVSDirectory *ContractAVSDirectoryCaller) Delegation(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _ContractAVSDirectory.contract.Call(opts, &out, "delegation") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// Delegation is a free data retrieval call binding the contract method 0xdf5cf723. -// -// Solidity: function delegation() view returns(address) -func (_ContractAVSDirectory *ContractAVSDirectorySession) Delegation() (common.Address, error) { - return _ContractAVSDirectory.Contract.Delegation(&_ContractAVSDirectory.CallOpts) -} - -// Delegation is a free data retrieval call binding the contract method 0xdf5cf723. -// -// Solidity: function delegation() view returns(address) -func (_ContractAVSDirectory *ContractAVSDirectoryCallerSession) Delegation() (common.Address, error) { - return _ContractAVSDirectory.Contract.Delegation(&_ContractAVSDirectory.CallOpts) -} - -// DomainSeparator is a free data retrieval call binding the contract method 0xf698da25. -// -// Solidity: function domainSeparator() view returns(bytes32) -func (_ContractAVSDirectory *ContractAVSDirectoryCaller) DomainSeparator(opts *bind.CallOpts) ([32]byte, error) { - var out []interface{} - err := _ContractAVSDirectory.contract.Call(opts, &out, "domainSeparator") - - if err != nil { - return *new([32]byte), err - } - - out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) - - return out0, err - -} - -// DomainSeparator is a free data retrieval call binding the contract method 0xf698da25. -// -// Solidity: function domainSeparator() view returns(bytes32) -func (_ContractAVSDirectory *ContractAVSDirectorySession) DomainSeparator() ([32]byte, error) { - return _ContractAVSDirectory.Contract.DomainSeparator(&_ContractAVSDirectory.CallOpts) -} - -// DomainSeparator is a free data retrieval call binding the contract method 0xf698da25. -// -// Solidity: function domainSeparator() view returns(bytes32) -func (_ContractAVSDirectory *ContractAVSDirectoryCallerSession) DomainSeparator() ([32]byte, error) { - return _ContractAVSDirectory.Contract.DomainSeparator(&_ContractAVSDirectory.CallOpts) -} - -// OperatorSaltIsSpent is a free data retrieval call binding the contract method 0x374823b5. -// -// Solidity: function operatorSaltIsSpent(address , bytes32 ) view returns(bool) -func (_ContractAVSDirectory *ContractAVSDirectoryCaller) OperatorSaltIsSpent(opts *bind.CallOpts, arg0 common.Address, arg1 [32]byte) (bool, error) { - var out []interface{} - err := _ContractAVSDirectory.contract.Call(opts, &out, "operatorSaltIsSpent", arg0, arg1) - - if err != nil { - return *new(bool), err - } - - out0 := *abi.ConvertType(out[0], new(bool)).(*bool) - - return out0, err - -} - -// OperatorSaltIsSpent is a free data retrieval call binding the contract method 0x374823b5. -// -// Solidity: function operatorSaltIsSpent(address , bytes32 ) view returns(bool) -func (_ContractAVSDirectory *ContractAVSDirectorySession) OperatorSaltIsSpent(arg0 common.Address, arg1 [32]byte) (bool, error) { - return _ContractAVSDirectory.Contract.OperatorSaltIsSpent(&_ContractAVSDirectory.CallOpts, arg0, arg1) -} - -// OperatorSaltIsSpent is a free data retrieval call binding the contract method 0x374823b5. -// -// Solidity: function operatorSaltIsSpent(address , bytes32 ) view returns(bool) -func (_ContractAVSDirectory *ContractAVSDirectoryCallerSession) OperatorSaltIsSpent(arg0 common.Address, arg1 [32]byte) (bool, error) { - return _ContractAVSDirectory.Contract.OperatorSaltIsSpent(&_ContractAVSDirectory.CallOpts, arg0, arg1) -} - -// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. -// -// Solidity: function owner() view returns(address) -func (_ContractAVSDirectory *ContractAVSDirectoryCaller) Owner(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _ContractAVSDirectory.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 (_ContractAVSDirectory *ContractAVSDirectorySession) Owner() (common.Address, error) { - return _ContractAVSDirectory.Contract.Owner(&_ContractAVSDirectory.CallOpts) -} - -// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. -// -// Solidity: function owner() view returns(address) -func (_ContractAVSDirectory *ContractAVSDirectoryCallerSession) Owner() (common.Address, error) { - return _ContractAVSDirectory.Contract.Owner(&_ContractAVSDirectory.CallOpts) -} - -// Paused is a free data retrieval call binding the contract method 0x5ac86ab7. -// -// Solidity: function paused(uint8 index) view returns(bool) -func (_ContractAVSDirectory *ContractAVSDirectoryCaller) Paused(opts *bind.CallOpts, index uint8) (bool, error) { - var out []interface{} - err := _ContractAVSDirectory.contract.Call(opts, &out, "paused", index) - - 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 0x5ac86ab7. -// -// Solidity: function paused(uint8 index) view returns(bool) -func (_ContractAVSDirectory *ContractAVSDirectorySession) Paused(index uint8) (bool, error) { - return _ContractAVSDirectory.Contract.Paused(&_ContractAVSDirectory.CallOpts, index) -} - -// Paused is a free data retrieval call binding the contract method 0x5ac86ab7. -// -// Solidity: function paused(uint8 index) view returns(bool) -func (_ContractAVSDirectory *ContractAVSDirectoryCallerSession) Paused(index uint8) (bool, error) { - return _ContractAVSDirectory.Contract.Paused(&_ContractAVSDirectory.CallOpts, index) -} - -// Paused0 is a free data retrieval call binding the contract method 0x5c975abb. -// -// Solidity: function paused() view returns(uint256) -func (_ContractAVSDirectory *ContractAVSDirectoryCaller) Paused0(opts *bind.CallOpts) (*big.Int, error) { - var out []interface{} - err := _ContractAVSDirectory.contract.Call(opts, &out, "paused0") - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// Paused0 is a free data retrieval call binding the contract method 0x5c975abb. -// -// Solidity: function paused() view returns(uint256) -func (_ContractAVSDirectory *ContractAVSDirectorySession) Paused0() (*big.Int, error) { - return _ContractAVSDirectory.Contract.Paused0(&_ContractAVSDirectory.CallOpts) -} - -// Paused0 is a free data retrieval call binding the contract method 0x5c975abb. -// -// Solidity: function paused() view returns(uint256) -func (_ContractAVSDirectory *ContractAVSDirectoryCallerSession) Paused0() (*big.Int, error) { - return _ContractAVSDirectory.Contract.Paused0(&_ContractAVSDirectory.CallOpts) -} - -// PauserRegistry is a free data retrieval call binding the contract method 0x886f1195. -// -// Solidity: function pauserRegistry() view returns(address) -func (_ContractAVSDirectory *ContractAVSDirectoryCaller) PauserRegistry(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _ContractAVSDirectory.contract.Call(opts, &out, "pauserRegistry") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// PauserRegistry is a free data retrieval call binding the contract method 0x886f1195. -// -// Solidity: function pauserRegistry() view returns(address) -func (_ContractAVSDirectory *ContractAVSDirectorySession) PauserRegistry() (common.Address, error) { - return _ContractAVSDirectory.Contract.PauserRegistry(&_ContractAVSDirectory.CallOpts) -} - -// PauserRegistry is a free data retrieval call binding the contract method 0x886f1195. -// -// Solidity: function pauserRegistry() view returns(address) -func (_ContractAVSDirectory *ContractAVSDirectoryCallerSession) PauserRegistry() (common.Address, error) { - return _ContractAVSDirectory.Contract.PauserRegistry(&_ContractAVSDirectory.CallOpts) -} - -// DeregisterOperatorFromAVS is a paid mutator transaction binding the contract method 0xa364f4da. -// -// Solidity: function deregisterOperatorFromAVS(address operator) returns() -func (_ContractAVSDirectory *ContractAVSDirectoryTransactor) DeregisterOperatorFromAVS(opts *bind.TransactOpts, operator common.Address) (*types.Transaction, error) { - return _ContractAVSDirectory.contract.Transact(opts, "deregisterOperatorFromAVS", operator) -} - -// DeregisterOperatorFromAVS is a paid mutator transaction binding the contract method 0xa364f4da. -// -// Solidity: function deregisterOperatorFromAVS(address operator) returns() -func (_ContractAVSDirectory *ContractAVSDirectorySession) DeregisterOperatorFromAVS(operator common.Address) (*types.Transaction, error) { - return _ContractAVSDirectory.Contract.DeregisterOperatorFromAVS(&_ContractAVSDirectory.TransactOpts, operator) -} - -// DeregisterOperatorFromAVS is a paid mutator transaction binding the contract method 0xa364f4da. -// -// Solidity: function deregisterOperatorFromAVS(address operator) returns() -func (_ContractAVSDirectory *ContractAVSDirectoryTransactorSession) DeregisterOperatorFromAVS(operator common.Address) (*types.Transaction, error) { - return _ContractAVSDirectory.Contract.DeregisterOperatorFromAVS(&_ContractAVSDirectory.TransactOpts, operator) -} - -// Initialize is a paid mutator transaction binding the contract method 0x1794bb3c. -// -// Solidity: function initialize(address initialOwner, address _pauserRegistry, uint256 initialPausedStatus) returns() -func (_ContractAVSDirectory *ContractAVSDirectoryTransactor) Initialize(opts *bind.TransactOpts, initialOwner common.Address, _pauserRegistry common.Address, initialPausedStatus *big.Int) (*types.Transaction, error) { - return _ContractAVSDirectory.contract.Transact(opts, "initialize", initialOwner, _pauserRegistry, initialPausedStatus) -} - -// Initialize is a paid mutator transaction binding the contract method 0x1794bb3c. -// -// Solidity: function initialize(address initialOwner, address _pauserRegistry, uint256 initialPausedStatus) returns() -func (_ContractAVSDirectory *ContractAVSDirectorySession) Initialize(initialOwner common.Address, _pauserRegistry common.Address, initialPausedStatus *big.Int) (*types.Transaction, error) { - return _ContractAVSDirectory.Contract.Initialize(&_ContractAVSDirectory.TransactOpts, initialOwner, _pauserRegistry, initialPausedStatus) -} - -// Initialize is a paid mutator transaction binding the contract method 0x1794bb3c. -// -// Solidity: function initialize(address initialOwner, address _pauserRegistry, uint256 initialPausedStatus) returns() -func (_ContractAVSDirectory *ContractAVSDirectoryTransactorSession) Initialize(initialOwner common.Address, _pauserRegistry common.Address, initialPausedStatus *big.Int) (*types.Transaction, error) { - return _ContractAVSDirectory.Contract.Initialize(&_ContractAVSDirectory.TransactOpts, initialOwner, _pauserRegistry, initialPausedStatus) -} - -// Pause is a paid mutator transaction binding the contract method 0x136439dd. -// -// Solidity: function pause(uint256 newPausedStatus) returns() -func (_ContractAVSDirectory *ContractAVSDirectoryTransactor) Pause(opts *bind.TransactOpts, newPausedStatus *big.Int) (*types.Transaction, error) { - return _ContractAVSDirectory.contract.Transact(opts, "pause", newPausedStatus) -} - -// Pause is a paid mutator transaction binding the contract method 0x136439dd. -// -// Solidity: function pause(uint256 newPausedStatus) returns() -func (_ContractAVSDirectory *ContractAVSDirectorySession) Pause(newPausedStatus *big.Int) (*types.Transaction, error) { - return _ContractAVSDirectory.Contract.Pause(&_ContractAVSDirectory.TransactOpts, newPausedStatus) -} - -// Pause is a paid mutator transaction binding the contract method 0x136439dd. -// -// Solidity: function pause(uint256 newPausedStatus) returns() -func (_ContractAVSDirectory *ContractAVSDirectoryTransactorSession) Pause(newPausedStatus *big.Int) (*types.Transaction, error) { - return _ContractAVSDirectory.Contract.Pause(&_ContractAVSDirectory.TransactOpts, newPausedStatus) -} - -// PauseAll is a paid mutator transaction binding the contract method 0x595c6a67. -// -// Solidity: function pauseAll() returns() -func (_ContractAVSDirectory *ContractAVSDirectoryTransactor) PauseAll(opts *bind.TransactOpts) (*types.Transaction, error) { - return _ContractAVSDirectory.contract.Transact(opts, "pauseAll") -} - -// PauseAll is a paid mutator transaction binding the contract method 0x595c6a67. -// -// Solidity: function pauseAll() returns() -func (_ContractAVSDirectory *ContractAVSDirectorySession) PauseAll() (*types.Transaction, error) { - return _ContractAVSDirectory.Contract.PauseAll(&_ContractAVSDirectory.TransactOpts) -} - -// PauseAll is a paid mutator transaction binding the contract method 0x595c6a67. -// -// Solidity: function pauseAll() returns() -func (_ContractAVSDirectory *ContractAVSDirectoryTransactorSession) PauseAll() (*types.Transaction, error) { - return _ContractAVSDirectory.Contract.PauseAll(&_ContractAVSDirectory.TransactOpts) -} - -// RegisterOperatorToAVS is a paid mutator transaction binding the contract method 0x9926ee7d. -// -// Solidity: function registerOperatorToAVS(address operator, (bytes,bytes32,uint256) operatorSignature) returns() -func (_ContractAVSDirectory *ContractAVSDirectoryTransactor) RegisterOperatorToAVS(opts *bind.TransactOpts, operator common.Address, operatorSignature ISignatureUtilsSignatureWithSaltAndExpiry) (*types.Transaction, error) { - return _ContractAVSDirectory.contract.Transact(opts, "registerOperatorToAVS", operator, operatorSignature) -} - -// RegisterOperatorToAVS is a paid mutator transaction binding the contract method 0x9926ee7d. -// -// Solidity: function registerOperatorToAVS(address operator, (bytes,bytes32,uint256) operatorSignature) returns() -func (_ContractAVSDirectory *ContractAVSDirectorySession) RegisterOperatorToAVS(operator common.Address, operatorSignature ISignatureUtilsSignatureWithSaltAndExpiry) (*types.Transaction, error) { - return _ContractAVSDirectory.Contract.RegisterOperatorToAVS(&_ContractAVSDirectory.TransactOpts, operator, operatorSignature) -} - -// RegisterOperatorToAVS is a paid mutator transaction binding the contract method 0x9926ee7d. -// -// Solidity: function registerOperatorToAVS(address operator, (bytes,bytes32,uint256) operatorSignature) returns() -func (_ContractAVSDirectory *ContractAVSDirectoryTransactorSession) RegisterOperatorToAVS(operator common.Address, operatorSignature ISignatureUtilsSignatureWithSaltAndExpiry) (*types.Transaction, error) { - return _ContractAVSDirectory.Contract.RegisterOperatorToAVS(&_ContractAVSDirectory.TransactOpts, operator, operatorSignature) -} - -// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. -// -// Solidity: function renounceOwnership() returns() -func (_ContractAVSDirectory *ContractAVSDirectoryTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) { - return _ContractAVSDirectory.contract.Transact(opts, "renounceOwnership") -} - -// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. -// -// Solidity: function renounceOwnership() returns() -func (_ContractAVSDirectory *ContractAVSDirectorySession) RenounceOwnership() (*types.Transaction, error) { - return _ContractAVSDirectory.Contract.RenounceOwnership(&_ContractAVSDirectory.TransactOpts) -} - -// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. -// -// Solidity: function renounceOwnership() returns() -func (_ContractAVSDirectory *ContractAVSDirectoryTransactorSession) RenounceOwnership() (*types.Transaction, error) { - return _ContractAVSDirectory.Contract.RenounceOwnership(&_ContractAVSDirectory.TransactOpts) -} - -// SetPauserRegistry is a paid mutator transaction binding the contract method 0x10d67a2f. -// -// Solidity: function setPauserRegistry(address newPauserRegistry) returns() -func (_ContractAVSDirectory *ContractAVSDirectoryTransactor) SetPauserRegistry(opts *bind.TransactOpts, newPauserRegistry common.Address) (*types.Transaction, error) { - return _ContractAVSDirectory.contract.Transact(opts, "setPauserRegistry", newPauserRegistry) -} - -// SetPauserRegistry is a paid mutator transaction binding the contract method 0x10d67a2f. -// -// Solidity: function setPauserRegistry(address newPauserRegistry) returns() -func (_ContractAVSDirectory *ContractAVSDirectorySession) SetPauserRegistry(newPauserRegistry common.Address) (*types.Transaction, error) { - return _ContractAVSDirectory.Contract.SetPauserRegistry(&_ContractAVSDirectory.TransactOpts, newPauserRegistry) -} - -// SetPauserRegistry is a paid mutator transaction binding the contract method 0x10d67a2f. -// -// Solidity: function setPauserRegistry(address newPauserRegistry) returns() -func (_ContractAVSDirectory *ContractAVSDirectoryTransactorSession) SetPauserRegistry(newPauserRegistry common.Address) (*types.Transaction, error) { - return _ContractAVSDirectory.Contract.SetPauserRegistry(&_ContractAVSDirectory.TransactOpts, newPauserRegistry) -} - -// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. -// -// Solidity: function transferOwnership(address newOwner) returns() -func (_ContractAVSDirectory *ContractAVSDirectoryTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { - return _ContractAVSDirectory.contract.Transact(opts, "transferOwnership", newOwner) -} - -// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. -// -// Solidity: function transferOwnership(address newOwner) returns() -func (_ContractAVSDirectory *ContractAVSDirectorySession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { - return _ContractAVSDirectory.Contract.TransferOwnership(&_ContractAVSDirectory.TransactOpts, newOwner) -} - -// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. -// -// Solidity: function transferOwnership(address newOwner) returns() -func (_ContractAVSDirectory *ContractAVSDirectoryTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { - return _ContractAVSDirectory.Contract.TransferOwnership(&_ContractAVSDirectory.TransactOpts, newOwner) -} - -// Unpause is a paid mutator transaction binding the contract method 0xfabc1cbc. -// -// Solidity: function unpause(uint256 newPausedStatus) returns() -func (_ContractAVSDirectory *ContractAVSDirectoryTransactor) Unpause(opts *bind.TransactOpts, newPausedStatus *big.Int) (*types.Transaction, error) { - return _ContractAVSDirectory.contract.Transact(opts, "unpause", newPausedStatus) -} - -// Unpause is a paid mutator transaction binding the contract method 0xfabc1cbc. -// -// Solidity: function unpause(uint256 newPausedStatus) returns() -func (_ContractAVSDirectory *ContractAVSDirectorySession) Unpause(newPausedStatus *big.Int) (*types.Transaction, error) { - return _ContractAVSDirectory.Contract.Unpause(&_ContractAVSDirectory.TransactOpts, newPausedStatus) -} - -// Unpause is a paid mutator transaction binding the contract method 0xfabc1cbc. -// -// Solidity: function unpause(uint256 newPausedStatus) returns() -func (_ContractAVSDirectory *ContractAVSDirectoryTransactorSession) Unpause(newPausedStatus *big.Int) (*types.Transaction, error) { - return _ContractAVSDirectory.Contract.Unpause(&_ContractAVSDirectory.TransactOpts, newPausedStatus) -} - -// UpdateAVSMetadataURI is a paid mutator transaction binding the contract method 0xa98fb355. -// -// Solidity: function updateAVSMetadataURI(string metadataURI) returns() -func (_ContractAVSDirectory *ContractAVSDirectoryTransactor) UpdateAVSMetadataURI(opts *bind.TransactOpts, metadataURI string) (*types.Transaction, error) { - return _ContractAVSDirectory.contract.Transact(opts, "updateAVSMetadataURI", metadataURI) -} - -// UpdateAVSMetadataURI is a paid mutator transaction binding the contract method 0xa98fb355. -// -// Solidity: function updateAVSMetadataURI(string metadataURI) returns() -func (_ContractAVSDirectory *ContractAVSDirectorySession) UpdateAVSMetadataURI(metadataURI string) (*types.Transaction, error) { - return _ContractAVSDirectory.Contract.UpdateAVSMetadataURI(&_ContractAVSDirectory.TransactOpts, metadataURI) -} - -// UpdateAVSMetadataURI is a paid mutator transaction binding the contract method 0xa98fb355. -// -// Solidity: function updateAVSMetadataURI(string metadataURI) returns() -func (_ContractAVSDirectory *ContractAVSDirectoryTransactorSession) UpdateAVSMetadataURI(metadataURI string) (*types.Transaction, error) { - return _ContractAVSDirectory.Contract.UpdateAVSMetadataURI(&_ContractAVSDirectory.TransactOpts, metadataURI) -} - -// ContractAVSDirectoryAVSMetadataURIUpdatedIterator is returned from FilterAVSMetadataURIUpdated and is used to iterate over the raw logs and unpacked data for AVSMetadataURIUpdated events raised by the ContractAVSDirectory contract. -type ContractAVSDirectoryAVSMetadataURIUpdatedIterator struct { - Event *ContractAVSDirectoryAVSMetadataURIUpdated // 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 *ContractAVSDirectoryAVSMetadataURIUpdatedIterator) 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(ContractAVSDirectoryAVSMetadataURIUpdated) - 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(ContractAVSDirectoryAVSMetadataURIUpdated) - 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 *ContractAVSDirectoryAVSMetadataURIUpdatedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ContractAVSDirectoryAVSMetadataURIUpdatedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ContractAVSDirectoryAVSMetadataURIUpdated represents a AVSMetadataURIUpdated event raised by the ContractAVSDirectory contract. -type ContractAVSDirectoryAVSMetadataURIUpdated struct { - Avs common.Address - MetadataURI string - Raw types.Log // Blockchain specific contextual infos -} - -// FilterAVSMetadataURIUpdated is a free log retrieval operation binding the contract event 0xa89c1dc243d8908a96dd84944bcc97d6bc6ac00dd78e20621576be6a3c943713. -// -// Solidity: event AVSMetadataURIUpdated(address indexed avs, string metadataURI) -func (_ContractAVSDirectory *ContractAVSDirectoryFilterer) FilterAVSMetadataURIUpdated(opts *bind.FilterOpts, avs []common.Address) (*ContractAVSDirectoryAVSMetadataURIUpdatedIterator, error) { - - var avsRule []interface{} - for _, avsItem := range avs { - avsRule = append(avsRule, avsItem) - } - - logs, sub, err := _ContractAVSDirectory.contract.FilterLogs(opts, "AVSMetadataURIUpdated", avsRule) - if err != nil { - return nil, err - } - return &ContractAVSDirectoryAVSMetadataURIUpdatedIterator{contract: _ContractAVSDirectory.contract, event: "AVSMetadataURIUpdated", logs: logs, sub: sub}, nil -} - -// WatchAVSMetadataURIUpdated is a free log subscription operation binding the contract event 0xa89c1dc243d8908a96dd84944bcc97d6bc6ac00dd78e20621576be6a3c943713. -// -// Solidity: event AVSMetadataURIUpdated(address indexed avs, string metadataURI) -func (_ContractAVSDirectory *ContractAVSDirectoryFilterer) WatchAVSMetadataURIUpdated(opts *bind.WatchOpts, sink chan<- *ContractAVSDirectoryAVSMetadataURIUpdated, avs []common.Address) (event.Subscription, error) { - - var avsRule []interface{} - for _, avsItem := range avs { - avsRule = append(avsRule, avsItem) - } - - logs, sub, err := _ContractAVSDirectory.contract.WatchLogs(opts, "AVSMetadataURIUpdated", avsRule) - 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(ContractAVSDirectoryAVSMetadataURIUpdated) - if err := _ContractAVSDirectory.contract.UnpackLog(event, "AVSMetadataURIUpdated", 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 -} - -// ParseAVSMetadataURIUpdated is a log parse operation binding the contract event 0xa89c1dc243d8908a96dd84944bcc97d6bc6ac00dd78e20621576be6a3c943713. -// -// Solidity: event AVSMetadataURIUpdated(address indexed avs, string metadataURI) -func (_ContractAVSDirectory *ContractAVSDirectoryFilterer) ParseAVSMetadataURIUpdated(log types.Log) (*ContractAVSDirectoryAVSMetadataURIUpdated, error) { - event := new(ContractAVSDirectoryAVSMetadataURIUpdated) - if err := _ContractAVSDirectory.contract.UnpackLog(event, "AVSMetadataURIUpdated", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ContractAVSDirectoryInitializedIterator is returned from FilterInitialized and is used to iterate over the raw logs and unpacked data for Initialized events raised by the ContractAVSDirectory contract. -type ContractAVSDirectoryInitializedIterator struct { - Event *ContractAVSDirectoryInitialized // 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 *ContractAVSDirectoryInitializedIterator) 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(ContractAVSDirectoryInitialized) - 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(ContractAVSDirectoryInitialized) - 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 *ContractAVSDirectoryInitializedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ContractAVSDirectoryInitializedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ContractAVSDirectoryInitialized represents a Initialized event raised by the ContractAVSDirectory contract. -type ContractAVSDirectoryInitialized 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 (_ContractAVSDirectory *ContractAVSDirectoryFilterer) FilterInitialized(opts *bind.FilterOpts) (*ContractAVSDirectoryInitializedIterator, error) { - - logs, sub, err := _ContractAVSDirectory.contract.FilterLogs(opts, "Initialized") - if err != nil { - return nil, err - } - return &ContractAVSDirectoryInitializedIterator{contract: _ContractAVSDirectory.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 (_ContractAVSDirectory *ContractAVSDirectoryFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *ContractAVSDirectoryInitialized) (event.Subscription, error) { - - logs, sub, err := _ContractAVSDirectory.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(ContractAVSDirectoryInitialized) - if err := _ContractAVSDirectory.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 (_ContractAVSDirectory *ContractAVSDirectoryFilterer) ParseInitialized(log types.Log) (*ContractAVSDirectoryInitialized, error) { - event := new(ContractAVSDirectoryInitialized) - if err := _ContractAVSDirectory.contract.UnpackLog(event, "Initialized", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ContractAVSDirectoryOperatorAVSRegistrationStatusUpdatedIterator is returned from FilterOperatorAVSRegistrationStatusUpdated and is used to iterate over the raw logs and unpacked data for OperatorAVSRegistrationStatusUpdated events raised by the ContractAVSDirectory contract. -type ContractAVSDirectoryOperatorAVSRegistrationStatusUpdatedIterator struct { - Event *ContractAVSDirectoryOperatorAVSRegistrationStatusUpdated // 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 *ContractAVSDirectoryOperatorAVSRegistrationStatusUpdatedIterator) 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(ContractAVSDirectoryOperatorAVSRegistrationStatusUpdated) - 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(ContractAVSDirectoryOperatorAVSRegistrationStatusUpdated) - 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 *ContractAVSDirectoryOperatorAVSRegistrationStatusUpdatedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ContractAVSDirectoryOperatorAVSRegistrationStatusUpdatedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ContractAVSDirectoryOperatorAVSRegistrationStatusUpdated represents a OperatorAVSRegistrationStatusUpdated event raised by the ContractAVSDirectory contract. -type ContractAVSDirectoryOperatorAVSRegistrationStatusUpdated struct { - Operator common.Address - Avs common.Address - Status uint8 - Raw types.Log // Blockchain specific contextual infos -} - -// FilterOperatorAVSRegistrationStatusUpdated is a free log retrieval operation binding the contract event 0xf0952b1c65271d819d39983d2abb044b9cace59bcc4d4dd389f586ebdcb15b41. -// -// Solidity: event OperatorAVSRegistrationStatusUpdated(address indexed operator, address indexed avs, uint8 status) -func (_ContractAVSDirectory *ContractAVSDirectoryFilterer) FilterOperatorAVSRegistrationStatusUpdated(opts *bind.FilterOpts, operator []common.Address, avs []common.Address) (*ContractAVSDirectoryOperatorAVSRegistrationStatusUpdatedIterator, error) { - - var operatorRule []interface{} - for _, operatorItem := range operator { - operatorRule = append(operatorRule, operatorItem) - } - var avsRule []interface{} - for _, avsItem := range avs { - avsRule = append(avsRule, avsItem) - } - - logs, sub, err := _ContractAVSDirectory.contract.FilterLogs(opts, "OperatorAVSRegistrationStatusUpdated", operatorRule, avsRule) - if err != nil { - return nil, err - } - return &ContractAVSDirectoryOperatorAVSRegistrationStatusUpdatedIterator{contract: _ContractAVSDirectory.contract, event: "OperatorAVSRegistrationStatusUpdated", logs: logs, sub: sub}, nil -} - -// WatchOperatorAVSRegistrationStatusUpdated is a free log subscription operation binding the contract event 0xf0952b1c65271d819d39983d2abb044b9cace59bcc4d4dd389f586ebdcb15b41. -// -// Solidity: event OperatorAVSRegistrationStatusUpdated(address indexed operator, address indexed avs, uint8 status) -func (_ContractAVSDirectory *ContractAVSDirectoryFilterer) WatchOperatorAVSRegistrationStatusUpdated(opts *bind.WatchOpts, sink chan<- *ContractAVSDirectoryOperatorAVSRegistrationStatusUpdated, operator []common.Address, avs []common.Address) (event.Subscription, error) { - - var operatorRule []interface{} - for _, operatorItem := range operator { - operatorRule = append(operatorRule, operatorItem) - } - var avsRule []interface{} - for _, avsItem := range avs { - avsRule = append(avsRule, avsItem) - } - - logs, sub, err := _ContractAVSDirectory.contract.WatchLogs(opts, "OperatorAVSRegistrationStatusUpdated", operatorRule, avsRule) - 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(ContractAVSDirectoryOperatorAVSRegistrationStatusUpdated) - if err := _ContractAVSDirectory.contract.UnpackLog(event, "OperatorAVSRegistrationStatusUpdated", 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 -} - -// ParseOperatorAVSRegistrationStatusUpdated is a log parse operation binding the contract event 0xf0952b1c65271d819d39983d2abb044b9cace59bcc4d4dd389f586ebdcb15b41. -// -// Solidity: event OperatorAVSRegistrationStatusUpdated(address indexed operator, address indexed avs, uint8 status) -func (_ContractAVSDirectory *ContractAVSDirectoryFilterer) ParseOperatorAVSRegistrationStatusUpdated(log types.Log) (*ContractAVSDirectoryOperatorAVSRegistrationStatusUpdated, error) { - event := new(ContractAVSDirectoryOperatorAVSRegistrationStatusUpdated) - if err := _ContractAVSDirectory.contract.UnpackLog(event, "OperatorAVSRegistrationStatusUpdated", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ContractAVSDirectoryOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the ContractAVSDirectory contract. -type ContractAVSDirectoryOwnershipTransferredIterator struct { - Event *ContractAVSDirectoryOwnershipTransferred // 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 *ContractAVSDirectoryOwnershipTransferredIterator) 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(ContractAVSDirectoryOwnershipTransferred) - 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(ContractAVSDirectoryOwnershipTransferred) - 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 *ContractAVSDirectoryOwnershipTransferredIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ContractAVSDirectoryOwnershipTransferredIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ContractAVSDirectoryOwnershipTransferred represents a OwnershipTransferred event raised by the ContractAVSDirectory contract. -type ContractAVSDirectoryOwnershipTransferred 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 (_ContractAVSDirectory *ContractAVSDirectoryFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*ContractAVSDirectoryOwnershipTransferredIterator, 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 := _ContractAVSDirectory.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) - if err != nil { - return nil, err - } - return &ContractAVSDirectoryOwnershipTransferredIterator{contract: _ContractAVSDirectory.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 (_ContractAVSDirectory *ContractAVSDirectoryFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *ContractAVSDirectoryOwnershipTransferred, 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 := _ContractAVSDirectory.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(ContractAVSDirectoryOwnershipTransferred) - if err := _ContractAVSDirectory.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 (_ContractAVSDirectory *ContractAVSDirectoryFilterer) ParseOwnershipTransferred(log types.Log) (*ContractAVSDirectoryOwnershipTransferred, error) { - event := new(ContractAVSDirectoryOwnershipTransferred) - if err := _ContractAVSDirectory.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ContractAVSDirectoryPausedIterator is returned from FilterPaused and is used to iterate over the raw logs and unpacked data for Paused events raised by the ContractAVSDirectory contract. -type ContractAVSDirectoryPausedIterator struct { - Event *ContractAVSDirectoryPaused // 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 *ContractAVSDirectoryPausedIterator) 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(ContractAVSDirectoryPaused) - 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(ContractAVSDirectoryPaused) - 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 *ContractAVSDirectoryPausedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ContractAVSDirectoryPausedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ContractAVSDirectoryPaused represents a Paused event raised by the ContractAVSDirectory contract. -type ContractAVSDirectoryPaused struct { - Account common.Address - NewPausedStatus *big.Int - Raw types.Log // Blockchain specific contextual infos -} - -// FilterPaused is a free log retrieval operation binding the contract event 0xab40a374bc51de372200a8bc981af8c9ecdc08dfdaef0bb6e09f88f3c616ef3d. -// -// Solidity: event Paused(address indexed account, uint256 newPausedStatus) -func (_ContractAVSDirectory *ContractAVSDirectoryFilterer) FilterPaused(opts *bind.FilterOpts, account []common.Address) (*ContractAVSDirectoryPausedIterator, error) { - - var accountRule []interface{} - for _, accountItem := range account { - accountRule = append(accountRule, accountItem) - } - - logs, sub, err := _ContractAVSDirectory.contract.FilterLogs(opts, "Paused", accountRule) - if err != nil { - return nil, err - } - return &ContractAVSDirectoryPausedIterator{contract: _ContractAVSDirectory.contract, event: "Paused", logs: logs, sub: sub}, nil -} - -// WatchPaused is a free log subscription operation binding the contract event 0xab40a374bc51de372200a8bc981af8c9ecdc08dfdaef0bb6e09f88f3c616ef3d. -// -// Solidity: event Paused(address indexed account, uint256 newPausedStatus) -func (_ContractAVSDirectory *ContractAVSDirectoryFilterer) WatchPaused(opts *bind.WatchOpts, sink chan<- *ContractAVSDirectoryPaused, account []common.Address) (event.Subscription, error) { - - var accountRule []interface{} - for _, accountItem := range account { - accountRule = append(accountRule, accountItem) - } - - logs, sub, err := _ContractAVSDirectory.contract.WatchLogs(opts, "Paused", 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(ContractAVSDirectoryPaused) - if err := _ContractAVSDirectory.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 0xab40a374bc51de372200a8bc981af8c9ecdc08dfdaef0bb6e09f88f3c616ef3d. -// -// Solidity: event Paused(address indexed account, uint256 newPausedStatus) -func (_ContractAVSDirectory *ContractAVSDirectoryFilterer) ParsePaused(log types.Log) (*ContractAVSDirectoryPaused, error) { - event := new(ContractAVSDirectoryPaused) - if err := _ContractAVSDirectory.contract.UnpackLog(event, "Paused", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ContractAVSDirectoryPauserRegistrySetIterator is returned from FilterPauserRegistrySet and is used to iterate over the raw logs and unpacked data for PauserRegistrySet events raised by the ContractAVSDirectory contract. -type ContractAVSDirectoryPauserRegistrySetIterator struct { - Event *ContractAVSDirectoryPauserRegistrySet // 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 *ContractAVSDirectoryPauserRegistrySetIterator) 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(ContractAVSDirectoryPauserRegistrySet) - 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(ContractAVSDirectoryPauserRegistrySet) - 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 *ContractAVSDirectoryPauserRegistrySetIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ContractAVSDirectoryPauserRegistrySetIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ContractAVSDirectoryPauserRegistrySet represents a PauserRegistrySet event raised by the ContractAVSDirectory contract. -type ContractAVSDirectoryPauserRegistrySet struct { - PauserRegistry common.Address - NewPauserRegistry common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterPauserRegistrySet is a free log retrieval operation binding the contract event 0x6e9fcd539896fca60e8b0f01dd580233e48a6b0f7df013b89ba7f565869acdb6. -// -// Solidity: event PauserRegistrySet(address pauserRegistry, address newPauserRegistry) -func (_ContractAVSDirectory *ContractAVSDirectoryFilterer) FilterPauserRegistrySet(opts *bind.FilterOpts) (*ContractAVSDirectoryPauserRegistrySetIterator, error) { - - logs, sub, err := _ContractAVSDirectory.contract.FilterLogs(opts, "PauserRegistrySet") - if err != nil { - return nil, err - } - return &ContractAVSDirectoryPauserRegistrySetIterator{contract: _ContractAVSDirectory.contract, event: "PauserRegistrySet", logs: logs, sub: sub}, nil -} - -// WatchPauserRegistrySet is a free log subscription operation binding the contract event 0x6e9fcd539896fca60e8b0f01dd580233e48a6b0f7df013b89ba7f565869acdb6. -// -// Solidity: event PauserRegistrySet(address pauserRegistry, address newPauserRegistry) -func (_ContractAVSDirectory *ContractAVSDirectoryFilterer) WatchPauserRegistrySet(opts *bind.WatchOpts, sink chan<- *ContractAVSDirectoryPauserRegistrySet) (event.Subscription, error) { - - logs, sub, err := _ContractAVSDirectory.contract.WatchLogs(opts, "PauserRegistrySet") - 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(ContractAVSDirectoryPauserRegistrySet) - if err := _ContractAVSDirectory.contract.UnpackLog(event, "PauserRegistrySet", 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 -} - -// ParsePauserRegistrySet is a log parse operation binding the contract event 0x6e9fcd539896fca60e8b0f01dd580233e48a6b0f7df013b89ba7f565869acdb6. -// -// Solidity: event PauserRegistrySet(address pauserRegistry, address newPauserRegistry) -func (_ContractAVSDirectory *ContractAVSDirectoryFilterer) ParsePauserRegistrySet(log types.Log) (*ContractAVSDirectoryPauserRegistrySet, error) { - event := new(ContractAVSDirectoryPauserRegistrySet) - if err := _ContractAVSDirectory.contract.UnpackLog(event, "PauserRegistrySet", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ContractAVSDirectoryUnpausedIterator is returned from FilterUnpaused and is used to iterate over the raw logs and unpacked data for Unpaused events raised by the ContractAVSDirectory contract. -type ContractAVSDirectoryUnpausedIterator struct { - Event *ContractAVSDirectoryUnpaused // 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 *ContractAVSDirectoryUnpausedIterator) 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(ContractAVSDirectoryUnpaused) - 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(ContractAVSDirectoryUnpaused) - 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 *ContractAVSDirectoryUnpausedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ContractAVSDirectoryUnpausedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ContractAVSDirectoryUnpaused represents a Unpaused event raised by the ContractAVSDirectory contract. -type ContractAVSDirectoryUnpaused struct { - Account common.Address - NewPausedStatus *big.Int - Raw types.Log // Blockchain specific contextual infos -} - -// FilterUnpaused is a free log retrieval operation binding the contract event 0x3582d1828e26bf56bd801502bc021ac0bc8afb57c826e4986b45593c8fad389c. -// -// Solidity: event Unpaused(address indexed account, uint256 newPausedStatus) -func (_ContractAVSDirectory *ContractAVSDirectoryFilterer) FilterUnpaused(opts *bind.FilterOpts, account []common.Address) (*ContractAVSDirectoryUnpausedIterator, error) { - - var accountRule []interface{} - for _, accountItem := range account { - accountRule = append(accountRule, accountItem) - } - - logs, sub, err := _ContractAVSDirectory.contract.FilterLogs(opts, "Unpaused", accountRule) - if err != nil { - return nil, err - } - return &ContractAVSDirectoryUnpausedIterator{contract: _ContractAVSDirectory.contract, event: "Unpaused", logs: logs, sub: sub}, nil -} - -// WatchUnpaused is a free log subscription operation binding the contract event 0x3582d1828e26bf56bd801502bc021ac0bc8afb57c826e4986b45593c8fad389c. -// -// Solidity: event Unpaused(address indexed account, uint256 newPausedStatus) -func (_ContractAVSDirectory *ContractAVSDirectoryFilterer) WatchUnpaused(opts *bind.WatchOpts, sink chan<- *ContractAVSDirectoryUnpaused, account []common.Address) (event.Subscription, error) { - - var accountRule []interface{} - for _, accountItem := range account { - accountRule = append(accountRule, accountItem) - } - - logs, sub, err := _ContractAVSDirectory.contract.WatchLogs(opts, "Unpaused", 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(ContractAVSDirectoryUnpaused) - if err := _ContractAVSDirectory.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 0x3582d1828e26bf56bd801502bc021ac0bc8afb57c826e4986b45593c8fad389c. -// -// Solidity: event Unpaused(address indexed account, uint256 newPausedStatus) -func (_ContractAVSDirectory *ContractAVSDirectoryFilterer) ParseUnpaused(log types.Log) (*ContractAVSDirectoryUnpaused, error) { - event := new(ContractAVSDirectoryUnpaused) - if err := _ContractAVSDirectory.contract.UnpackLog(event, "Unpaused", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} diff --git a/contracts/bindings/BLSApkRegistry/binding.go b/contracts/bindings/BLSApkRegistry/binding.go deleted file mode 100644 index 2ab2b19..0000000 --- a/contracts/bindings/BLSApkRegistry/binding.go +++ /dev/null @@ -1,1435 +0,0 @@ -// Code generated - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package contractBLSApkRegistry - -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 -) - -// BN254G1Point is an auto generated low-level Go binding around an user-defined struct. -type BN254G1Point struct { - X *big.Int - Y *big.Int -} - -// BN254G2Point is an auto generated low-level Go binding around an user-defined struct. -type BN254G2Point struct { - X [2]*big.Int - Y [2]*big.Int -} - -// IBLSApkRegistryApkUpdate is an auto generated low-level Go binding around an user-defined struct. -type IBLSApkRegistryApkUpdate struct { - ApkHash [24]byte - UpdateBlockNumber uint32 - NextUpdateBlockNumber uint32 -} - -// IBLSApkRegistryPubkeyRegistrationParams is an auto generated low-level Go binding around an user-defined struct. -type IBLSApkRegistryPubkeyRegistrationParams struct { - PubkeyRegistrationSignature BN254G1Point - PubkeyG1 BN254G1Point - PubkeyG2 BN254G2Point -} - -// ContractBLSApkRegistryMetaData contains all meta data concerning the ContractBLSApkRegistry contract. -var ContractBLSApkRegistryMetaData = &bind.MetaData{ - ABI: "[{\"type\":\"constructor\",\"inputs\":[{\"name\":\"_registryCoordinator\",\"type\":\"address\",\"internalType\":\"contractIEORegistryCoordinator\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"apkHistory\",\"inputs\":[{\"name\":\"\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"apkHash\",\"type\":\"bytes24\",\"internalType\":\"bytes24\"},{\"name\":\"updateBlockNumber\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"nextUpdateBlockNumber\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"currentApk\",\"inputs\":[{\"name\":\"\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"deregisterOperator\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"quorumNumbers\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"getApk\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structBN254.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getApkHashAtBlockNumberAndIndex\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"blockNumber\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"index\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes24\",\"internalType\":\"bytes24\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getApkHistoryLength\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getApkIndicesAtBlockNumber\",\"inputs\":[{\"name\":\"quorumNumbers\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"blockNumber\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint32[]\",\"internalType\":\"uint32[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getApkUpdateAtIndex\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"index\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structIBLSApkRegistry.ApkUpdate\",\"components\":[{\"name\":\"apkHash\",\"type\":\"bytes24\",\"internalType\":\"bytes24\"},{\"name\":\"updateBlockNumber\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"nextUpdateBlockNumber\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getOperatorFromPubkeyHash\",\"inputs\":[{\"name\":\"pubkeyHash\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getOperatorId\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getRegisteredPubkey\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structBN254.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"initializeQuorum\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"operatorToPubkey\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"operatorToPubkeyHash\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pubkeyHashToOperator\",\"inputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"registerBLSPublicKey\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"params\",\"type\":\"tuple\",\"internalType\":\"structIBLSApkRegistry.PubkeyRegistrationParams\",\"components\":[{\"name\":\"pubkeyRegistrationSignature\",\"type\":\"tuple\",\"internalType\":\"structBN254.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"pubkeyG1\",\"type\":\"tuple\",\"internalType\":\"structBN254.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"pubkeyG2\",\"type\":\"tuple\",\"internalType\":\"structBN254.G2Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256[2]\",\"internalType\":\"uint256[2]\"},{\"name\":\"Y\",\"type\":\"uint256[2]\",\"internalType\":\"uint256[2]\"}]}]},{\"name\":\"pubkeyRegistrationMessageHash\",\"type\":\"tuple\",\"internalType\":\"structBN254.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]}],\"outputs\":[{\"name\":\"operatorId\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"registerOperator\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"quorumNumbers\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"registryCoordinator\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"event\",\"name\":\"Initialized\",\"inputs\":[{\"name\":\"version\",\"type\":\"uint8\",\"indexed\":false,\"internalType\":\"uint8\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"NewPubkeyRegistration\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"pubkeyG1\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structBN254.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"pubkeyG2\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structBN254.G2Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256[2]\",\"internalType\":\"uint256[2]\"},{\"name\":\"Y\",\"type\":\"uint256[2]\",\"internalType\":\"uint256[2]\"}]}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorAddedToQuorums\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"quorumNumbers\",\"type\":\"bytes\",\"indexed\":false,\"internalType\":\"bytes\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorRemovedFromQuorums\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"quorumNumbers\",\"type\":\"bytes\",\"indexed\":false,\"internalType\":\"bytes\"}],\"anonymous\":false}]", - Bin: "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", -} - -// ContractBLSApkRegistryABI is the input ABI used to generate the binding from. -// Deprecated: Use ContractBLSApkRegistryMetaData.ABI instead. -var ContractBLSApkRegistryABI = ContractBLSApkRegistryMetaData.ABI - -// ContractBLSApkRegistryBin is the compiled bytecode used for deploying new contracts. -// Deprecated: Use ContractBLSApkRegistryMetaData.Bin instead. -var ContractBLSApkRegistryBin = ContractBLSApkRegistryMetaData.Bin - -// DeployContractBLSApkRegistry deploys a new Ethereum contract, binding an instance of ContractBLSApkRegistry to it. -func DeployContractBLSApkRegistry(auth *bind.TransactOpts, backend bind.ContractBackend, _registryCoordinator common.Address) (common.Address, *types.Transaction, *ContractBLSApkRegistry, error) { - parsed, err := ContractBLSApkRegistryMetaData.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(ContractBLSApkRegistryBin), backend, _registryCoordinator) - if err != nil { - return common.Address{}, nil, nil, err - } - return address, tx, &ContractBLSApkRegistry{ContractBLSApkRegistryCaller: ContractBLSApkRegistryCaller{contract: contract}, ContractBLSApkRegistryTransactor: ContractBLSApkRegistryTransactor{contract: contract}, ContractBLSApkRegistryFilterer: ContractBLSApkRegistryFilterer{contract: contract}}, nil -} - -// ContractBLSApkRegistryMethods is an auto generated interface around an Ethereum contract. -type ContractBLSApkRegistryMethods interface { - ContractBLSApkRegistryCalls - ContractBLSApkRegistryTransacts - ContractBLSApkRegistryFilters -} - -// ContractBLSApkRegistryCalls is an auto generated interface that defines the call methods available for an Ethereum contract. -type ContractBLSApkRegistryCalls interface { - ApkHistory(opts *bind.CallOpts, arg0 uint8, arg1 *big.Int) (struct { - ApkHash [24]byte - UpdateBlockNumber uint32 - NextUpdateBlockNumber uint32 - }, error) - - CurrentApk(opts *bind.CallOpts, arg0 uint8) (struct { - X *big.Int - Y *big.Int - }, error) - - GetApk(opts *bind.CallOpts, quorumNumber uint8) (BN254G1Point, error) - - GetApkHashAtBlockNumberAndIndex(opts *bind.CallOpts, quorumNumber uint8, blockNumber uint32, index *big.Int) ([24]byte, error) - - GetApkHistoryLength(opts *bind.CallOpts, quorumNumber uint8) (uint32, error) - - GetApkIndicesAtBlockNumber(opts *bind.CallOpts, quorumNumbers []byte, blockNumber *big.Int) ([]uint32, error) - - GetApkUpdateAtIndex(opts *bind.CallOpts, quorumNumber uint8, index *big.Int) (IBLSApkRegistryApkUpdate, error) - - GetOperatorFromPubkeyHash(opts *bind.CallOpts, pubkeyHash [32]byte) (common.Address, error) - - GetOperatorId(opts *bind.CallOpts, operator common.Address) ([32]byte, error) - - GetRegisteredPubkey(opts *bind.CallOpts, operator common.Address) (BN254G1Point, [32]byte, error) - - OperatorToPubkey(opts *bind.CallOpts, arg0 common.Address) (struct { - X *big.Int - Y *big.Int - }, error) - - OperatorToPubkeyHash(opts *bind.CallOpts, arg0 common.Address) ([32]byte, error) - - PubkeyHashToOperator(opts *bind.CallOpts, arg0 [32]byte) (common.Address, error) - - RegistryCoordinator(opts *bind.CallOpts) (common.Address, error) -} - -// ContractBLSApkRegistryTransacts is an auto generated interface that defines the transact methods available for an Ethereum contract. -type ContractBLSApkRegistryTransacts interface { - DeregisterOperator(opts *bind.TransactOpts, operator common.Address, quorumNumbers []byte) (*types.Transaction, error) - - InitializeQuorum(opts *bind.TransactOpts, quorumNumber uint8) (*types.Transaction, error) - - RegisterBLSPublicKey(opts *bind.TransactOpts, operator common.Address, params IBLSApkRegistryPubkeyRegistrationParams, pubkeyRegistrationMessageHash BN254G1Point) (*types.Transaction, error) - - RegisterOperator(opts *bind.TransactOpts, operator common.Address, quorumNumbers []byte) (*types.Transaction, error) -} - -// ContractBLSApkRegistryFilterer is an auto generated interface that defines the log filtering methods available for an Ethereum contract. -type ContractBLSApkRegistryFilters interface { - FilterInitialized(opts *bind.FilterOpts) (*ContractBLSApkRegistryInitializedIterator, error) - WatchInitialized(opts *bind.WatchOpts, sink chan<- *ContractBLSApkRegistryInitialized) (event.Subscription, error) - ParseInitialized(log types.Log) (*ContractBLSApkRegistryInitialized, error) - - FilterNewPubkeyRegistration(opts *bind.FilterOpts, operator []common.Address) (*ContractBLSApkRegistryNewPubkeyRegistrationIterator, error) - WatchNewPubkeyRegistration(opts *bind.WatchOpts, sink chan<- *ContractBLSApkRegistryNewPubkeyRegistration, operator []common.Address) (event.Subscription, error) - ParseNewPubkeyRegistration(log types.Log) (*ContractBLSApkRegistryNewPubkeyRegistration, error) - - FilterOperatorAddedToQuorums(opts *bind.FilterOpts) (*ContractBLSApkRegistryOperatorAddedToQuorumsIterator, error) - WatchOperatorAddedToQuorums(opts *bind.WatchOpts, sink chan<- *ContractBLSApkRegistryOperatorAddedToQuorums) (event.Subscription, error) - ParseOperatorAddedToQuorums(log types.Log) (*ContractBLSApkRegistryOperatorAddedToQuorums, error) - - FilterOperatorRemovedFromQuorums(opts *bind.FilterOpts) (*ContractBLSApkRegistryOperatorRemovedFromQuorumsIterator, error) - WatchOperatorRemovedFromQuorums(opts *bind.WatchOpts, sink chan<- *ContractBLSApkRegistryOperatorRemovedFromQuorums) (event.Subscription, error) - ParseOperatorRemovedFromQuorums(log types.Log) (*ContractBLSApkRegistryOperatorRemovedFromQuorums, error) -} - -// ContractBLSApkRegistry is an auto generated Go binding around an Ethereum contract. -type ContractBLSApkRegistry struct { - ContractBLSApkRegistryCaller // Read-only binding to the contract - ContractBLSApkRegistryTransactor // Write-only binding to the contract - ContractBLSApkRegistryFilterer // Log filterer for contract events -} - -// ContractBLSApkRegistry implements the ContractBLSApkRegistryMethods interface. -var _ ContractBLSApkRegistryMethods = (*ContractBLSApkRegistry)(nil) - -// ContractBLSApkRegistryCaller is an auto generated read-only Go binding around an Ethereum contract. -type ContractBLSApkRegistryCaller struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// ContractBLSApkRegistryCaller implements the ContractBLSApkRegistryCalls interface. -var _ ContractBLSApkRegistryCalls = (*ContractBLSApkRegistryCaller)(nil) - -// ContractBLSApkRegistryTransactor is an auto generated write-only Go binding around an Ethereum contract. -type ContractBLSApkRegistryTransactor struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// ContractBLSApkRegistryTransactor implements the ContractBLSApkRegistryTransacts interface. -var _ ContractBLSApkRegistryTransacts = (*ContractBLSApkRegistryTransactor)(nil) - -// ContractBLSApkRegistryFilterer is an auto generated log filtering Go binding around an Ethereum contract events. -type ContractBLSApkRegistryFilterer struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// ContractBLSApkRegistryFilterer implements the ContractBLSApkRegistryFilters interface. -var _ ContractBLSApkRegistryFilters = (*ContractBLSApkRegistryFilterer)(nil) - -// ContractBLSApkRegistrySession is an auto generated Go binding around an Ethereum contract, -// with pre-set call and transact options. -type ContractBLSApkRegistrySession struct { - Contract *ContractBLSApkRegistry // 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 -} - -// ContractBLSApkRegistryCallerSession is an auto generated read-only Go binding around an Ethereum contract, -// with pre-set call options. -type ContractBLSApkRegistryCallerSession struct { - Contract *ContractBLSApkRegistryCaller // Generic contract caller binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session -} - -// ContractBLSApkRegistryTransactorSession is an auto generated write-only Go binding around an Ethereum contract, -// with pre-set transact options. -type ContractBLSApkRegistryTransactorSession struct { - Contract *ContractBLSApkRegistryTransactor // Generic contract transactor binding to set the session for - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session -} - -// ContractBLSApkRegistryRaw is an auto generated low-level Go binding around an Ethereum contract. -type ContractBLSApkRegistryRaw struct { - Contract *ContractBLSApkRegistry // Generic contract binding to access the raw methods on -} - -// ContractBLSApkRegistryCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. -type ContractBLSApkRegistryCallerRaw struct { - Contract *ContractBLSApkRegistryCaller // Generic read-only contract binding to access the raw methods on -} - -// ContractBLSApkRegistryTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. -type ContractBLSApkRegistryTransactorRaw struct { - Contract *ContractBLSApkRegistryTransactor // Generic write-only contract binding to access the raw methods on -} - -// NewContractBLSApkRegistry creates a new instance of ContractBLSApkRegistry, bound to a specific deployed contract. -func NewContractBLSApkRegistry(address common.Address, backend bind.ContractBackend) (*ContractBLSApkRegistry, error) { - contract, err := bindContractBLSApkRegistry(address, backend, backend, backend) - if err != nil { - return nil, err - } - return &ContractBLSApkRegistry{ContractBLSApkRegistryCaller: ContractBLSApkRegistryCaller{contract: contract}, ContractBLSApkRegistryTransactor: ContractBLSApkRegistryTransactor{contract: contract}, ContractBLSApkRegistryFilterer: ContractBLSApkRegistryFilterer{contract: contract}}, nil -} - -// NewContractBLSApkRegistryCaller creates a new read-only instance of ContractBLSApkRegistry, bound to a specific deployed contract. -func NewContractBLSApkRegistryCaller(address common.Address, caller bind.ContractCaller) (*ContractBLSApkRegistryCaller, error) { - contract, err := bindContractBLSApkRegistry(address, caller, nil, nil) - if err != nil { - return nil, err - } - return &ContractBLSApkRegistryCaller{contract: contract}, nil -} - -// NewContractBLSApkRegistryTransactor creates a new write-only instance of ContractBLSApkRegistry, bound to a specific deployed contract. -func NewContractBLSApkRegistryTransactor(address common.Address, transactor bind.ContractTransactor) (*ContractBLSApkRegistryTransactor, error) { - contract, err := bindContractBLSApkRegistry(address, nil, transactor, nil) - if err != nil { - return nil, err - } - return &ContractBLSApkRegistryTransactor{contract: contract}, nil -} - -// NewContractBLSApkRegistryFilterer creates a new log filterer instance of ContractBLSApkRegistry, bound to a specific deployed contract. -func NewContractBLSApkRegistryFilterer(address common.Address, filterer bind.ContractFilterer) (*ContractBLSApkRegistryFilterer, error) { - contract, err := bindContractBLSApkRegistry(address, nil, nil, filterer) - if err != nil { - return nil, err - } - return &ContractBLSApkRegistryFilterer{contract: contract}, nil -} - -// bindContractBLSApkRegistry binds a generic wrapper to an already deployed contract. -func bindContractBLSApkRegistry(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { - parsed, err := ContractBLSApkRegistryMetaData.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 (_ContractBLSApkRegistry *ContractBLSApkRegistryRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _ContractBLSApkRegistry.Contract.ContractBLSApkRegistryCaller.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 (_ContractBLSApkRegistry *ContractBLSApkRegistryRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _ContractBLSApkRegistry.Contract.ContractBLSApkRegistryTransactor.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_ContractBLSApkRegistry *ContractBLSApkRegistryRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _ContractBLSApkRegistry.Contract.ContractBLSApkRegistryTransactor.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 (_ContractBLSApkRegistry *ContractBLSApkRegistryCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _ContractBLSApkRegistry.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 (_ContractBLSApkRegistry *ContractBLSApkRegistryTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _ContractBLSApkRegistry.Contract.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_ContractBLSApkRegistry *ContractBLSApkRegistryTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _ContractBLSApkRegistry.Contract.contract.Transact(opts, method, params...) -} - -// ApkHistory is a free data retrieval call binding the contract method 0x7916cea6. -// -// Solidity: function apkHistory(uint8 , uint256 ) view returns(bytes24 apkHash, uint32 updateBlockNumber, uint32 nextUpdateBlockNumber) -func (_ContractBLSApkRegistry *ContractBLSApkRegistryCaller) ApkHistory(opts *bind.CallOpts, arg0 uint8, arg1 *big.Int) (struct { - ApkHash [24]byte - UpdateBlockNumber uint32 - NextUpdateBlockNumber uint32 -}, error) { - var out []interface{} - err := _ContractBLSApkRegistry.contract.Call(opts, &out, "apkHistory", arg0, arg1) - - outstruct := new(struct { - ApkHash [24]byte - UpdateBlockNumber uint32 - NextUpdateBlockNumber uint32 - }) - if err != nil { - return *outstruct, err - } - - outstruct.ApkHash = *abi.ConvertType(out[0], new([24]byte)).(*[24]byte) - outstruct.UpdateBlockNumber = *abi.ConvertType(out[1], new(uint32)).(*uint32) - outstruct.NextUpdateBlockNumber = *abi.ConvertType(out[2], new(uint32)).(*uint32) - - return *outstruct, err - -} - -// ApkHistory is a free data retrieval call binding the contract method 0x7916cea6. -// -// Solidity: function apkHistory(uint8 , uint256 ) view returns(bytes24 apkHash, uint32 updateBlockNumber, uint32 nextUpdateBlockNumber) -func (_ContractBLSApkRegistry *ContractBLSApkRegistrySession) ApkHistory(arg0 uint8, arg1 *big.Int) (struct { - ApkHash [24]byte - UpdateBlockNumber uint32 - NextUpdateBlockNumber uint32 -}, error) { - return _ContractBLSApkRegistry.Contract.ApkHistory(&_ContractBLSApkRegistry.CallOpts, arg0, arg1) -} - -// ApkHistory is a free data retrieval call binding the contract method 0x7916cea6. -// -// Solidity: function apkHistory(uint8 , uint256 ) view returns(bytes24 apkHash, uint32 updateBlockNumber, uint32 nextUpdateBlockNumber) -func (_ContractBLSApkRegistry *ContractBLSApkRegistryCallerSession) ApkHistory(arg0 uint8, arg1 *big.Int) (struct { - ApkHash [24]byte - UpdateBlockNumber uint32 - NextUpdateBlockNumber uint32 -}, error) { - return _ContractBLSApkRegistry.Contract.ApkHistory(&_ContractBLSApkRegistry.CallOpts, arg0, arg1) -} - -// CurrentApk is a free data retrieval call binding the contract method 0xa3db80e2. -// -// Solidity: function currentApk(uint8 ) view returns(uint256 X, uint256 Y) -func (_ContractBLSApkRegistry *ContractBLSApkRegistryCaller) CurrentApk(opts *bind.CallOpts, arg0 uint8) (struct { - X *big.Int - Y *big.Int -}, error) { - var out []interface{} - err := _ContractBLSApkRegistry.contract.Call(opts, &out, "currentApk", arg0) - - outstruct := new(struct { - X *big.Int - Y *big.Int - }) - if err != nil { - return *outstruct, err - } - - outstruct.X = *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - outstruct.Y = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) - - return *outstruct, err - -} - -// CurrentApk is a free data retrieval call binding the contract method 0xa3db80e2. -// -// Solidity: function currentApk(uint8 ) view returns(uint256 X, uint256 Y) -func (_ContractBLSApkRegistry *ContractBLSApkRegistrySession) CurrentApk(arg0 uint8) (struct { - X *big.Int - Y *big.Int -}, error) { - return _ContractBLSApkRegistry.Contract.CurrentApk(&_ContractBLSApkRegistry.CallOpts, arg0) -} - -// CurrentApk is a free data retrieval call binding the contract method 0xa3db80e2. -// -// Solidity: function currentApk(uint8 ) view returns(uint256 X, uint256 Y) -func (_ContractBLSApkRegistry *ContractBLSApkRegistryCallerSession) CurrentApk(arg0 uint8) (struct { - X *big.Int - Y *big.Int -}, error) { - return _ContractBLSApkRegistry.Contract.CurrentApk(&_ContractBLSApkRegistry.CallOpts, arg0) -} - -// GetApk is a free data retrieval call binding the contract method 0x5f61a884. -// -// Solidity: function getApk(uint8 quorumNumber) view returns((uint256,uint256)) -func (_ContractBLSApkRegistry *ContractBLSApkRegistryCaller) GetApk(opts *bind.CallOpts, quorumNumber uint8) (BN254G1Point, error) { - var out []interface{} - err := _ContractBLSApkRegistry.contract.Call(opts, &out, "getApk", quorumNumber) - - if err != nil { - return *new(BN254G1Point), err - } - - out0 := *abi.ConvertType(out[0], new(BN254G1Point)).(*BN254G1Point) - - return out0, err - -} - -// GetApk is a free data retrieval call binding the contract method 0x5f61a884. -// -// Solidity: function getApk(uint8 quorumNumber) view returns((uint256,uint256)) -func (_ContractBLSApkRegistry *ContractBLSApkRegistrySession) GetApk(quorumNumber uint8) (BN254G1Point, error) { - return _ContractBLSApkRegistry.Contract.GetApk(&_ContractBLSApkRegistry.CallOpts, quorumNumber) -} - -// GetApk is a free data retrieval call binding the contract method 0x5f61a884. -// -// Solidity: function getApk(uint8 quorumNumber) view returns((uint256,uint256)) -func (_ContractBLSApkRegistry *ContractBLSApkRegistryCallerSession) GetApk(quorumNumber uint8) (BN254G1Point, error) { - return _ContractBLSApkRegistry.Contract.GetApk(&_ContractBLSApkRegistry.CallOpts, quorumNumber) -} - -// GetApkHashAtBlockNumberAndIndex is a free data retrieval call binding the contract method 0x68bccaac. -// -// Solidity: function getApkHashAtBlockNumberAndIndex(uint8 quorumNumber, uint32 blockNumber, uint256 index) view returns(bytes24) -func (_ContractBLSApkRegistry *ContractBLSApkRegistryCaller) GetApkHashAtBlockNumberAndIndex(opts *bind.CallOpts, quorumNumber uint8, blockNumber uint32, index *big.Int) ([24]byte, error) { - var out []interface{} - err := _ContractBLSApkRegistry.contract.Call(opts, &out, "getApkHashAtBlockNumberAndIndex", quorumNumber, blockNumber, index) - - if err != nil { - return *new([24]byte), err - } - - out0 := *abi.ConvertType(out[0], new([24]byte)).(*[24]byte) - - return out0, err - -} - -// GetApkHashAtBlockNumberAndIndex is a free data retrieval call binding the contract method 0x68bccaac. -// -// Solidity: function getApkHashAtBlockNumberAndIndex(uint8 quorumNumber, uint32 blockNumber, uint256 index) view returns(bytes24) -func (_ContractBLSApkRegistry *ContractBLSApkRegistrySession) GetApkHashAtBlockNumberAndIndex(quorumNumber uint8, blockNumber uint32, index *big.Int) ([24]byte, error) { - return _ContractBLSApkRegistry.Contract.GetApkHashAtBlockNumberAndIndex(&_ContractBLSApkRegistry.CallOpts, quorumNumber, blockNumber, index) -} - -// GetApkHashAtBlockNumberAndIndex is a free data retrieval call binding the contract method 0x68bccaac. -// -// Solidity: function getApkHashAtBlockNumberAndIndex(uint8 quorumNumber, uint32 blockNumber, uint256 index) view returns(bytes24) -func (_ContractBLSApkRegistry *ContractBLSApkRegistryCallerSession) GetApkHashAtBlockNumberAndIndex(quorumNumber uint8, blockNumber uint32, index *big.Int) ([24]byte, error) { - return _ContractBLSApkRegistry.Contract.GetApkHashAtBlockNumberAndIndex(&_ContractBLSApkRegistry.CallOpts, quorumNumber, blockNumber, index) -} - -// GetApkHistoryLength is a free data retrieval call binding the contract method 0x377ed99d. -// -// Solidity: function getApkHistoryLength(uint8 quorumNumber) view returns(uint32) -func (_ContractBLSApkRegistry *ContractBLSApkRegistryCaller) GetApkHistoryLength(opts *bind.CallOpts, quorumNumber uint8) (uint32, error) { - var out []interface{} - err := _ContractBLSApkRegistry.contract.Call(opts, &out, "getApkHistoryLength", quorumNumber) - - if err != nil { - return *new(uint32), err - } - - out0 := *abi.ConvertType(out[0], new(uint32)).(*uint32) - - return out0, err - -} - -// GetApkHistoryLength is a free data retrieval call binding the contract method 0x377ed99d. -// -// Solidity: function getApkHistoryLength(uint8 quorumNumber) view returns(uint32) -func (_ContractBLSApkRegistry *ContractBLSApkRegistrySession) GetApkHistoryLength(quorumNumber uint8) (uint32, error) { - return _ContractBLSApkRegistry.Contract.GetApkHistoryLength(&_ContractBLSApkRegistry.CallOpts, quorumNumber) -} - -// GetApkHistoryLength is a free data retrieval call binding the contract method 0x377ed99d. -// -// Solidity: function getApkHistoryLength(uint8 quorumNumber) view returns(uint32) -func (_ContractBLSApkRegistry *ContractBLSApkRegistryCallerSession) GetApkHistoryLength(quorumNumber uint8) (uint32, error) { - return _ContractBLSApkRegistry.Contract.GetApkHistoryLength(&_ContractBLSApkRegistry.CallOpts, quorumNumber) -} - -// GetApkIndicesAtBlockNumber is a free data retrieval call binding the contract method 0xd5254a8c. -// -// Solidity: function getApkIndicesAtBlockNumber(bytes quorumNumbers, uint256 blockNumber) view returns(uint32[]) -func (_ContractBLSApkRegistry *ContractBLSApkRegistryCaller) GetApkIndicesAtBlockNumber(opts *bind.CallOpts, quorumNumbers []byte, blockNumber *big.Int) ([]uint32, error) { - var out []interface{} - err := _ContractBLSApkRegistry.contract.Call(opts, &out, "getApkIndicesAtBlockNumber", quorumNumbers, blockNumber) - - if err != nil { - return *new([]uint32), err - } - - out0 := *abi.ConvertType(out[0], new([]uint32)).(*[]uint32) - - return out0, err - -} - -// GetApkIndicesAtBlockNumber is a free data retrieval call binding the contract method 0xd5254a8c. -// -// Solidity: function getApkIndicesAtBlockNumber(bytes quorumNumbers, uint256 blockNumber) view returns(uint32[]) -func (_ContractBLSApkRegistry *ContractBLSApkRegistrySession) GetApkIndicesAtBlockNumber(quorumNumbers []byte, blockNumber *big.Int) ([]uint32, error) { - return _ContractBLSApkRegistry.Contract.GetApkIndicesAtBlockNumber(&_ContractBLSApkRegistry.CallOpts, quorumNumbers, blockNumber) -} - -// GetApkIndicesAtBlockNumber is a free data retrieval call binding the contract method 0xd5254a8c. -// -// Solidity: function getApkIndicesAtBlockNumber(bytes quorumNumbers, uint256 blockNumber) view returns(uint32[]) -func (_ContractBLSApkRegistry *ContractBLSApkRegistryCallerSession) GetApkIndicesAtBlockNumber(quorumNumbers []byte, blockNumber *big.Int) ([]uint32, error) { - return _ContractBLSApkRegistry.Contract.GetApkIndicesAtBlockNumber(&_ContractBLSApkRegistry.CallOpts, quorumNumbers, blockNumber) -} - -// GetApkUpdateAtIndex is a free data retrieval call binding the contract method 0x605747d5. -// -// Solidity: function getApkUpdateAtIndex(uint8 quorumNumber, uint256 index) view returns((bytes24,uint32,uint32)) -func (_ContractBLSApkRegistry *ContractBLSApkRegistryCaller) GetApkUpdateAtIndex(opts *bind.CallOpts, quorumNumber uint8, index *big.Int) (IBLSApkRegistryApkUpdate, error) { - var out []interface{} - err := _ContractBLSApkRegistry.contract.Call(opts, &out, "getApkUpdateAtIndex", quorumNumber, index) - - if err != nil { - return *new(IBLSApkRegistryApkUpdate), err - } - - out0 := *abi.ConvertType(out[0], new(IBLSApkRegistryApkUpdate)).(*IBLSApkRegistryApkUpdate) - - return out0, err - -} - -// GetApkUpdateAtIndex is a free data retrieval call binding the contract method 0x605747d5. -// -// Solidity: function getApkUpdateAtIndex(uint8 quorumNumber, uint256 index) view returns((bytes24,uint32,uint32)) -func (_ContractBLSApkRegistry *ContractBLSApkRegistrySession) GetApkUpdateAtIndex(quorumNumber uint8, index *big.Int) (IBLSApkRegistryApkUpdate, error) { - return _ContractBLSApkRegistry.Contract.GetApkUpdateAtIndex(&_ContractBLSApkRegistry.CallOpts, quorumNumber, index) -} - -// GetApkUpdateAtIndex is a free data retrieval call binding the contract method 0x605747d5. -// -// Solidity: function getApkUpdateAtIndex(uint8 quorumNumber, uint256 index) view returns((bytes24,uint32,uint32)) -func (_ContractBLSApkRegistry *ContractBLSApkRegistryCallerSession) GetApkUpdateAtIndex(quorumNumber uint8, index *big.Int) (IBLSApkRegistryApkUpdate, error) { - return _ContractBLSApkRegistry.Contract.GetApkUpdateAtIndex(&_ContractBLSApkRegistry.CallOpts, quorumNumber, index) -} - -// GetOperatorFromPubkeyHash is a free data retrieval call binding the contract method 0x47b314e8. -// -// Solidity: function getOperatorFromPubkeyHash(bytes32 pubkeyHash) view returns(address) -func (_ContractBLSApkRegistry *ContractBLSApkRegistryCaller) GetOperatorFromPubkeyHash(opts *bind.CallOpts, pubkeyHash [32]byte) (common.Address, error) { - var out []interface{} - err := _ContractBLSApkRegistry.contract.Call(opts, &out, "getOperatorFromPubkeyHash", pubkeyHash) - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// GetOperatorFromPubkeyHash is a free data retrieval call binding the contract method 0x47b314e8. -// -// Solidity: function getOperatorFromPubkeyHash(bytes32 pubkeyHash) view returns(address) -func (_ContractBLSApkRegistry *ContractBLSApkRegistrySession) GetOperatorFromPubkeyHash(pubkeyHash [32]byte) (common.Address, error) { - return _ContractBLSApkRegistry.Contract.GetOperatorFromPubkeyHash(&_ContractBLSApkRegistry.CallOpts, pubkeyHash) -} - -// GetOperatorFromPubkeyHash is a free data retrieval call binding the contract method 0x47b314e8. -// -// Solidity: function getOperatorFromPubkeyHash(bytes32 pubkeyHash) view returns(address) -func (_ContractBLSApkRegistry *ContractBLSApkRegistryCallerSession) GetOperatorFromPubkeyHash(pubkeyHash [32]byte) (common.Address, error) { - return _ContractBLSApkRegistry.Contract.GetOperatorFromPubkeyHash(&_ContractBLSApkRegistry.CallOpts, pubkeyHash) -} - -// GetOperatorId is a free data retrieval call binding the contract method 0x13542a4e. -// -// Solidity: function getOperatorId(address operator) view returns(bytes32) -func (_ContractBLSApkRegistry *ContractBLSApkRegistryCaller) GetOperatorId(opts *bind.CallOpts, operator common.Address) ([32]byte, error) { - var out []interface{} - err := _ContractBLSApkRegistry.contract.Call(opts, &out, "getOperatorId", operator) - - if err != nil { - return *new([32]byte), err - } - - out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) - - return out0, err - -} - -// GetOperatorId is a free data retrieval call binding the contract method 0x13542a4e. -// -// Solidity: function getOperatorId(address operator) view returns(bytes32) -func (_ContractBLSApkRegistry *ContractBLSApkRegistrySession) GetOperatorId(operator common.Address) ([32]byte, error) { - return _ContractBLSApkRegistry.Contract.GetOperatorId(&_ContractBLSApkRegistry.CallOpts, operator) -} - -// GetOperatorId is a free data retrieval call binding the contract method 0x13542a4e. -// -// Solidity: function getOperatorId(address operator) view returns(bytes32) -func (_ContractBLSApkRegistry *ContractBLSApkRegistryCallerSession) GetOperatorId(operator common.Address) ([32]byte, error) { - return _ContractBLSApkRegistry.Contract.GetOperatorId(&_ContractBLSApkRegistry.CallOpts, operator) -} - -// GetRegisteredPubkey is a free data retrieval call binding the contract method 0x7ff81a87. -// -// Solidity: function getRegisteredPubkey(address operator) view returns((uint256,uint256), bytes32) -func (_ContractBLSApkRegistry *ContractBLSApkRegistryCaller) GetRegisteredPubkey(opts *bind.CallOpts, operator common.Address) (BN254G1Point, [32]byte, error) { - var out []interface{} - err := _ContractBLSApkRegistry.contract.Call(opts, &out, "getRegisteredPubkey", operator) - - if err != nil { - return *new(BN254G1Point), *new([32]byte), err - } - - out0 := *abi.ConvertType(out[0], new(BN254G1Point)).(*BN254G1Point) - out1 := *abi.ConvertType(out[1], new([32]byte)).(*[32]byte) - - return out0, out1, err - -} - -// GetRegisteredPubkey is a free data retrieval call binding the contract method 0x7ff81a87. -// -// Solidity: function getRegisteredPubkey(address operator) view returns((uint256,uint256), bytes32) -func (_ContractBLSApkRegistry *ContractBLSApkRegistrySession) GetRegisteredPubkey(operator common.Address) (BN254G1Point, [32]byte, error) { - return _ContractBLSApkRegistry.Contract.GetRegisteredPubkey(&_ContractBLSApkRegistry.CallOpts, operator) -} - -// GetRegisteredPubkey is a free data retrieval call binding the contract method 0x7ff81a87. -// -// Solidity: function getRegisteredPubkey(address operator) view returns((uint256,uint256), bytes32) -func (_ContractBLSApkRegistry *ContractBLSApkRegistryCallerSession) GetRegisteredPubkey(operator common.Address) (BN254G1Point, [32]byte, error) { - return _ContractBLSApkRegistry.Contract.GetRegisteredPubkey(&_ContractBLSApkRegistry.CallOpts, operator) -} - -// OperatorToPubkey is a free data retrieval call binding the contract method 0x00a1f4cb. -// -// Solidity: function operatorToPubkey(address ) view returns(uint256 X, uint256 Y) -func (_ContractBLSApkRegistry *ContractBLSApkRegistryCaller) OperatorToPubkey(opts *bind.CallOpts, arg0 common.Address) (struct { - X *big.Int - Y *big.Int -}, error) { - var out []interface{} - err := _ContractBLSApkRegistry.contract.Call(opts, &out, "operatorToPubkey", arg0) - - outstruct := new(struct { - X *big.Int - Y *big.Int - }) - if err != nil { - return *outstruct, err - } - - outstruct.X = *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - outstruct.Y = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) - - return *outstruct, err - -} - -// OperatorToPubkey is a free data retrieval call binding the contract method 0x00a1f4cb. -// -// Solidity: function operatorToPubkey(address ) view returns(uint256 X, uint256 Y) -func (_ContractBLSApkRegistry *ContractBLSApkRegistrySession) OperatorToPubkey(arg0 common.Address) (struct { - X *big.Int - Y *big.Int -}, error) { - return _ContractBLSApkRegistry.Contract.OperatorToPubkey(&_ContractBLSApkRegistry.CallOpts, arg0) -} - -// OperatorToPubkey is a free data retrieval call binding the contract method 0x00a1f4cb. -// -// Solidity: function operatorToPubkey(address ) view returns(uint256 X, uint256 Y) -func (_ContractBLSApkRegistry *ContractBLSApkRegistryCallerSession) OperatorToPubkey(arg0 common.Address) (struct { - X *big.Int - Y *big.Int -}, error) { - return _ContractBLSApkRegistry.Contract.OperatorToPubkey(&_ContractBLSApkRegistry.CallOpts, arg0) -} - -// OperatorToPubkeyHash is a free data retrieval call binding the contract method 0xde29fac0. -// -// Solidity: function operatorToPubkeyHash(address ) view returns(bytes32) -func (_ContractBLSApkRegistry *ContractBLSApkRegistryCaller) OperatorToPubkeyHash(opts *bind.CallOpts, arg0 common.Address) ([32]byte, error) { - var out []interface{} - err := _ContractBLSApkRegistry.contract.Call(opts, &out, "operatorToPubkeyHash", arg0) - - if err != nil { - return *new([32]byte), err - } - - out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) - - return out0, err - -} - -// OperatorToPubkeyHash is a free data retrieval call binding the contract method 0xde29fac0. -// -// Solidity: function operatorToPubkeyHash(address ) view returns(bytes32) -func (_ContractBLSApkRegistry *ContractBLSApkRegistrySession) OperatorToPubkeyHash(arg0 common.Address) ([32]byte, error) { - return _ContractBLSApkRegistry.Contract.OperatorToPubkeyHash(&_ContractBLSApkRegistry.CallOpts, arg0) -} - -// OperatorToPubkeyHash is a free data retrieval call binding the contract method 0xde29fac0. -// -// Solidity: function operatorToPubkeyHash(address ) view returns(bytes32) -func (_ContractBLSApkRegistry *ContractBLSApkRegistryCallerSession) OperatorToPubkeyHash(arg0 common.Address) ([32]byte, error) { - return _ContractBLSApkRegistry.Contract.OperatorToPubkeyHash(&_ContractBLSApkRegistry.CallOpts, arg0) -} - -// PubkeyHashToOperator is a free data retrieval call binding the contract method 0xe8bb9ae6. -// -// Solidity: function pubkeyHashToOperator(bytes32 ) view returns(address) -func (_ContractBLSApkRegistry *ContractBLSApkRegistryCaller) PubkeyHashToOperator(opts *bind.CallOpts, arg0 [32]byte) (common.Address, error) { - var out []interface{} - err := _ContractBLSApkRegistry.contract.Call(opts, &out, "pubkeyHashToOperator", arg0) - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// PubkeyHashToOperator is a free data retrieval call binding the contract method 0xe8bb9ae6. -// -// Solidity: function pubkeyHashToOperator(bytes32 ) view returns(address) -func (_ContractBLSApkRegistry *ContractBLSApkRegistrySession) PubkeyHashToOperator(arg0 [32]byte) (common.Address, error) { - return _ContractBLSApkRegistry.Contract.PubkeyHashToOperator(&_ContractBLSApkRegistry.CallOpts, arg0) -} - -// PubkeyHashToOperator is a free data retrieval call binding the contract method 0xe8bb9ae6. -// -// Solidity: function pubkeyHashToOperator(bytes32 ) view returns(address) -func (_ContractBLSApkRegistry *ContractBLSApkRegistryCallerSession) PubkeyHashToOperator(arg0 [32]byte) (common.Address, error) { - return _ContractBLSApkRegistry.Contract.PubkeyHashToOperator(&_ContractBLSApkRegistry.CallOpts, arg0) -} - -// RegistryCoordinator is a free data retrieval call binding the contract method 0x6d14a987. -// -// Solidity: function registryCoordinator() view returns(address) -func (_ContractBLSApkRegistry *ContractBLSApkRegistryCaller) RegistryCoordinator(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _ContractBLSApkRegistry.contract.Call(opts, &out, "registryCoordinator") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// RegistryCoordinator is a free data retrieval call binding the contract method 0x6d14a987. -// -// Solidity: function registryCoordinator() view returns(address) -func (_ContractBLSApkRegistry *ContractBLSApkRegistrySession) RegistryCoordinator() (common.Address, error) { - return _ContractBLSApkRegistry.Contract.RegistryCoordinator(&_ContractBLSApkRegistry.CallOpts) -} - -// RegistryCoordinator is a free data retrieval call binding the contract method 0x6d14a987. -// -// Solidity: function registryCoordinator() view returns(address) -func (_ContractBLSApkRegistry *ContractBLSApkRegistryCallerSession) RegistryCoordinator() (common.Address, error) { - return _ContractBLSApkRegistry.Contract.RegistryCoordinator(&_ContractBLSApkRegistry.CallOpts) -} - -// DeregisterOperator is a paid mutator transaction binding the contract method 0xf4e24fe5. -// -// Solidity: function deregisterOperator(address operator, bytes quorumNumbers) returns() -func (_ContractBLSApkRegistry *ContractBLSApkRegistryTransactor) DeregisterOperator(opts *bind.TransactOpts, operator common.Address, quorumNumbers []byte) (*types.Transaction, error) { - return _ContractBLSApkRegistry.contract.Transact(opts, "deregisterOperator", operator, quorumNumbers) -} - -// DeregisterOperator is a paid mutator transaction binding the contract method 0xf4e24fe5. -// -// Solidity: function deregisterOperator(address operator, bytes quorumNumbers) returns() -func (_ContractBLSApkRegistry *ContractBLSApkRegistrySession) DeregisterOperator(operator common.Address, quorumNumbers []byte) (*types.Transaction, error) { - return _ContractBLSApkRegistry.Contract.DeregisterOperator(&_ContractBLSApkRegistry.TransactOpts, operator, quorumNumbers) -} - -// DeregisterOperator is a paid mutator transaction binding the contract method 0xf4e24fe5. -// -// Solidity: function deregisterOperator(address operator, bytes quorumNumbers) returns() -func (_ContractBLSApkRegistry *ContractBLSApkRegistryTransactorSession) DeregisterOperator(operator common.Address, quorumNumbers []byte) (*types.Transaction, error) { - return _ContractBLSApkRegistry.Contract.DeregisterOperator(&_ContractBLSApkRegistry.TransactOpts, operator, quorumNumbers) -} - -// InitializeQuorum is a paid mutator transaction binding the contract method 0x26d941f2. -// -// Solidity: function initializeQuorum(uint8 quorumNumber) returns() -func (_ContractBLSApkRegistry *ContractBLSApkRegistryTransactor) InitializeQuorum(opts *bind.TransactOpts, quorumNumber uint8) (*types.Transaction, error) { - return _ContractBLSApkRegistry.contract.Transact(opts, "initializeQuorum", quorumNumber) -} - -// InitializeQuorum is a paid mutator transaction binding the contract method 0x26d941f2. -// -// Solidity: function initializeQuorum(uint8 quorumNumber) returns() -func (_ContractBLSApkRegistry *ContractBLSApkRegistrySession) InitializeQuorum(quorumNumber uint8) (*types.Transaction, error) { - return _ContractBLSApkRegistry.Contract.InitializeQuorum(&_ContractBLSApkRegistry.TransactOpts, quorumNumber) -} - -// InitializeQuorum is a paid mutator transaction binding the contract method 0x26d941f2. -// -// Solidity: function initializeQuorum(uint8 quorumNumber) returns() -func (_ContractBLSApkRegistry *ContractBLSApkRegistryTransactorSession) InitializeQuorum(quorumNumber uint8) (*types.Transaction, error) { - return _ContractBLSApkRegistry.Contract.InitializeQuorum(&_ContractBLSApkRegistry.TransactOpts, quorumNumber) -} - -// RegisterBLSPublicKey is a paid mutator transaction binding the contract method 0xbf79ce58. -// -// Solidity: function registerBLSPublicKey(address operator, ((uint256,uint256),(uint256,uint256),(uint256[2],uint256[2])) params, (uint256,uint256) pubkeyRegistrationMessageHash) returns(bytes32 operatorId) -func (_ContractBLSApkRegistry *ContractBLSApkRegistryTransactor) RegisterBLSPublicKey(opts *bind.TransactOpts, operator common.Address, params IBLSApkRegistryPubkeyRegistrationParams, pubkeyRegistrationMessageHash BN254G1Point) (*types.Transaction, error) { - return _ContractBLSApkRegistry.contract.Transact(opts, "registerBLSPublicKey", operator, params, pubkeyRegistrationMessageHash) -} - -// RegisterBLSPublicKey is a paid mutator transaction binding the contract method 0xbf79ce58. -// -// Solidity: function registerBLSPublicKey(address operator, ((uint256,uint256),(uint256,uint256),(uint256[2],uint256[2])) params, (uint256,uint256) pubkeyRegistrationMessageHash) returns(bytes32 operatorId) -func (_ContractBLSApkRegistry *ContractBLSApkRegistrySession) RegisterBLSPublicKey(operator common.Address, params IBLSApkRegistryPubkeyRegistrationParams, pubkeyRegistrationMessageHash BN254G1Point) (*types.Transaction, error) { - return _ContractBLSApkRegistry.Contract.RegisterBLSPublicKey(&_ContractBLSApkRegistry.TransactOpts, operator, params, pubkeyRegistrationMessageHash) -} - -// RegisterBLSPublicKey is a paid mutator transaction binding the contract method 0xbf79ce58. -// -// Solidity: function registerBLSPublicKey(address operator, ((uint256,uint256),(uint256,uint256),(uint256[2],uint256[2])) params, (uint256,uint256) pubkeyRegistrationMessageHash) returns(bytes32 operatorId) -func (_ContractBLSApkRegistry *ContractBLSApkRegistryTransactorSession) RegisterBLSPublicKey(operator common.Address, params IBLSApkRegistryPubkeyRegistrationParams, pubkeyRegistrationMessageHash BN254G1Point) (*types.Transaction, error) { - return _ContractBLSApkRegistry.Contract.RegisterBLSPublicKey(&_ContractBLSApkRegistry.TransactOpts, operator, params, pubkeyRegistrationMessageHash) -} - -// RegisterOperator is a paid mutator transaction binding the contract method 0x3fb27952. -// -// Solidity: function registerOperator(address operator, bytes quorumNumbers) returns() -func (_ContractBLSApkRegistry *ContractBLSApkRegistryTransactor) RegisterOperator(opts *bind.TransactOpts, operator common.Address, quorumNumbers []byte) (*types.Transaction, error) { - return _ContractBLSApkRegistry.contract.Transact(opts, "registerOperator", operator, quorumNumbers) -} - -// RegisterOperator is a paid mutator transaction binding the contract method 0x3fb27952. -// -// Solidity: function registerOperator(address operator, bytes quorumNumbers) returns() -func (_ContractBLSApkRegistry *ContractBLSApkRegistrySession) RegisterOperator(operator common.Address, quorumNumbers []byte) (*types.Transaction, error) { - return _ContractBLSApkRegistry.Contract.RegisterOperator(&_ContractBLSApkRegistry.TransactOpts, operator, quorumNumbers) -} - -// RegisterOperator is a paid mutator transaction binding the contract method 0x3fb27952. -// -// Solidity: function registerOperator(address operator, bytes quorumNumbers) returns() -func (_ContractBLSApkRegistry *ContractBLSApkRegistryTransactorSession) RegisterOperator(operator common.Address, quorumNumbers []byte) (*types.Transaction, error) { - return _ContractBLSApkRegistry.Contract.RegisterOperator(&_ContractBLSApkRegistry.TransactOpts, operator, quorumNumbers) -} - -// ContractBLSApkRegistryInitializedIterator is returned from FilterInitialized and is used to iterate over the raw logs and unpacked data for Initialized events raised by the ContractBLSApkRegistry contract. -type ContractBLSApkRegistryInitializedIterator struct { - Event *ContractBLSApkRegistryInitialized // 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 *ContractBLSApkRegistryInitializedIterator) 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(ContractBLSApkRegistryInitialized) - 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(ContractBLSApkRegistryInitialized) - 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 *ContractBLSApkRegistryInitializedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ContractBLSApkRegistryInitializedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ContractBLSApkRegistryInitialized represents a Initialized event raised by the ContractBLSApkRegistry contract. -type ContractBLSApkRegistryInitialized 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 (_ContractBLSApkRegistry *ContractBLSApkRegistryFilterer) FilterInitialized(opts *bind.FilterOpts) (*ContractBLSApkRegistryInitializedIterator, error) { - - logs, sub, err := _ContractBLSApkRegistry.contract.FilterLogs(opts, "Initialized") - if err != nil { - return nil, err - } - return &ContractBLSApkRegistryInitializedIterator{contract: _ContractBLSApkRegistry.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 (_ContractBLSApkRegistry *ContractBLSApkRegistryFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *ContractBLSApkRegistryInitialized) (event.Subscription, error) { - - logs, sub, err := _ContractBLSApkRegistry.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(ContractBLSApkRegistryInitialized) - if err := _ContractBLSApkRegistry.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 (_ContractBLSApkRegistry *ContractBLSApkRegistryFilterer) ParseInitialized(log types.Log) (*ContractBLSApkRegistryInitialized, error) { - event := new(ContractBLSApkRegistryInitialized) - if err := _ContractBLSApkRegistry.contract.UnpackLog(event, "Initialized", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ContractBLSApkRegistryNewPubkeyRegistrationIterator is returned from FilterNewPubkeyRegistration and is used to iterate over the raw logs and unpacked data for NewPubkeyRegistration events raised by the ContractBLSApkRegistry contract. -type ContractBLSApkRegistryNewPubkeyRegistrationIterator struct { - Event *ContractBLSApkRegistryNewPubkeyRegistration // 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 *ContractBLSApkRegistryNewPubkeyRegistrationIterator) 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(ContractBLSApkRegistryNewPubkeyRegistration) - 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(ContractBLSApkRegistryNewPubkeyRegistration) - 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 *ContractBLSApkRegistryNewPubkeyRegistrationIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ContractBLSApkRegistryNewPubkeyRegistrationIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ContractBLSApkRegistryNewPubkeyRegistration represents a NewPubkeyRegistration event raised by the ContractBLSApkRegistry contract. -type ContractBLSApkRegistryNewPubkeyRegistration struct { - Operator common.Address - PubkeyG1 BN254G1Point - PubkeyG2 BN254G2Point - Raw types.Log // Blockchain specific contextual infos -} - -// FilterNewPubkeyRegistration is a free log retrieval operation binding the contract event 0xe3fb6613af2e8930cf85d47fcf6db10192224a64c6cbe8023e0eee1ba3828041. -// -// Solidity: event NewPubkeyRegistration(address indexed operator, (uint256,uint256) pubkeyG1, (uint256[2],uint256[2]) pubkeyG2) -func (_ContractBLSApkRegistry *ContractBLSApkRegistryFilterer) FilterNewPubkeyRegistration(opts *bind.FilterOpts, operator []common.Address) (*ContractBLSApkRegistryNewPubkeyRegistrationIterator, error) { - - var operatorRule []interface{} - for _, operatorItem := range operator { - operatorRule = append(operatorRule, operatorItem) - } - - logs, sub, err := _ContractBLSApkRegistry.contract.FilterLogs(opts, "NewPubkeyRegistration", operatorRule) - if err != nil { - return nil, err - } - return &ContractBLSApkRegistryNewPubkeyRegistrationIterator{contract: _ContractBLSApkRegistry.contract, event: "NewPubkeyRegistration", logs: logs, sub: sub}, nil -} - -// WatchNewPubkeyRegistration is a free log subscription operation binding the contract event 0xe3fb6613af2e8930cf85d47fcf6db10192224a64c6cbe8023e0eee1ba3828041. -// -// Solidity: event NewPubkeyRegistration(address indexed operator, (uint256,uint256) pubkeyG1, (uint256[2],uint256[2]) pubkeyG2) -func (_ContractBLSApkRegistry *ContractBLSApkRegistryFilterer) WatchNewPubkeyRegistration(opts *bind.WatchOpts, sink chan<- *ContractBLSApkRegistryNewPubkeyRegistration, operator []common.Address) (event.Subscription, error) { - - var operatorRule []interface{} - for _, operatorItem := range operator { - operatorRule = append(operatorRule, operatorItem) - } - - logs, sub, err := _ContractBLSApkRegistry.contract.WatchLogs(opts, "NewPubkeyRegistration", operatorRule) - 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(ContractBLSApkRegistryNewPubkeyRegistration) - if err := _ContractBLSApkRegistry.contract.UnpackLog(event, "NewPubkeyRegistration", 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 -} - -// ParseNewPubkeyRegistration is a log parse operation binding the contract event 0xe3fb6613af2e8930cf85d47fcf6db10192224a64c6cbe8023e0eee1ba3828041. -// -// Solidity: event NewPubkeyRegistration(address indexed operator, (uint256,uint256) pubkeyG1, (uint256[2],uint256[2]) pubkeyG2) -func (_ContractBLSApkRegistry *ContractBLSApkRegistryFilterer) ParseNewPubkeyRegistration(log types.Log) (*ContractBLSApkRegistryNewPubkeyRegistration, error) { - event := new(ContractBLSApkRegistryNewPubkeyRegistration) - if err := _ContractBLSApkRegistry.contract.UnpackLog(event, "NewPubkeyRegistration", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ContractBLSApkRegistryOperatorAddedToQuorumsIterator is returned from FilterOperatorAddedToQuorums and is used to iterate over the raw logs and unpacked data for OperatorAddedToQuorums events raised by the ContractBLSApkRegistry contract. -type ContractBLSApkRegistryOperatorAddedToQuorumsIterator struct { - Event *ContractBLSApkRegistryOperatorAddedToQuorums // 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 *ContractBLSApkRegistryOperatorAddedToQuorumsIterator) 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(ContractBLSApkRegistryOperatorAddedToQuorums) - 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(ContractBLSApkRegistryOperatorAddedToQuorums) - 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 *ContractBLSApkRegistryOperatorAddedToQuorumsIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ContractBLSApkRegistryOperatorAddedToQuorumsIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ContractBLSApkRegistryOperatorAddedToQuorums represents a OperatorAddedToQuorums event raised by the ContractBLSApkRegistry contract. -type ContractBLSApkRegistryOperatorAddedToQuorums struct { - Operator common.Address - QuorumNumbers []byte - Raw types.Log // Blockchain specific contextual infos -} - -// FilterOperatorAddedToQuorums is a free log retrieval operation binding the contract event 0x5358c5b42179178c8fc757734ac2a3198f9071c765ee0d8389211525f5005246. -// -// Solidity: event OperatorAddedToQuorums(address operator, bytes quorumNumbers) -func (_ContractBLSApkRegistry *ContractBLSApkRegistryFilterer) FilterOperatorAddedToQuorums(opts *bind.FilterOpts) (*ContractBLSApkRegistryOperatorAddedToQuorumsIterator, error) { - - logs, sub, err := _ContractBLSApkRegistry.contract.FilterLogs(opts, "OperatorAddedToQuorums") - if err != nil { - return nil, err - } - return &ContractBLSApkRegistryOperatorAddedToQuorumsIterator{contract: _ContractBLSApkRegistry.contract, event: "OperatorAddedToQuorums", logs: logs, sub: sub}, nil -} - -// WatchOperatorAddedToQuorums is a free log subscription operation binding the contract event 0x5358c5b42179178c8fc757734ac2a3198f9071c765ee0d8389211525f5005246. -// -// Solidity: event OperatorAddedToQuorums(address operator, bytes quorumNumbers) -func (_ContractBLSApkRegistry *ContractBLSApkRegistryFilterer) WatchOperatorAddedToQuorums(opts *bind.WatchOpts, sink chan<- *ContractBLSApkRegistryOperatorAddedToQuorums) (event.Subscription, error) { - - logs, sub, err := _ContractBLSApkRegistry.contract.WatchLogs(opts, "OperatorAddedToQuorums") - 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(ContractBLSApkRegistryOperatorAddedToQuorums) - if err := _ContractBLSApkRegistry.contract.UnpackLog(event, "OperatorAddedToQuorums", 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 -} - -// ParseOperatorAddedToQuorums is a log parse operation binding the contract event 0x5358c5b42179178c8fc757734ac2a3198f9071c765ee0d8389211525f5005246. -// -// Solidity: event OperatorAddedToQuorums(address operator, bytes quorumNumbers) -func (_ContractBLSApkRegistry *ContractBLSApkRegistryFilterer) ParseOperatorAddedToQuorums(log types.Log) (*ContractBLSApkRegistryOperatorAddedToQuorums, error) { - event := new(ContractBLSApkRegistryOperatorAddedToQuorums) - if err := _ContractBLSApkRegistry.contract.UnpackLog(event, "OperatorAddedToQuorums", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ContractBLSApkRegistryOperatorRemovedFromQuorumsIterator is returned from FilterOperatorRemovedFromQuorums and is used to iterate over the raw logs and unpacked data for OperatorRemovedFromQuorums events raised by the ContractBLSApkRegistry contract. -type ContractBLSApkRegistryOperatorRemovedFromQuorumsIterator struct { - Event *ContractBLSApkRegistryOperatorRemovedFromQuorums // 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 *ContractBLSApkRegistryOperatorRemovedFromQuorumsIterator) 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(ContractBLSApkRegistryOperatorRemovedFromQuorums) - 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(ContractBLSApkRegistryOperatorRemovedFromQuorums) - 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 *ContractBLSApkRegistryOperatorRemovedFromQuorumsIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ContractBLSApkRegistryOperatorRemovedFromQuorumsIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ContractBLSApkRegistryOperatorRemovedFromQuorums represents a OperatorRemovedFromQuorums event raised by the ContractBLSApkRegistry contract. -type ContractBLSApkRegistryOperatorRemovedFromQuorums struct { - Operator common.Address - QuorumNumbers []byte - Raw types.Log // Blockchain specific contextual infos -} - -// FilterOperatorRemovedFromQuorums is a free log retrieval operation binding the contract event 0x14a5172b312e9d2c22b8468f9c70ec2caa9de934fe380734fbc6f3beff2b14ba. -// -// Solidity: event OperatorRemovedFromQuorums(address operator, bytes quorumNumbers) -func (_ContractBLSApkRegistry *ContractBLSApkRegistryFilterer) FilterOperatorRemovedFromQuorums(opts *bind.FilterOpts) (*ContractBLSApkRegistryOperatorRemovedFromQuorumsIterator, error) { - - logs, sub, err := _ContractBLSApkRegistry.contract.FilterLogs(opts, "OperatorRemovedFromQuorums") - if err != nil { - return nil, err - } - return &ContractBLSApkRegistryOperatorRemovedFromQuorumsIterator{contract: _ContractBLSApkRegistry.contract, event: "OperatorRemovedFromQuorums", logs: logs, sub: sub}, nil -} - -// WatchOperatorRemovedFromQuorums is a free log subscription operation binding the contract event 0x14a5172b312e9d2c22b8468f9c70ec2caa9de934fe380734fbc6f3beff2b14ba. -// -// Solidity: event OperatorRemovedFromQuorums(address operator, bytes quorumNumbers) -func (_ContractBLSApkRegistry *ContractBLSApkRegistryFilterer) WatchOperatorRemovedFromQuorums(opts *bind.WatchOpts, sink chan<- *ContractBLSApkRegistryOperatorRemovedFromQuorums) (event.Subscription, error) { - - logs, sub, err := _ContractBLSApkRegistry.contract.WatchLogs(opts, "OperatorRemovedFromQuorums") - 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(ContractBLSApkRegistryOperatorRemovedFromQuorums) - if err := _ContractBLSApkRegistry.contract.UnpackLog(event, "OperatorRemovedFromQuorums", 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 -} - -// ParseOperatorRemovedFromQuorums is a log parse operation binding the contract event 0x14a5172b312e9d2c22b8468f9c70ec2caa9de934fe380734fbc6f3beff2b14ba. -// -// Solidity: event OperatorRemovedFromQuorums(address operator, bytes quorumNumbers) -func (_ContractBLSApkRegistry *ContractBLSApkRegistryFilterer) ParseOperatorRemovedFromQuorums(log types.Log) (*ContractBLSApkRegistryOperatorRemovedFromQuorums, error) { - event := new(ContractBLSApkRegistryOperatorRemovedFromQuorums) - if err := _ContractBLSApkRegistry.contract.UnpackLog(event, "OperatorRemovedFromQuorums", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} diff --git a/contracts/bindings/DelegationManager/binding.go b/contracts/bindings/DelegationManager/binding.go deleted file mode 100644 index 6f5aa25..0000000 --- a/contracts/bindings/DelegationManager/binding.go +++ /dev/null @@ -1,4541 +0,0 @@ -// Code generated - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package contractDelegationManager - -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 -) - -// IDelegationManagerOperatorDetails is an auto generated low-level Go binding around an user-defined struct. -type IDelegationManagerOperatorDetails struct { - EarningsReceiver common.Address - DelegationApprover common.Address - StakerOptOutWindowBlocks uint32 -} - -// IDelegationManagerQueuedWithdrawalParams is an auto generated low-level Go binding around an user-defined struct. -type IDelegationManagerQueuedWithdrawalParams struct { - Strategies []common.Address - Shares []*big.Int - Withdrawer common.Address -} - -// IDelegationManagerWithdrawal is an auto generated low-level Go binding around an user-defined struct. -type IDelegationManagerWithdrawal struct { - Staker common.Address - DelegatedTo common.Address - Withdrawer common.Address - Nonce *big.Int - StartBlock uint32 - Strategies []common.Address - Shares []*big.Int -} - -// ISignatureUtilsSignatureWithExpiry is an auto generated low-level Go binding around an user-defined struct. -type ISignatureUtilsSignatureWithExpiry struct { - Signature []byte - Expiry *big.Int -} - -// IStrategyManagerDeprecatedStructQueuedWithdrawal is an auto generated low-level Go binding around an user-defined struct. -type IStrategyManagerDeprecatedStructQueuedWithdrawal struct { - Strategies []common.Address - Shares []*big.Int - Staker common.Address - WithdrawerAndNonce IStrategyManagerDeprecatedStructWithdrawerAndNonce - WithdrawalStartBlock uint32 - DelegatedAddress common.Address -} - -// IStrategyManagerDeprecatedStructWithdrawerAndNonce is an auto generated low-level Go binding around an user-defined struct. -type IStrategyManagerDeprecatedStructWithdrawerAndNonce struct { - Withdrawer common.Address - Nonce *big.Int -} - -// ContractDelegationManagerMetaData contains all meta data concerning the ContractDelegationManager contract. -var ContractDelegationManagerMetaData = &bind.MetaData{ - ABI: "[{\"type\":\"constructor\",\"inputs\":[{\"name\":\"_strategyManager\",\"type\":\"address\",\"internalType\":\"contractIStrategyManager\"},{\"name\":\"_slasher\",\"type\":\"address\",\"internalType\":\"contractISlasher\"},{\"name\":\"_eigenPodManager\",\"type\":\"address\",\"internalType\":\"contractIEigenPodManager\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"DELEGATION_APPROVAL_TYPEHASH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"DOMAIN_TYPEHASH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"MAX_STAKER_OPT_OUT_WINDOW_BLOCKS\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"MAX_WITHDRAWAL_DELAY_BLOCKS\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"STAKER_DELEGATION_TYPEHASH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"beaconChainETHStrategy\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"calculateCurrentStakerDelegationDigestHash\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"calculateDelegationApprovalDigestHash\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"_delegationApprover\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"approverSalt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"calculateStakerDelegationDigestHash\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"_stakerNonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"calculateWithdrawalRoot\",\"inputs\":[{\"name\":\"withdrawal\",\"type\":\"tuple\",\"internalType\":\"structIDelegationManager.Withdrawal\",\"components\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delegatedTo\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"withdrawer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"startBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"shares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"pure\"},{\"type\":\"function\",\"name\":\"completeQueuedWithdrawal\",\"inputs\":[{\"name\":\"withdrawal\",\"type\":\"tuple\",\"internalType\":\"structIDelegationManager.Withdrawal\",\"components\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delegatedTo\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"withdrawer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"startBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"shares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]},{\"name\":\"tokens\",\"type\":\"address[]\",\"internalType\":\"contractIERC20[]\"},{\"name\":\"middlewareTimesIndex\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"receiveAsTokens\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"completeQueuedWithdrawals\",\"inputs\":[{\"name\":\"withdrawals\",\"type\":\"tuple[]\",\"internalType\":\"structIDelegationManager.Withdrawal[]\",\"components\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delegatedTo\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"withdrawer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"startBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"shares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]},{\"name\":\"tokens\",\"type\":\"address[][]\",\"internalType\":\"contractIERC20[][]\"},{\"name\":\"middlewareTimesIndexes\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"},{\"name\":\"receiveAsTokens\",\"type\":\"bool[]\",\"internalType\":\"bool[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"cumulativeWithdrawalsQueued\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"decreaseDelegatedShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"shares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"delegateTo\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"approverSignatureAndExpiry\",\"type\":\"tuple\",\"internalType\":\"structISignatureUtils.SignatureWithExpiry\",\"components\":[{\"name\":\"signature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"approverSalt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"delegateToBySignature\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"stakerSignatureAndExpiry\",\"type\":\"tuple\",\"internalType\":\"structISignatureUtils.SignatureWithExpiry\",\"components\":[{\"name\":\"signature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"approverSignatureAndExpiry\",\"type\":\"tuple\",\"internalType\":\"structISignatureUtils.SignatureWithExpiry\",\"components\":[{\"name\":\"signature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"approverSalt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"delegatedTo\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"delegationApprover\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"delegationApproverSaltIsSpent\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"domainSeparator\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"earningsReceiver\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"eigenPodManager\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIEigenPodManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getDelegatableShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getOperatorShares\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getWithdrawalDelay\",\"inputs\":[{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"increaseDelegatedShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"shares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[{\"name\":\"initialOwner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"_pauserRegistry\",\"type\":\"address\",\"internalType\":\"contractIPauserRegistry\"},{\"name\":\"initialPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"_minWithdrawalDelayBlocks\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"_strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"_withdrawalDelayBlocks\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"isDelegated\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"isOperator\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"migrateQueuedWithdrawals\",\"inputs\":[{\"name\":\"withdrawalsToMigrate\",\"type\":\"tuple[]\",\"internalType\":\"structIStrategyManager.DeprecatedStruct_QueuedWithdrawal[]\",\"components\":[{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"shares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"},{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"withdrawerAndNonce\",\"type\":\"tuple\",\"internalType\":\"structIStrategyManager.DeprecatedStruct_WithdrawerAndNonce\",\"components\":[{\"name\":\"withdrawer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"nonce\",\"type\":\"uint96\",\"internalType\":\"uint96\"}]},{\"name\":\"withdrawalStartBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"delegatedAddress\",\"type\":\"address\",\"internalType\":\"address\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"minWithdrawalDelayBlocks\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"modifyOperatorDetails\",\"inputs\":[{\"name\":\"newOperatorDetails\",\"type\":\"tuple\",\"internalType\":\"structIDelegationManager.OperatorDetails\",\"components\":[{\"name\":\"earningsReceiver\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delegationApprover\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"stakerOptOutWindowBlocks\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"operatorDetails\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structIDelegationManager.OperatorDetails\",\"components\":[{\"name\":\"earningsReceiver\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delegationApprover\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"stakerOptOutWindowBlocks\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"operatorShares\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"owner\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pause\",\"inputs\":[{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"pauseAll\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[{\"name\":\"index\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pauserRegistry\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIPauserRegistry\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pendingWithdrawals\",\"inputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"queueWithdrawals\",\"inputs\":[{\"name\":\"queuedWithdrawalParams\",\"type\":\"tuple[]\",\"internalType\":\"structIDelegationManager.QueuedWithdrawalParams[]\",\"components\":[{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"shares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"},{\"name\":\"withdrawer\",\"type\":\"address\",\"internalType\":\"address\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32[]\",\"internalType\":\"bytes32[]\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"registerAsOperator\",\"inputs\":[{\"name\":\"registeringOperatorDetails\",\"type\":\"tuple\",\"internalType\":\"structIDelegationManager.OperatorDetails\",\"components\":[{\"name\":\"earningsReceiver\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delegationApprover\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"stakerOptOutWindowBlocks\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"metadataURI\",\"type\":\"string\",\"internalType\":\"string\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"renounceOwnership\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setPauserRegistry\",\"inputs\":[{\"name\":\"newPauserRegistry\",\"type\":\"address\",\"internalType\":\"contractIPauserRegistry\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setStrategyWithdrawalDelayBlocks\",\"inputs\":[{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"withdrawalDelayBlocks\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"slasher\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractISlasher\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"stakerNonce\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"stakerOptOutWindowBlocks\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"strategyManager\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIStrategyManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"strategyWithdrawalDelayBlocks\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"transferOwnership\",\"inputs\":[{\"name\":\"newOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"undelegate\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"withdrawalRoots\",\"type\":\"bytes32[]\",\"internalType\":\"bytes32[]\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"unpause\",\"inputs\":[{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"updateOperatorMetadataURI\",\"inputs\":[{\"name\":\"metadataURI\",\"type\":\"string\",\"internalType\":\"string\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"Initialized\",\"inputs\":[{\"name\":\"version\",\"type\":\"uint8\",\"indexed\":false,\"internalType\":\"uint8\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"MinWithdrawalDelayBlocksSet\",\"inputs\":[{\"name\":\"previousValue\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"},{\"name\":\"newValue\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorDetailsModified\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newOperatorDetails\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structIDelegationManager.OperatorDetails\",\"components\":[{\"name\":\"earningsReceiver\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delegationApprover\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"stakerOptOutWindowBlocks\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorMetadataURIUpdated\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"metadataURI\",\"type\":\"string\",\"indexed\":false,\"internalType\":\"string\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorRegistered\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"operatorDetails\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structIDelegationManager.OperatorDetails\",\"components\":[{\"name\":\"earningsReceiver\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delegationApprover\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"stakerOptOutWindowBlocks\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorSharesDecreased\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"staker\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"shares\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorSharesIncreased\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"staker\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"shares\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OwnershipTransferred\",\"inputs\":[{\"name\":\"previousOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Paused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"PauserRegistrySet\",\"inputs\":[{\"name\":\"pauserRegistry\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIPauserRegistry\"},{\"name\":\"newPauserRegistry\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIPauserRegistry\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StakerDelegated\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StakerForceUndelegated\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StakerUndelegated\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StrategyWithdrawalDelayBlocksSet\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"previousValue\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"},{\"name\":\"newValue\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Unpaused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"WithdrawalCompleted\",\"inputs\":[{\"name\":\"withdrawalRoot\",\"type\":\"bytes32\",\"indexed\":false,\"internalType\":\"bytes32\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"WithdrawalMigrated\",\"inputs\":[{\"name\":\"oldWithdrawalRoot\",\"type\":\"bytes32\",\"indexed\":false,\"internalType\":\"bytes32\"},{\"name\":\"newWithdrawalRoot\",\"type\":\"bytes32\",\"indexed\":false,\"internalType\":\"bytes32\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"WithdrawalQueued\",\"inputs\":[{\"name\":\"withdrawalRoot\",\"type\":\"bytes32\",\"indexed\":false,\"internalType\":\"bytes32\"},{\"name\":\"withdrawal\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structIDelegationManager.Withdrawal\",\"components\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"delegatedTo\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"withdrawer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"nonce\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"startBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"shares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]}],\"anonymous\":false}]", - Bin: "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", -} - -// ContractDelegationManagerABI is the input ABI used to generate the binding from. -// Deprecated: Use ContractDelegationManagerMetaData.ABI instead. -var ContractDelegationManagerABI = ContractDelegationManagerMetaData.ABI - -// ContractDelegationManagerBin is the compiled bytecode used for deploying new contracts. -// Deprecated: Use ContractDelegationManagerMetaData.Bin instead. -var ContractDelegationManagerBin = ContractDelegationManagerMetaData.Bin - -// DeployContractDelegationManager deploys a new Ethereum contract, binding an instance of ContractDelegationManager to it. -func DeployContractDelegationManager(auth *bind.TransactOpts, backend bind.ContractBackend, _strategyManager common.Address, _slasher common.Address, _eigenPodManager common.Address) (common.Address, *types.Transaction, *ContractDelegationManager, error) { - parsed, err := ContractDelegationManagerMetaData.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(ContractDelegationManagerBin), backend, _strategyManager, _slasher, _eigenPodManager) - if err != nil { - return common.Address{}, nil, nil, err - } - return address, tx, &ContractDelegationManager{ContractDelegationManagerCaller: ContractDelegationManagerCaller{contract: contract}, ContractDelegationManagerTransactor: ContractDelegationManagerTransactor{contract: contract}, ContractDelegationManagerFilterer: ContractDelegationManagerFilterer{contract: contract}}, nil -} - -// ContractDelegationManagerMethods is an auto generated interface around an Ethereum contract. -type ContractDelegationManagerMethods interface { - ContractDelegationManagerCalls - ContractDelegationManagerTransacts - ContractDelegationManagerFilters -} - -// ContractDelegationManagerCalls is an auto generated interface that defines the call methods available for an Ethereum contract. -type ContractDelegationManagerCalls interface { - DELEGATIONAPPROVALTYPEHASH(opts *bind.CallOpts) ([32]byte, error) - - DOMAINTYPEHASH(opts *bind.CallOpts) ([32]byte, error) - - MAXSTAKEROPTOUTWINDOWBLOCKS(opts *bind.CallOpts) (*big.Int, error) - - MAXWITHDRAWALDELAYBLOCKS(opts *bind.CallOpts) (*big.Int, error) - - STAKERDELEGATIONTYPEHASH(opts *bind.CallOpts) ([32]byte, error) - - BeaconChainETHStrategy(opts *bind.CallOpts) (common.Address, error) - - CalculateCurrentStakerDelegationDigestHash(opts *bind.CallOpts, staker common.Address, operator common.Address, expiry *big.Int) ([32]byte, error) - - CalculateDelegationApprovalDigestHash(opts *bind.CallOpts, staker common.Address, operator common.Address, _delegationApprover common.Address, approverSalt [32]byte, expiry *big.Int) ([32]byte, error) - - CalculateStakerDelegationDigestHash(opts *bind.CallOpts, staker common.Address, _stakerNonce *big.Int, operator common.Address, expiry *big.Int) ([32]byte, error) - - CalculateWithdrawalRoot(opts *bind.CallOpts, withdrawal IDelegationManagerWithdrawal) ([32]byte, error) - - CumulativeWithdrawalsQueued(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) - - DelegatedTo(opts *bind.CallOpts, arg0 common.Address) (common.Address, error) - - DelegationApprover(opts *bind.CallOpts, operator common.Address) (common.Address, error) - - DelegationApproverSaltIsSpent(opts *bind.CallOpts, arg0 common.Address, arg1 [32]byte) (bool, error) - - DomainSeparator(opts *bind.CallOpts) ([32]byte, error) - - EarningsReceiver(opts *bind.CallOpts, operator common.Address) (common.Address, error) - - EigenPodManager(opts *bind.CallOpts) (common.Address, error) - - GetDelegatableShares(opts *bind.CallOpts, staker common.Address) ([]common.Address, []*big.Int, error) - - GetOperatorShares(opts *bind.CallOpts, operator common.Address, strategies []common.Address) ([]*big.Int, error) - - GetWithdrawalDelay(opts *bind.CallOpts, strategies []common.Address) (*big.Int, error) - - IsDelegated(opts *bind.CallOpts, staker common.Address) (bool, error) - - IsOperator(opts *bind.CallOpts, operator common.Address) (bool, error) - - MinWithdrawalDelayBlocks(opts *bind.CallOpts) (*big.Int, error) - - OperatorDetails(opts *bind.CallOpts, operator common.Address) (IDelegationManagerOperatorDetails, error) - - OperatorShares(opts *bind.CallOpts, arg0 common.Address, arg1 common.Address) (*big.Int, error) - - Owner(opts *bind.CallOpts) (common.Address, error) - - Paused(opts *bind.CallOpts, index uint8) (bool, error) - - Paused0(opts *bind.CallOpts) (*big.Int, error) - - PauserRegistry(opts *bind.CallOpts) (common.Address, error) - - PendingWithdrawals(opts *bind.CallOpts, arg0 [32]byte) (bool, error) - - Slasher(opts *bind.CallOpts) (common.Address, error) - - StakerNonce(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) - - StakerOptOutWindowBlocks(opts *bind.CallOpts, operator common.Address) (*big.Int, error) - - StrategyManager(opts *bind.CallOpts) (common.Address, error) - - StrategyWithdrawalDelayBlocks(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) -} - -// ContractDelegationManagerTransacts is an auto generated interface that defines the transact methods available for an Ethereum contract. -type ContractDelegationManagerTransacts interface { - CompleteQueuedWithdrawal(opts *bind.TransactOpts, withdrawal IDelegationManagerWithdrawal, tokens []common.Address, middlewareTimesIndex *big.Int, receiveAsTokens bool) (*types.Transaction, error) - - CompleteQueuedWithdrawals(opts *bind.TransactOpts, withdrawals []IDelegationManagerWithdrawal, tokens [][]common.Address, middlewareTimesIndexes []*big.Int, receiveAsTokens []bool) (*types.Transaction, error) - - DecreaseDelegatedShares(opts *bind.TransactOpts, staker common.Address, strategy common.Address, shares *big.Int) (*types.Transaction, error) - - DelegateTo(opts *bind.TransactOpts, operator common.Address, approverSignatureAndExpiry ISignatureUtilsSignatureWithExpiry, approverSalt [32]byte) (*types.Transaction, error) - - DelegateToBySignature(opts *bind.TransactOpts, staker common.Address, operator common.Address, stakerSignatureAndExpiry ISignatureUtilsSignatureWithExpiry, approverSignatureAndExpiry ISignatureUtilsSignatureWithExpiry, approverSalt [32]byte) (*types.Transaction, error) - - IncreaseDelegatedShares(opts *bind.TransactOpts, staker common.Address, strategy common.Address, shares *big.Int) (*types.Transaction, error) - - Initialize(opts *bind.TransactOpts, initialOwner common.Address, _pauserRegistry common.Address, initialPausedStatus *big.Int, _minWithdrawalDelayBlocks *big.Int, _strategies []common.Address, _withdrawalDelayBlocks []*big.Int) (*types.Transaction, error) - - MigrateQueuedWithdrawals(opts *bind.TransactOpts, withdrawalsToMigrate []IStrategyManagerDeprecatedStructQueuedWithdrawal) (*types.Transaction, error) - - ModifyOperatorDetails(opts *bind.TransactOpts, newOperatorDetails IDelegationManagerOperatorDetails) (*types.Transaction, error) - - Pause(opts *bind.TransactOpts, newPausedStatus *big.Int) (*types.Transaction, error) - - PauseAll(opts *bind.TransactOpts) (*types.Transaction, error) - - QueueWithdrawals(opts *bind.TransactOpts, queuedWithdrawalParams []IDelegationManagerQueuedWithdrawalParams) (*types.Transaction, error) - - RegisterAsOperator(opts *bind.TransactOpts, registeringOperatorDetails IDelegationManagerOperatorDetails, metadataURI string) (*types.Transaction, error) - - RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) - - SetPauserRegistry(opts *bind.TransactOpts, newPauserRegistry common.Address) (*types.Transaction, error) - - SetStrategyWithdrawalDelayBlocks(opts *bind.TransactOpts, strategies []common.Address, withdrawalDelayBlocks []*big.Int) (*types.Transaction, error) - - TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) - - Undelegate(opts *bind.TransactOpts, staker common.Address) (*types.Transaction, error) - - Unpause(opts *bind.TransactOpts, newPausedStatus *big.Int) (*types.Transaction, error) - - UpdateOperatorMetadataURI(opts *bind.TransactOpts, metadataURI string) (*types.Transaction, error) -} - -// ContractDelegationManagerFilterer is an auto generated interface that defines the log filtering methods available for an Ethereum contract. -type ContractDelegationManagerFilters interface { - FilterInitialized(opts *bind.FilterOpts) (*ContractDelegationManagerInitializedIterator, error) - WatchInitialized(opts *bind.WatchOpts, sink chan<- *ContractDelegationManagerInitialized) (event.Subscription, error) - ParseInitialized(log types.Log) (*ContractDelegationManagerInitialized, error) - - FilterMinWithdrawalDelayBlocksSet(opts *bind.FilterOpts) (*ContractDelegationManagerMinWithdrawalDelayBlocksSetIterator, error) - WatchMinWithdrawalDelayBlocksSet(opts *bind.WatchOpts, sink chan<- *ContractDelegationManagerMinWithdrawalDelayBlocksSet) (event.Subscription, error) - ParseMinWithdrawalDelayBlocksSet(log types.Log) (*ContractDelegationManagerMinWithdrawalDelayBlocksSet, error) - - FilterOperatorDetailsModified(opts *bind.FilterOpts, operator []common.Address) (*ContractDelegationManagerOperatorDetailsModifiedIterator, error) - WatchOperatorDetailsModified(opts *bind.WatchOpts, sink chan<- *ContractDelegationManagerOperatorDetailsModified, operator []common.Address) (event.Subscription, error) - ParseOperatorDetailsModified(log types.Log) (*ContractDelegationManagerOperatorDetailsModified, error) - - FilterOperatorMetadataURIUpdated(opts *bind.FilterOpts, operator []common.Address) (*ContractDelegationManagerOperatorMetadataURIUpdatedIterator, error) - WatchOperatorMetadataURIUpdated(opts *bind.WatchOpts, sink chan<- *ContractDelegationManagerOperatorMetadataURIUpdated, operator []common.Address) (event.Subscription, error) - ParseOperatorMetadataURIUpdated(log types.Log) (*ContractDelegationManagerOperatorMetadataURIUpdated, error) - - FilterOperatorRegistered(opts *bind.FilterOpts, operator []common.Address) (*ContractDelegationManagerOperatorRegisteredIterator, error) - WatchOperatorRegistered(opts *bind.WatchOpts, sink chan<- *ContractDelegationManagerOperatorRegistered, operator []common.Address) (event.Subscription, error) - ParseOperatorRegistered(log types.Log) (*ContractDelegationManagerOperatorRegistered, error) - - FilterOperatorSharesDecreased(opts *bind.FilterOpts, operator []common.Address) (*ContractDelegationManagerOperatorSharesDecreasedIterator, error) - WatchOperatorSharesDecreased(opts *bind.WatchOpts, sink chan<- *ContractDelegationManagerOperatorSharesDecreased, operator []common.Address) (event.Subscription, error) - ParseOperatorSharesDecreased(log types.Log) (*ContractDelegationManagerOperatorSharesDecreased, error) - - FilterOperatorSharesIncreased(opts *bind.FilterOpts, operator []common.Address) (*ContractDelegationManagerOperatorSharesIncreasedIterator, error) - WatchOperatorSharesIncreased(opts *bind.WatchOpts, sink chan<- *ContractDelegationManagerOperatorSharesIncreased, operator []common.Address) (event.Subscription, error) - ParseOperatorSharesIncreased(log types.Log) (*ContractDelegationManagerOperatorSharesIncreased, error) - - FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*ContractDelegationManagerOwnershipTransferredIterator, error) - WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *ContractDelegationManagerOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) - ParseOwnershipTransferred(log types.Log) (*ContractDelegationManagerOwnershipTransferred, error) - - FilterPaused(opts *bind.FilterOpts, account []common.Address) (*ContractDelegationManagerPausedIterator, error) - WatchPaused(opts *bind.WatchOpts, sink chan<- *ContractDelegationManagerPaused, account []common.Address) (event.Subscription, error) - ParsePaused(log types.Log) (*ContractDelegationManagerPaused, error) - - FilterPauserRegistrySet(opts *bind.FilterOpts) (*ContractDelegationManagerPauserRegistrySetIterator, error) - WatchPauserRegistrySet(opts *bind.WatchOpts, sink chan<- *ContractDelegationManagerPauserRegistrySet) (event.Subscription, error) - ParsePauserRegistrySet(log types.Log) (*ContractDelegationManagerPauserRegistrySet, error) - - FilterStakerDelegated(opts *bind.FilterOpts, staker []common.Address, operator []common.Address) (*ContractDelegationManagerStakerDelegatedIterator, error) - WatchStakerDelegated(opts *bind.WatchOpts, sink chan<- *ContractDelegationManagerStakerDelegated, staker []common.Address, operator []common.Address) (event.Subscription, error) - ParseStakerDelegated(log types.Log) (*ContractDelegationManagerStakerDelegated, error) - - FilterStakerForceUndelegated(opts *bind.FilterOpts, staker []common.Address, operator []common.Address) (*ContractDelegationManagerStakerForceUndelegatedIterator, error) - WatchStakerForceUndelegated(opts *bind.WatchOpts, sink chan<- *ContractDelegationManagerStakerForceUndelegated, staker []common.Address, operator []common.Address) (event.Subscription, error) - ParseStakerForceUndelegated(log types.Log) (*ContractDelegationManagerStakerForceUndelegated, error) - - FilterStakerUndelegated(opts *bind.FilterOpts, staker []common.Address, operator []common.Address) (*ContractDelegationManagerStakerUndelegatedIterator, error) - WatchStakerUndelegated(opts *bind.WatchOpts, sink chan<- *ContractDelegationManagerStakerUndelegated, staker []common.Address, operator []common.Address) (event.Subscription, error) - ParseStakerUndelegated(log types.Log) (*ContractDelegationManagerStakerUndelegated, error) - - FilterStrategyWithdrawalDelayBlocksSet(opts *bind.FilterOpts) (*ContractDelegationManagerStrategyWithdrawalDelayBlocksSetIterator, error) - WatchStrategyWithdrawalDelayBlocksSet(opts *bind.WatchOpts, sink chan<- *ContractDelegationManagerStrategyWithdrawalDelayBlocksSet) (event.Subscription, error) - ParseStrategyWithdrawalDelayBlocksSet(log types.Log) (*ContractDelegationManagerStrategyWithdrawalDelayBlocksSet, error) - - FilterUnpaused(opts *bind.FilterOpts, account []common.Address) (*ContractDelegationManagerUnpausedIterator, error) - WatchUnpaused(opts *bind.WatchOpts, sink chan<- *ContractDelegationManagerUnpaused, account []common.Address) (event.Subscription, error) - ParseUnpaused(log types.Log) (*ContractDelegationManagerUnpaused, error) - - FilterWithdrawalCompleted(opts *bind.FilterOpts) (*ContractDelegationManagerWithdrawalCompletedIterator, error) - WatchWithdrawalCompleted(opts *bind.WatchOpts, sink chan<- *ContractDelegationManagerWithdrawalCompleted) (event.Subscription, error) - ParseWithdrawalCompleted(log types.Log) (*ContractDelegationManagerWithdrawalCompleted, error) - - FilterWithdrawalMigrated(opts *bind.FilterOpts) (*ContractDelegationManagerWithdrawalMigratedIterator, error) - WatchWithdrawalMigrated(opts *bind.WatchOpts, sink chan<- *ContractDelegationManagerWithdrawalMigrated) (event.Subscription, error) - ParseWithdrawalMigrated(log types.Log) (*ContractDelegationManagerWithdrawalMigrated, error) - - FilterWithdrawalQueued(opts *bind.FilterOpts) (*ContractDelegationManagerWithdrawalQueuedIterator, error) - WatchWithdrawalQueued(opts *bind.WatchOpts, sink chan<- *ContractDelegationManagerWithdrawalQueued) (event.Subscription, error) - ParseWithdrawalQueued(log types.Log) (*ContractDelegationManagerWithdrawalQueued, error) -} - -// ContractDelegationManager is an auto generated Go binding around an Ethereum contract. -type ContractDelegationManager struct { - ContractDelegationManagerCaller // Read-only binding to the contract - ContractDelegationManagerTransactor // Write-only binding to the contract - ContractDelegationManagerFilterer // Log filterer for contract events -} - -// ContractDelegationManager implements the ContractDelegationManagerMethods interface. -var _ ContractDelegationManagerMethods = (*ContractDelegationManager)(nil) - -// ContractDelegationManagerCaller is an auto generated read-only Go binding around an Ethereum contract. -type ContractDelegationManagerCaller struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// ContractDelegationManagerCaller implements the ContractDelegationManagerCalls interface. -var _ ContractDelegationManagerCalls = (*ContractDelegationManagerCaller)(nil) - -// ContractDelegationManagerTransactor is an auto generated write-only Go binding around an Ethereum contract. -type ContractDelegationManagerTransactor struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// ContractDelegationManagerTransactor implements the ContractDelegationManagerTransacts interface. -var _ ContractDelegationManagerTransacts = (*ContractDelegationManagerTransactor)(nil) - -// ContractDelegationManagerFilterer is an auto generated log filtering Go binding around an Ethereum contract events. -type ContractDelegationManagerFilterer struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// ContractDelegationManagerFilterer implements the ContractDelegationManagerFilters interface. -var _ ContractDelegationManagerFilters = (*ContractDelegationManagerFilterer)(nil) - -// ContractDelegationManagerSession is an auto generated Go binding around an Ethereum contract, -// with pre-set call and transact options. -type ContractDelegationManagerSession struct { - Contract *ContractDelegationManager // 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 -} - -// ContractDelegationManagerCallerSession is an auto generated read-only Go binding around an Ethereum contract, -// with pre-set call options. -type ContractDelegationManagerCallerSession struct { - Contract *ContractDelegationManagerCaller // Generic contract caller binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session -} - -// ContractDelegationManagerTransactorSession is an auto generated write-only Go binding around an Ethereum contract, -// with pre-set transact options. -type ContractDelegationManagerTransactorSession struct { - Contract *ContractDelegationManagerTransactor // Generic contract transactor binding to set the session for - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session -} - -// ContractDelegationManagerRaw is an auto generated low-level Go binding around an Ethereum contract. -type ContractDelegationManagerRaw struct { - Contract *ContractDelegationManager // Generic contract binding to access the raw methods on -} - -// ContractDelegationManagerCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. -type ContractDelegationManagerCallerRaw struct { - Contract *ContractDelegationManagerCaller // Generic read-only contract binding to access the raw methods on -} - -// ContractDelegationManagerTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. -type ContractDelegationManagerTransactorRaw struct { - Contract *ContractDelegationManagerTransactor // Generic write-only contract binding to access the raw methods on -} - -// NewContractDelegationManager creates a new instance of ContractDelegationManager, bound to a specific deployed contract. -func NewContractDelegationManager(address common.Address, backend bind.ContractBackend) (*ContractDelegationManager, error) { - contract, err := bindContractDelegationManager(address, backend, backend, backend) - if err != nil { - return nil, err - } - return &ContractDelegationManager{ContractDelegationManagerCaller: ContractDelegationManagerCaller{contract: contract}, ContractDelegationManagerTransactor: ContractDelegationManagerTransactor{contract: contract}, ContractDelegationManagerFilterer: ContractDelegationManagerFilterer{contract: contract}}, nil -} - -// NewContractDelegationManagerCaller creates a new read-only instance of ContractDelegationManager, bound to a specific deployed contract. -func NewContractDelegationManagerCaller(address common.Address, caller bind.ContractCaller) (*ContractDelegationManagerCaller, error) { - contract, err := bindContractDelegationManager(address, caller, nil, nil) - if err != nil { - return nil, err - } - return &ContractDelegationManagerCaller{contract: contract}, nil -} - -// NewContractDelegationManagerTransactor creates a new write-only instance of ContractDelegationManager, bound to a specific deployed contract. -func NewContractDelegationManagerTransactor(address common.Address, transactor bind.ContractTransactor) (*ContractDelegationManagerTransactor, error) { - contract, err := bindContractDelegationManager(address, nil, transactor, nil) - if err != nil { - return nil, err - } - return &ContractDelegationManagerTransactor{contract: contract}, nil -} - -// NewContractDelegationManagerFilterer creates a new log filterer instance of ContractDelegationManager, bound to a specific deployed contract. -func NewContractDelegationManagerFilterer(address common.Address, filterer bind.ContractFilterer) (*ContractDelegationManagerFilterer, error) { - contract, err := bindContractDelegationManager(address, nil, nil, filterer) - if err != nil { - return nil, err - } - return &ContractDelegationManagerFilterer{contract: contract}, nil -} - -// bindContractDelegationManager binds a generic wrapper to an already deployed contract. -func bindContractDelegationManager(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { - parsed, err := ContractDelegationManagerMetaData.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 (_ContractDelegationManager *ContractDelegationManagerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _ContractDelegationManager.Contract.ContractDelegationManagerCaller.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 (_ContractDelegationManager *ContractDelegationManagerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _ContractDelegationManager.Contract.ContractDelegationManagerTransactor.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_ContractDelegationManager *ContractDelegationManagerRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _ContractDelegationManager.Contract.ContractDelegationManagerTransactor.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 (_ContractDelegationManager *ContractDelegationManagerCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _ContractDelegationManager.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 (_ContractDelegationManager *ContractDelegationManagerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _ContractDelegationManager.Contract.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_ContractDelegationManager *ContractDelegationManagerTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _ContractDelegationManager.Contract.contract.Transact(opts, method, params...) -} - -// DELEGATIONAPPROVALTYPEHASH is a free data retrieval call binding the contract method 0x04a4f979. -// -// Solidity: function DELEGATION_APPROVAL_TYPEHASH() view returns(bytes32) -func (_ContractDelegationManager *ContractDelegationManagerCaller) DELEGATIONAPPROVALTYPEHASH(opts *bind.CallOpts) ([32]byte, error) { - var out []interface{} - err := _ContractDelegationManager.contract.Call(opts, &out, "DELEGATION_APPROVAL_TYPEHASH") - - if err != nil { - return *new([32]byte), err - } - - out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) - - return out0, err - -} - -// DELEGATIONAPPROVALTYPEHASH is a free data retrieval call binding the contract method 0x04a4f979. -// -// Solidity: function DELEGATION_APPROVAL_TYPEHASH() view returns(bytes32) -func (_ContractDelegationManager *ContractDelegationManagerSession) DELEGATIONAPPROVALTYPEHASH() ([32]byte, error) { - return _ContractDelegationManager.Contract.DELEGATIONAPPROVALTYPEHASH(&_ContractDelegationManager.CallOpts) -} - -// DELEGATIONAPPROVALTYPEHASH is a free data retrieval call binding the contract method 0x04a4f979. -// -// Solidity: function DELEGATION_APPROVAL_TYPEHASH() view returns(bytes32) -func (_ContractDelegationManager *ContractDelegationManagerCallerSession) DELEGATIONAPPROVALTYPEHASH() ([32]byte, error) { - return _ContractDelegationManager.Contract.DELEGATIONAPPROVALTYPEHASH(&_ContractDelegationManager.CallOpts) -} - -// DOMAINTYPEHASH is a free data retrieval call binding the contract method 0x20606b70. -// -// Solidity: function DOMAIN_TYPEHASH() view returns(bytes32) -func (_ContractDelegationManager *ContractDelegationManagerCaller) DOMAINTYPEHASH(opts *bind.CallOpts) ([32]byte, error) { - var out []interface{} - err := _ContractDelegationManager.contract.Call(opts, &out, "DOMAIN_TYPEHASH") - - if err != nil { - return *new([32]byte), err - } - - out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) - - return out0, err - -} - -// DOMAINTYPEHASH is a free data retrieval call binding the contract method 0x20606b70. -// -// Solidity: function DOMAIN_TYPEHASH() view returns(bytes32) -func (_ContractDelegationManager *ContractDelegationManagerSession) DOMAINTYPEHASH() ([32]byte, error) { - return _ContractDelegationManager.Contract.DOMAINTYPEHASH(&_ContractDelegationManager.CallOpts) -} - -// DOMAINTYPEHASH is a free data retrieval call binding the contract method 0x20606b70. -// -// Solidity: function DOMAIN_TYPEHASH() view returns(bytes32) -func (_ContractDelegationManager *ContractDelegationManagerCallerSession) DOMAINTYPEHASH() ([32]byte, error) { - return _ContractDelegationManager.Contract.DOMAINTYPEHASH(&_ContractDelegationManager.CallOpts) -} - -// MAXSTAKEROPTOUTWINDOWBLOCKS is a free data retrieval call binding the contract method 0x4fc40b61. -// -// Solidity: function MAX_STAKER_OPT_OUT_WINDOW_BLOCKS() view returns(uint256) -func (_ContractDelegationManager *ContractDelegationManagerCaller) MAXSTAKEROPTOUTWINDOWBLOCKS(opts *bind.CallOpts) (*big.Int, error) { - var out []interface{} - err := _ContractDelegationManager.contract.Call(opts, &out, "MAX_STAKER_OPT_OUT_WINDOW_BLOCKS") - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// MAXSTAKEROPTOUTWINDOWBLOCKS is a free data retrieval call binding the contract method 0x4fc40b61. -// -// Solidity: function MAX_STAKER_OPT_OUT_WINDOW_BLOCKS() view returns(uint256) -func (_ContractDelegationManager *ContractDelegationManagerSession) MAXSTAKEROPTOUTWINDOWBLOCKS() (*big.Int, error) { - return _ContractDelegationManager.Contract.MAXSTAKEROPTOUTWINDOWBLOCKS(&_ContractDelegationManager.CallOpts) -} - -// MAXSTAKEROPTOUTWINDOWBLOCKS is a free data retrieval call binding the contract method 0x4fc40b61. -// -// Solidity: function MAX_STAKER_OPT_OUT_WINDOW_BLOCKS() view returns(uint256) -func (_ContractDelegationManager *ContractDelegationManagerCallerSession) MAXSTAKEROPTOUTWINDOWBLOCKS() (*big.Int, error) { - return _ContractDelegationManager.Contract.MAXSTAKEROPTOUTWINDOWBLOCKS(&_ContractDelegationManager.CallOpts) -} - -// MAXWITHDRAWALDELAYBLOCKS is a free data retrieval call binding the contract method 0xca661c04. -// -// Solidity: function MAX_WITHDRAWAL_DELAY_BLOCKS() view returns(uint256) -func (_ContractDelegationManager *ContractDelegationManagerCaller) MAXWITHDRAWALDELAYBLOCKS(opts *bind.CallOpts) (*big.Int, error) { - var out []interface{} - err := _ContractDelegationManager.contract.Call(opts, &out, "MAX_WITHDRAWAL_DELAY_BLOCKS") - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// MAXWITHDRAWALDELAYBLOCKS is a free data retrieval call binding the contract method 0xca661c04. -// -// Solidity: function MAX_WITHDRAWAL_DELAY_BLOCKS() view returns(uint256) -func (_ContractDelegationManager *ContractDelegationManagerSession) MAXWITHDRAWALDELAYBLOCKS() (*big.Int, error) { - return _ContractDelegationManager.Contract.MAXWITHDRAWALDELAYBLOCKS(&_ContractDelegationManager.CallOpts) -} - -// MAXWITHDRAWALDELAYBLOCKS is a free data retrieval call binding the contract method 0xca661c04. -// -// Solidity: function MAX_WITHDRAWAL_DELAY_BLOCKS() view returns(uint256) -func (_ContractDelegationManager *ContractDelegationManagerCallerSession) MAXWITHDRAWALDELAYBLOCKS() (*big.Int, error) { - return _ContractDelegationManager.Contract.MAXWITHDRAWALDELAYBLOCKS(&_ContractDelegationManager.CallOpts) -} - -// STAKERDELEGATIONTYPEHASH is a free data retrieval call binding the contract method 0x43377382. -// -// Solidity: function STAKER_DELEGATION_TYPEHASH() view returns(bytes32) -func (_ContractDelegationManager *ContractDelegationManagerCaller) STAKERDELEGATIONTYPEHASH(opts *bind.CallOpts) ([32]byte, error) { - var out []interface{} - err := _ContractDelegationManager.contract.Call(opts, &out, "STAKER_DELEGATION_TYPEHASH") - - if err != nil { - return *new([32]byte), err - } - - out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) - - return out0, err - -} - -// STAKERDELEGATIONTYPEHASH is a free data retrieval call binding the contract method 0x43377382. -// -// Solidity: function STAKER_DELEGATION_TYPEHASH() view returns(bytes32) -func (_ContractDelegationManager *ContractDelegationManagerSession) STAKERDELEGATIONTYPEHASH() ([32]byte, error) { - return _ContractDelegationManager.Contract.STAKERDELEGATIONTYPEHASH(&_ContractDelegationManager.CallOpts) -} - -// STAKERDELEGATIONTYPEHASH is a free data retrieval call binding the contract method 0x43377382. -// -// Solidity: function STAKER_DELEGATION_TYPEHASH() view returns(bytes32) -func (_ContractDelegationManager *ContractDelegationManagerCallerSession) STAKERDELEGATIONTYPEHASH() ([32]byte, error) { - return _ContractDelegationManager.Contract.STAKERDELEGATIONTYPEHASH(&_ContractDelegationManager.CallOpts) -} - -// BeaconChainETHStrategy is a free data retrieval call binding the contract method 0x9104c319. -// -// Solidity: function beaconChainETHStrategy() view returns(address) -func (_ContractDelegationManager *ContractDelegationManagerCaller) BeaconChainETHStrategy(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _ContractDelegationManager.contract.Call(opts, &out, "beaconChainETHStrategy") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// BeaconChainETHStrategy is a free data retrieval call binding the contract method 0x9104c319. -// -// Solidity: function beaconChainETHStrategy() view returns(address) -func (_ContractDelegationManager *ContractDelegationManagerSession) BeaconChainETHStrategy() (common.Address, error) { - return _ContractDelegationManager.Contract.BeaconChainETHStrategy(&_ContractDelegationManager.CallOpts) -} - -// BeaconChainETHStrategy is a free data retrieval call binding the contract method 0x9104c319. -// -// Solidity: function beaconChainETHStrategy() view returns(address) -func (_ContractDelegationManager *ContractDelegationManagerCallerSession) BeaconChainETHStrategy() (common.Address, error) { - return _ContractDelegationManager.Contract.BeaconChainETHStrategy(&_ContractDelegationManager.CallOpts) -} - -// CalculateCurrentStakerDelegationDigestHash is a free data retrieval call binding the contract method 0x1bbce091. -// -// Solidity: function calculateCurrentStakerDelegationDigestHash(address staker, address operator, uint256 expiry) view returns(bytes32) -func (_ContractDelegationManager *ContractDelegationManagerCaller) CalculateCurrentStakerDelegationDigestHash(opts *bind.CallOpts, staker common.Address, operator common.Address, expiry *big.Int) ([32]byte, error) { - var out []interface{} - err := _ContractDelegationManager.contract.Call(opts, &out, "calculateCurrentStakerDelegationDigestHash", staker, operator, expiry) - - if err != nil { - return *new([32]byte), err - } - - out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) - - return out0, err - -} - -// CalculateCurrentStakerDelegationDigestHash is a free data retrieval call binding the contract method 0x1bbce091. -// -// Solidity: function calculateCurrentStakerDelegationDigestHash(address staker, address operator, uint256 expiry) view returns(bytes32) -func (_ContractDelegationManager *ContractDelegationManagerSession) CalculateCurrentStakerDelegationDigestHash(staker common.Address, operator common.Address, expiry *big.Int) ([32]byte, error) { - return _ContractDelegationManager.Contract.CalculateCurrentStakerDelegationDigestHash(&_ContractDelegationManager.CallOpts, staker, operator, expiry) -} - -// CalculateCurrentStakerDelegationDigestHash is a free data retrieval call binding the contract method 0x1bbce091. -// -// Solidity: function calculateCurrentStakerDelegationDigestHash(address staker, address operator, uint256 expiry) view returns(bytes32) -func (_ContractDelegationManager *ContractDelegationManagerCallerSession) CalculateCurrentStakerDelegationDigestHash(staker common.Address, operator common.Address, expiry *big.Int) ([32]byte, error) { - return _ContractDelegationManager.Contract.CalculateCurrentStakerDelegationDigestHash(&_ContractDelegationManager.CallOpts, staker, operator, expiry) -} - -// CalculateDelegationApprovalDigestHash is a free data retrieval call binding the contract method 0x0b9f487a. -// -// Solidity: function calculateDelegationApprovalDigestHash(address staker, address operator, address _delegationApprover, bytes32 approverSalt, uint256 expiry) view returns(bytes32) -func (_ContractDelegationManager *ContractDelegationManagerCaller) CalculateDelegationApprovalDigestHash(opts *bind.CallOpts, staker common.Address, operator common.Address, _delegationApprover common.Address, approverSalt [32]byte, expiry *big.Int) ([32]byte, error) { - var out []interface{} - err := _ContractDelegationManager.contract.Call(opts, &out, "calculateDelegationApprovalDigestHash", staker, operator, _delegationApprover, approverSalt, expiry) - - if err != nil { - return *new([32]byte), err - } - - out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) - - return out0, err - -} - -// CalculateDelegationApprovalDigestHash is a free data retrieval call binding the contract method 0x0b9f487a. -// -// Solidity: function calculateDelegationApprovalDigestHash(address staker, address operator, address _delegationApprover, bytes32 approverSalt, uint256 expiry) view returns(bytes32) -func (_ContractDelegationManager *ContractDelegationManagerSession) CalculateDelegationApprovalDigestHash(staker common.Address, operator common.Address, _delegationApprover common.Address, approverSalt [32]byte, expiry *big.Int) ([32]byte, error) { - return _ContractDelegationManager.Contract.CalculateDelegationApprovalDigestHash(&_ContractDelegationManager.CallOpts, staker, operator, _delegationApprover, approverSalt, expiry) -} - -// CalculateDelegationApprovalDigestHash is a free data retrieval call binding the contract method 0x0b9f487a. -// -// Solidity: function calculateDelegationApprovalDigestHash(address staker, address operator, address _delegationApprover, bytes32 approverSalt, uint256 expiry) view returns(bytes32) -func (_ContractDelegationManager *ContractDelegationManagerCallerSession) CalculateDelegationApprovalDigestHash(staker common.Address, operator common.Address, _delegationApprover common.Address, approverSalt [32]byte, expiry *big.Int) ([32]byte, error) { - return _ContractDelegationManager.Contract.CalculateDelegationApprovalDigestHash(&_ContractDelegationManager.CallOpts, staker, operator, _delegationApprover, approverSalt, expiry) -} - -// CalculateStakerDelegationDigestHash is a free data retrieval call binding the contract method 0xc94b5111. -// -// Solidity: function calculateStakerDelegationDigestHash(address staker, uint256 _stakerNonce, address operator, uint256 expiry) view returns(bytes32) -func (_ContractDelegationManager *ContractDelegationManagerCaller) CalculateStakerDelegationDigestHash(opts *bind.CallOpts, staker common.Address, _stakerNonce *big.Int, operator common.Address, expiry *big.Int) ([32]byte, error) { - var out []interface{} - err := _ContractDelegationManager.contract.Call(opts, &out, "calculateStakerDelegationDigestHash", staker, _stakerNonce, operator, expiry) - - if err != nil { - return *new([32]byte), err - } - - out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) - - return out0, err - -} - -// CalculateStakerDelegationDigestHash is a free data retrieval call binding the contract method 0xc94b5111. -// -// Solidity: function calculateStakerDelegationDigestHash(address staker, uint256 _stakerNonce, address operator, uint256 expiry) view returns(bytes32) -func (_ContractDelegationManager *ContractDelegationManagerSession) CalculateStakerDelegationDigestHash(staker common.Address, _stakerNonce *big.Int, operator common.Address, expiry *big.Int) ([32]byte, error) { - return _ContractDelegationManager.Contract.CalculateStakerDelegationDigestHash(&_ContractDelegationManager.CallOpts, staker, _stakerNonce, operator, expiry) -} - -// CalculateStakerDelegationDigestHash is a free data retrieval call binding the contract method 0xc94b5111. -// -// Solidity: function calculateStakerDelegationDigestHash(address staker, uint256 _stakerNonce, address operator, uint256 expiry) view returns(bytes32) -func (_ContractDelegationManager *ContractDelegationManagerCallerSession) CalculateStakerDelegationDigestHash(staker common.Address, _stakerNonce *big.Int, operator common.Address, expiry *big.Int) ([32]byte, error) { - return _ContractDelegationManager.Contract.CalculateStakerDelegationDigestHash(&_ContractDelegationManager.CallOpts, staker, _stakerNonce, operator, expiry) -} - -// CalculateWithdrawalRoot is a free data retrieval call binding the contract method 0x597b36da. -// -// Solidity: function calculateWithdrawalRoot((address,address,address,uint256,uint32,address[],uint256[]) withdrawal) pure returns(bytes32) -func (_ContractDelegationManager *ContractDelegationManagerCaller) CalculateWithdrawalRoot(opts *bind.CallOpts, withdrawal IDelegationManagerWithdrawal) ([32]byte, error) { - var out []interface{} - err := _ContractDelegationManager.contract.Call(opts, &out, "calculateWithdrawalRoot", withdrawal) - - if err != nil { - return *new([32]byte), err - } - - out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) - - return out0, err - -} - -// CalculateWithdrawalRoot is a free data retrieval call binding the contract method 0x597b36da. -// -// Solidity: function calculateWithdrawalRoot((address,address,address,uint256,uint32,address[],uint256[]) withdrawal) pure returns(bytes32) -func (_ContractDelegationManager *ContractDelegationManagerSession) CalculateWithdrawalRoot(withdrawal IDelegationManagerWithdrawal) ([32]byte, error) { - return _ContractDelegationManager.Contract.CalculateWithdrawalRoot(&_ContractDelegationManager.CallOpts, withdrawal) -} - -// CalculateWithdrawalRoot is a free data retrieval call binding the contract method 0x597b36da. -// -// Solidity: function calculateWithdrawalRoot((address,address,address,uint256,uint32,address[],uint256[]) withdrawal) pure returns(bytes32) -func (_ContractDelegationManager *ContractDelegationManagerCallerSession) CalculateWithdrawalRoot(withdrawal IDelegationManagerWithdrawal) ([32]byte, error) { - return _ContractDelegationManager.Contract.CalculateWithdrawalRoot(&_ContractDelegationManager.CallOpts, withdrawal) -} - -// CumulativeWithdrawalsQueued is a free data retrieval call binding the contract method 0xa1788484. -// -// Solidity: function cumulativeWithdrawalsQueued(address ) view returns(uint256) -func (_ContractDelegationManager *ContractDelegationManagerCaller) CumulativeWithdrawalsQueued(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) { - var out []interface{} - err := _ContractDelegationManager.contract.Call(opts, &out, "cumulativeWithdrawalsQueued", arg0) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// CumulativeWithdrawalsQueued is a free data retrieval call binding the contract method 0xa1788484. -// -// Solidity: function cumulativeWithdrawalsQueued(address ) view returns(uint256) -func (_ContractDelegationManager *ContractDelegationManagerSession) CumulativeWithdrawalsQueued(arg0 common.Address) (*big.Int, error) { - return _ContractDelegationManager.Contract.CumulativeWithdrawalsQueued(&_ContractDelegationManager.CallOpts, arg0) -} - -// CumulativeWithdrawalsQueued is a free data retrieval call binding the contract method 0xa1788484. -// -// Solidity: function cumulativeWithdrawalsQueued(address ) view returns(uint256) -func (_ContractDelegationManager *ContractDelegationManagerCallerSession) CumulativeWithdrawalsQueued(arg0 common.Address) (*big.Int, error) { - return _ContractDelegationManager.Contract.CumulativeWithdrawalsQueued(&_ContractDelegationManager.CallOpts, arg0) -} - -// DelegatedTo is a free data retrieval call binding the contract method 0x65da1264. -// -// Solidity: function delegatedTo(address ) view returns(address) -func (_ContractDelegationManager *ContractDelegationManagerCaller) DelegatedTo(opts *bind.CallOpts, arg0 common.Address) (common.Address, error) { - var out []interface{} - err := _ContractDelegationManager.contract.Call(opts, &out, "delegatedTo", arg0) - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// DelegatedTo is a free data retrieval call binding the contract method 0x65da1264. -// -// Solidity: function delegatedTo(address ) view returns(address) -func (_ContractDelegationManager *ContractDelegationManagerSession) DelegatedTo(arg0 common.Address) (common.Address, error) { - return _ContractDelegationManager.Contract.DelegatedTo(&_ContractDelegationManager.CallOpts, arg0) -} - -// DelegatedTo is a free data retrieval call binding the contract method 0x65da1264. -// -// Solidity: function delegatedTo(address ) view returns(address) -func (_ContractDelegationManager *ContractDelegationManagerCallerSession) DelegatedTo(arg0 common.Address) (common.Address, error) { - return _ContractDelegationManager.Contract.DelegatedTo(&_ContractDelegationManager.CallOpts, arg0) -} - -// DelegationApprover is a free data retrieval call binding the contract method 0x3cdeb5e0. -// -// Solidity: function delegationApprover(address operator) view returns(address) -func (_ContractDelegationManager *ContractDelegationManagerCaller) DelegationApprover(opts *bind.CallOpts, operator common.Address) (common.Address, error) { - var out []interface{} - err := _ContractDelegationManager.contract.Call(opts, &out, "delegationApprover", operator) - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// DelegationApprover is a free data retrieval call binding the contract method 0x3cdeb5e0. -// -// Solidity: function delegationApprover(address operator) view returns(address) -func (_ContractDelegationManager *ContractDelegationManagerSession) DelegationApprover(operator common.Address) (common.Address, error) { - return _ContractDelegationManager.Contract.DelegationApprover(&_ContractDelegationManager.CallOpts, operator) -} - -// DelegationApprover is a free data retrieval call binding the contract method 0x3cdeb5e0. -// -// Solidity: function delegationApprover(address operator) view returns(address) -func (_ContractDelegationManager *ContractDelegationManagerCallerSession) DelegationApprover(operator common.Address) (common.Address, error) { - return _ContractDelegationManager.Contract.DelegationApprover(&_ContractDelegationManager.CallOpts, operator) -} - -// DelegationApproverSaltIsSpent is a free data retrieval call binding the contract method 0xbb45fef2. -// -// Solidity: function delegationApproverSaltIsSpent(address , bytes32 ) view returns(bool) -func (_ContractDelegationManager *ContractDelegationManagerCaller) DelegationApproverSaltIsSpent(opts *bind.CallOpts, arg0 common.Address, arg1 [32]byte) (bool, error) { - var out []interface{} - err := _ContractDelegationManager.contract.Call(opts, &out, "delegationApproverSaltIsSpent", arg0, arg1) - - if err != nil { - return *new(bool), err - } - - out0 := *abi.ConvertType(out[0], new(bool)).(*bool) - - return out0, err - -} - -// DelegationApproverSaltIsSpent is a free data retrieval call binding the contract method 0xbb45fef2. -// -// Solidity: function delegationApproverSaltIsSpent(address , bytes32 ) view returns(bool) -func (_ContractDelegationManager *ContractDelegationManagerSession) DelegationApproverSaltIsSpent(arg0 common.Address, arg1 [32]byte) (bool, error) { - return _ContractDelegationManager.Contract.DelegationApproverSaltIsSpent(&_ContractDelegationManager.CallOpts, arg0, arg1) -} - -// DelegationApproverSaltIsSpent is a free data retrieval call binding the contract method 0xbb45fef2. -// -// Solidity: function delegationApproverSaltIsSpent(address , bytes32 ) view returns(bool) -func (_ContractDelegationManager *ContractDelegationManagerCallerSession) DelegationApproverSaltIsSpent(arg0 common.Address, arg1 [32]byte) (bool, error) { - return _ContractDelegationManager.Contract.DelegationApproverSaltIsSpent(&_ContractDelegationManager.CallOpts, arg0, arg1) -} - -// DomainSeparator is a free data retrieval call binding the contract method 0xf698da25. -// -// Solidity: function domainSeparator() view returns(bytes32) -func (_ContractDelegationManager *ContractDelegationManagerCaller) DomainSeparator(opts *bind.CallOpts) ([32]byte, error) { - var out []interface{} - err := _ContractDelegationManager.contract.Call(opts, &out, "domainSeparator") - - if err != nil { - return *new([32]byte), err - } - - out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) - - return out0, err - -} - -// DomainSeparator is a free data retrieval call binding the contract method 0xf698da25. -// -// Solidity: function domainSeparator() view returns(bytes32) -func (_ContractDelegationManager *ContractDelegationManagerSession) DomainSeparator() ([32]byte, error) { - return _ContractDelegationManager.Contract.DomainSeparator(&_ContractDelegationManager.CallOpts) -} - -// DomainSeparator is a free data retrieval call binding the contract method 0xf698da25. -// -// Solidity: function domainSeparator() view returns(bytes32) -func (_ContractDelegationManager *ContractDelegationManagerCallerSession) DomainSeparator() ([32]byte, error) { - return _ContractDelegationManager.Contract.DomainSeparator(&_ContractDelegationManager.CallOpts) -} - -// EarningsReceiver is a free data retrieval call binding the contract method 0x5f966f14. -// -// Solidity: function earningsReceiver(address operator) view returns(address) -func (_ContractDelegationManager *ContractDelegationManagerCaller) EarningsReceiver(opts *bind.CallOpts, operator common.Address) (common.Address, error) { - var out []interface{} - err := _ContractDelegationManager.contract.Call(opts, &out, "earningsReceiver", operator) - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// EarningsReceiver is a free data retrieval call binding the contract method 0x5f966f14. -// -// Solidity: function earningsReceiver(address operator) view returns(address) -func (_ContractDelegationManager *ContractDelegationManagerSession) EarningsReceiver(operator common.Address) (common.Address, error) { - return _ContractDelegationManager.Contract.EarningsReceiver(&_ContractDelegationManager.CallOpts, operator) -} - -// EarningsReceiver is a free data retrieval call binding the contract method 0x5f966f14. -// -// Solidity: function earningsReceiver(address operator) view returns(address) -func (_ContractDelegationManager *ContractDelegationManagerCallerSession) EarningsReceiver(operator common.Address) (common.Address, error) { - return _ContractDelegationManager.Contract.EarningsReceiver(&_ContractDelegationManager.CallOpts, operator) -} - -// EigenPodManager is a free data retrieval call binding the contract method 0x4665bcda. -// -// Solidity: function eigenPodManager() view returns(address) -func (_ContractDelegationManager *ContractDelegationManagerCaller) EigenPodManager(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _ContractDelegationManager.contract.Call(opts, &out, "eigenPodManager") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// EigenPodManager is a free data retrieval call binding the contract method 0x4665bcda. -// -// Solidity: function eigenPodManager() view returns(address) -func (_ContractDelegationManager *ContractDelegationManagerSession) EigenPodManager() (common.Address, error) { - return _ContractDelegationManager.Contract.EigenPodManager(&_ContractDelegationManager.CallOpts) -} - -// EigenPodManager is a free data retrieval call binding the contract method 0x4665bcda. -// -// Solidity: function eigenPodManager() view returns(address) -func (_ContractDelegationManager *ContractDelegationManagerCallerSession) EigenPodManager() (common.Address, error) { - return _ContractDelegationManager.Contract.EigenPodManager(&_ContractDelegationManager.CallOpts) -} - -// GetDelegatableShares is a free data retrieval call binding the contract method 0xcf80873e. -// -// Solidity: function getDelegatableShares(address staker) view returns(address[], uint256[]) -func (_ContractDelegationManager *ContractDelegationManagerCaller) GetDelegatableShares(opts *bind.CallOpts, staker common.Address) ([]common.Address, []*big.Int, error) { - var out []interface{} - err := _ContractDelegationManager.contract.Call(opts, &out, "getDelegatableShares", staker) - - if err != nil { - return *new([]common.Address), *new([]*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address) - out1 := *abi.ConvertType(out[1], new([]*big.Int)).(*[]*big.Int) - - return out0, out1, err - -} - -// GetDelegatableShares is a free data retrieval call binding the contract method 0xcf80873e. -// -// Solidity: function getDelegatableShares(address staker) view returns(address[], uint256[]) -func (_ContractDelegationManager *ContractDelegationManagerSession) GetDelegatableShares(staker common.Address) ([]common.Address, []*big.Int, error) { - return _ContractDelegationManager.Contract.GetDelegatableShares(&_ContractDelegationManager.CallOpts, staker) -} - -// GetDelegatableShares is a free data retrieval call binding the contract method 0xcf80873e. -// -// Solidity: function getDelegatableShares(address staker) view returns(address[], uint256[]) -func (_ContractDelegationManager *ContractDelegationManagerCallerSession) GetDelegatableShares(staker common.Address) ([]common.Address, []*big.Int, error) { - return _ContractDelegationManager.Contract.GetDelegatableShares(&_ContractDelegationManager.CallOpts, staker) -} - -// GetOperatorShares is a free data retrieval call binding the contract method 0x90041347. -// -// Solidity: function getOperatorShares(address operator, address[] strategies) view returns(uint256[]) -func (_ContractDelegationManager *ContractDelegationManagerCaller) GetOperatorShares(opts *bind.CallOpts, operator common.Address, strategies []common.Address) ([]*big.Int, error) { - var out []interface{} - err := _ContractDelegationManager.contract.Call(opts, &out, "getOperatorShares", operator, strategies) - - if err != nil { - return *new([]*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new([]*big.Int)).(*[]*big.Int) - - return out0, err - -} - -// GetOperatorShares is a free data retrieval call binding the contract method 0x90041347. -// -// Solidity: function getOperatorShares(address operator, address[] strategies) view returns(uint256[]) -func (_ContractDelegationManager *ContractDelegationManagerSession) GetOperatorShares(operator common.Address, strategies []common.Address) ([]*big.Int, error) { - return _ContractDelegationManager.Contract.GetOperatorShares(&_ContractDelegationManager.CallOpts, operator, strategies) -} - -// GetOperatorShares is a free data retrieval call binding the contract method 0x90041347. -// -// Solidity: function getOperatorShares(address operator, address[] strategies) view returns(uint256[]) -func (_ContractDelegationManager *ContractDelegationManagerCallerSession) GetOperatorShares(operator common.Address, strategies []common.Address) ([]*big.Int, error) { - return _ContractDelegationManager.Contract.GetOperatorShares(&_ContractDelegationManager.CallOpts, operator, strategies) -} - -// GetWithdrawalDelay is a free data retrieval call binding the contract method 0x0449ca39. -// -// Solidity: function getWithdrawalDelay(address[] strategies) view returns(uint256) -func (_ContractDelegationManager *ContractDelegationManagerCaller) GetWithdrawalDelay(opts *bind.CallOpts, strategies []common.Address) (*big.Int, error) { - var out []interface{} - err := _ContractDelegationManager.contract.Call(opts, &out, "getWithdrawalDelay", strategies) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// GetWithdrawalDelay is a free data retrieval call binding the contract method 0x0449ca39. -// -// Solidity: function getWithdrawalDelay(address[] strategies) view returns(uint256) -func (_ContractDelegationManager *ContractDelegationManagerSession) GetWithdrawalDelay(strategies []common.Address) (*big.Int, error) { - return _ContractDelegationManager.Contract.GetWithdrawalDelay(&_ContractDelegationManager.CallOpts, strategies) -} - -// GetWithdrawalDelay is a free data retrieval call binding the contract method 0x0449ca39. -// -// Solidity: function getWithdrawalDelay(address[] strategies) view returns(uint256) -func (_ContractDelegationManager *ContractDelegationManagerCallerSession) GetWithdrawalDelay(strategies []common.Address) (*big.Int, error) { - return _ContractDelegationManager.Contract.GetWithdrawalDelay(&_ContractDelegationManager.CallOpts, strategies) -} - -// IsDelegated is a free data retrieval call binding the contract method 0x3e28391d. -// -// Solidity: function isDelegated(address staker) view returns(bool) -func (_ContractDelegationManager *ContractDelegationManagerCaller) IsDelegated(opts *bind.CallOpts, staker common.Address) (bool, error) { - var out []interface{} - err := _ContractDelegationManager.contract.Call(opts, &out, "isDelegated", staker) - - if err != nil { - return *new(bool), err - } - - out0 := *abi.ConvertType(out[0], new(bool)).(*bool) - - return out0, err - -} - -// IsDelegated is a free data retrieval call binding the contract method 0x3e28391d. -// -// Solidity: function isDelegated(address staker) view returns(bool) -func (_ContractDelegationManager *ContractDelegationManagerSession) IsDelegated(staker common.Address) (bool, error) { - return _ContractDelegationManager.Contract.IsDelegated(&_ContractDelegationManager.CallOpts, staker) -} - -// IsDelegated is a free data retrieval call binding the contract method 0x3e28391d. -// -// Solidity: function isDelegated(address staker) view returns(bool) -func (_ContractDelegationManager *ContractDelegationManagerCallerSession) IsDelegated(staker common.Address) (bool, error) { - return _ContractDelegationManager.Contract.IsDelegated(&_ContractDelegationManager.CallOpts, staker) -} - -// IsOperator is a free data retrieval call binding the contract method 0x6d70f7ae. -// -// Solidity: function isOperator(address operator) view returns(bool) -func (_ContractDelegationManager *ContractDelegationManagerCaller) IsOperator(opts *bind.CallOpts, operator common.Address) (bool, error) { - var out []interface{} - err := _ContractDelegationManager.contract.Call(opts, &out, "isOperator", operator) - - if err != nil { - return *new(bool), err - } - - out0 := *abi.ConvertType(out[0], new(bool)).(*bool) - - return out0, err - -} - -// IsOperator is a free data retrieval call binding the contract method 0x6d70f7ae. -// -// Solidity: function isOperator(address operator) view returns(bool) -func (_ContractDelegationManager *ContractDelegationManagerSession) IsOperator(operator common.Address) (bool, error) { - return _ContractDelegationManager.Contract.IsOperator(&_ContractDelegationManager.CallOpts, operator) -} - -// IsOperator is a free data retrieval call binding the contract method 0x6d70f7ae. -// -// Solidity: function isOperator(address operator) view returns(bool) -func (_ContractDelegationManager *ContractDelegationManagerCallerSession) IsOperator(operator common.Address) (bool, error) { - return _ContractDelegationManager.Contract.IsOperator(&_ContractDelegationManager.CallOpts, operator) -} - -// MinWithdrawalDelayBlocks is a free data retrieval call binding the contract method 0xc448feb8. -// -// Solidity: function minWithdrawalDelayBlocks() view returns(uint256) -func (_ContractDelegationManager *ContractDelegationManagerCaller) MinWithdrawalDelayBlocks(opts *bind.CallOpts) (*big.Int, error) { - var out []interface{} - err := _ContractDelegationManager.contract.Call(opts, &out, "minWithdrawalDelayBlocks") - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// MinWithdrawalDelayBlocks is a free data retrieval call binding the contract method 0xc448feb8. -// -// Solidity: function minWithdrawalDelayBlocks() view returns(uint256) -func (_ContractDelegationManager *ContractDelegationManagerSession) MinWithdrawalDelayBlocks() (*big.Int, error) { - return _ContractDelegationManager.Contract.MinWithdrawalDelayBlocks(&_ContractDelegationManager.CallOpts) -} - -// MinWithdrawalDelayBlocks is a free data retrieval call binding the contract method 0xc448feb8. -// -// Solidity: function minWithdrawalDelayBlocks() view returns(uint256) -func (_ContractDelegationManager *ContractDelegationManagerCallerSession) MinWithdrawalDelayBlocks() (*big.Int, error) { - return _ContractDelegationManager.Contract.MinWithdrawalDelayBlocks(&_ContractDelegationManager.CallOpts) -} - -// OperatorDetails is a free data retrieval call binding the contract method 0xc5e480db. -// -// Solidity: function operatorDetails(address operator) view returns((address,address,uint32)) -func (_ContractDelegationManager *ContractDelegationManagerCaller) OperatorDetails(opts *bind.CallOpts, operator common.Address) (IDelegationManagerOperatorDetails, error) { - var out []interface{} - err := _ContractDelegationManager.contract.Call(opts, &out, "operatorDetails", operator) - - if err != nil { - return *new(IDelegationManagerOperatorDetails), err - } - - out0 := *abi.ConvertType(out[0], new(IDelegationManagerOperatorDetails)).(*IDelegationManagerOperatorDetails) - - return out0, err - -} - -// OperatorDetails is a free data retrieval call binding the contract method 0xc5e480db. -// -// Solidity: function operatorDetails(address operator) view returns((address,address,uint32)) -func (_ContractDelegationManager *ContractDelegationManagerSession) OperatorDetails(operator common.Address) (IDelegationManagerOperatorDetails, error) { - return _ContractDelegationManager.Contract.OperatorDetails(&_ContractDelegationManager.CallOpts, operator) -} - -// OperatorDetails is a free data retrieval call binding the contract method 0xc5e480db. -// -// Solidity: function operatorDetails(address operator) view returns((address,address,uint32)) -func (_ContractDelegationManager *ContractDelegationManagerCallerSession) OperatorDetails(operator common.Address) (IDelegationManagerOperatorDetails, error) { - return _ContractDelegationManager.Contract.OperatorDetails(&_ContractDelegationManager.CallOpts, operator) -} - -// OperatorShares is a free data retrieval call binding the contract method 0x778e55f3. -// -// Solidity: function operatorShares(address , address ) view returns(uint256) -func (_ContractDelegationManager *ContractDelegationManagerCaller) OperatorShares(opts *bind.CallOpts, arg0 common.Address, arg1 common.Address) (*big.Int, error) { - var out []interface{} - err := _ContractDelegationManager.contract.Call(opts, &out, "operatorShares", arg0, arg1) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// OperatorShares is a free data retrieval call binding the contract method 0x778e55f3. -// -// Solidity: function operatorShares(address , address ) view returns(uint256) -func (_ContractDelegationManager *ContractDelegationManagerSession) OperatorShares(arg0 common.Address, arg1 common.Address) (*big.Int, error) { - return _ContractDelegationManager.Contract.OperatorShares(&_ContractDelegationManager.CallOpts, arg0, arg1) -} - -// OperatorShares is a free data retrieval call binding the contract method 0x778e55f3. -// -// Solidity: function operatorShares(address , address ) view returns(uint256) -func (_ContractDelegationManager *ContractDelegationManagerCallerSession) OperatorShares(arg0 common.Address, arg1 common.Address) (*big.Int, error) { - return _ContractDelegationManager.Contract.OperatorShares(&_ContractDelegationManager.CallOpts, arg0, arg1) -} - -// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. -// -// Solidity: function owner() view returns(address) -func (_ContractDelegationManager *ContractDelegationManagerCaller) Owner(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _ContractDelegationManager.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 (_ContractDelegationManager *ContractDelegationManagerSession) Owner() (common.Address, error) { - return _ContractDelegationManager.Contract.Owner(&_ContractDelegationManager.CallOpts) -} - -// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. -// -// Solidity: function owner() view returns(address) -func (_ContractDelegationManager *ContractDelegationManagerCallerSession) Owner() (common.Address, error) { - return _ContractDelegationManager.Contract.Owner(&_ContractDelegationManager.CallOpts) -} - -// Paused is a free data retrieval call binding the contract method 0x5ac86ab7. -// -// Solidity: function paused(uint8 index) view returns(bool) -func (_ContractDelegationManager *ContractDelegationManagerCaller) Paused(opts *bind.CallOpts, index uint8) (bool, error) { - var out []interface{} - err := _ContractDelegationManager.contract.Call(opts, &out, "paused", index) - - 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 0x5ac86ab7. -// -// Solidity: function paused(uint8 index) view returns(bool) -func (_ContractDelegationManager *ContractDelegationManagerSession) Paused(index uint8) (bool, error) { - return _ContractDelegationManager.Contract.Paused(&_ContractDelegationManager.CallOpts, index) -} - -// Paused is a free data retrieval call binding the contract method 0x5ac86ab7. -// -// Solidity: function paused(uint8 index) view returns(bool) -func (_ContractDelegationManager *ContractDelegationManagerCallerSession) Paused(index uint8) (bool, error) { - return _ContractDelegationManager.Contract.Paused(&_ContractDelegationManager.CallOpts, index) -} - -// Paused0 is a free data retrieval call binding the contract method 0x5c975abb. -// -// Solidity: function paused() view returns(uint256) -func (_ContractDelegationManager *ContractDelegationManagerCaller) Paused0(opts *bind.CallOpts) (*big.Int, error) { - var out []interface{} - err := _ContractDelegationManager.contract.Call(opts, &out, "paused0") - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// Paused0 is a free data retrieval call binding the contract method 0x5c975abb. -// -// Solidity: function paused() view returns(uint256) -func (_ContractDelegationManager *ContractDelegationManagerSession) Paused0() (*big.Int, error) { - return _ContractDelegationManager.Contract.Paused0(&_ContractDelegationManager.CallOpts) -} - -// Paused0 is a free data retrieval call binding the contract method 0x5c975abb. -// -// Solidity: function paused() view returns(uint256) -func (_ContractDelegationManager *ContractDelegationManagerCallerSession) Paused0() (*big.Int, error) { - return _ContractDelegationManager.Contract.Paused0(&_ContractDelegationManager.CallOpts) -} - -// PauserRegistry is a free data retrieval call binding the contract method 0x886f1195. -// -// Solidity: function pauserRegistry() view returns(address) -func (_ContractDelegationManager *ContractDelegationManagerCaller) PauserRegistry(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _ContractDelegationManager.contract.Call(opts, &out, "pauserRegistry") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// PauserRegistry is a free data retrieval call binding the contract method 0x886f1195. -// -// Solidity: function pauserRegistry() view returns(address) -func (_ContractDelegationManager *ContractDelegationManagerSession) PauserRegistry() (common.Address, error) { - return _ContractDelegationManager.Contract.PauserRegistry(&_ContractDelegationManager.CallOpts) -} - -// PauserRegistry is a free data retrieval call binding the contract method 0x886f1195. -// -// Solidity: function pauserRegistry() view returns(address) -func (_ContractDelegationManager *ContractDelegationManagerCallerSession) PauserRegistry() (common.Address, error) { - return _ContractDelegationManager.Contract.PauserRegistry(&_ContractDelegationManager.CallOpts) -} - -// PendingWithdrawals is a free data retrieval call binding the contract method 0xb7f06ebe. -// -// Solidity: function pendingWithdrawals(bytes32 ) view returns(bool) -func (_ContractDelegationManager *ContractDelegationManagerCaller) PendingWithdrawals(opts *bind.CallOpts, arg0 [32]byte) (bool, error) { - var out []interface{} - err := _ContractDelegationManager.contract.Call(opts, &out, "pendingWithdrawals", arg0) - - if err != nil { - return *new(bool), err - } - - out0 := *abi.ConvertType(out[0], new(bool)).(*bool) - - return out0, err - -} - -// PendingWithdrawals is a free data retrieval call binding the contract method 0xb7f06ebe. -// -// Solidity: function pendingWithdrawals(bytes32 ) view returns(bool) -func (_ContractDelegationManager *ContractDelegationManagerSession) PendingWithdrawals(arg0 [32]byte) (bool, error) { - return _ContractDelegationManager.Contract.PendingWithdrawals(&_ContractDelegationManager.CallOpts, arg0) -} - -// PendingWithdrawals is a free data retrieval call binding the contract method 0xb7f06ebe. -// -// Solidity: function pendingWithdrawals(bytes32 ) view returns(bool) -func (_ContractDelegationManager *ContractDelegationManagerCallerSession) PendingWithdrawals(arg0 [32]byte) (bool, error) { - return _ContractDelegationManager.Contract.PendingWithdrawals(&_ContractDelegationManager.CallOpts, arg0) -} - -// Slasher is a free data retrieval call binding the contract method 0xb1344271. -// -// Solidity: function slasher() view returns(address) -func (_ContractDelegationManager *ContractDelegationManagerCaller) Slasher(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _ContractDelegationManager.contract.Call(opts, &out, "slasher") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// Slasher is a free data retrieval call binding the contract method 0xb1344271. -// -// Solidity: function slasher() view returns(address) -func (_ContractDelegationManager *ContractDelegationManagerSession) Slasher() (common.Address, error) { - return _ContractDelegationManager.Contract.Slasher(&_ContractDelegationManager.CallOpts) -} - -// Slasher is a free data retrieval call binding the contract method 0xb1344271. -// -// Solidity: function slasher() view returns(address) -func (_ContractDelegationManager *ContractDelegationManagerCallerSession) Slasher() (common.Address, error) { - return _ContractDelegationManager.Contract.Slasher(&_ContractDelegationManager.CallOpts) -} - -// StakerNonce is a free data retrieval call binding the contract method 0x29c77d4f. -// -// Solidity: function stakerNonce(address ) view returns(uint256) -func (_ContractDelegationManager *ContractDelegationManagerCaller) StakerNonce(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) { - var out []interface{} - err := _ContractDelegationManager.contract.Call(opts, &out, "stakerNonce", arg0) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// StakerNonce is a free data retrieval call binding the contract method 0x29c77d4f. -// -// Solidity: function stakerNonce(address ) view returns(uint256) -func (_ContractDelegationManager *ContractDelegationManagerSession) StakerNonce(arg0 common.Address) (*big.Int, error) { - return _ContractDelegationManager.Contract.StakerNonce(&_ContractDelegationManager.CallOpts, arg0) -} - -// StakerNonce is a free data retrieval call binding the contract method 0x29c77d4f. -// -// Solidity: function stakerNonce(address ) view returns(uint256) -func (_ContractDelegationManager *ContractDelegationManagerCallerSession) StakerNonce(arg0 common.Address) (*big.Int, error) { - return _ContractDelegationManager.Contract.StakerNonce(&_ContractDelegationManager.CallOpts, arg0) -} - -// StakerOptOutWindowBlocks is a free data retrieval call binding the contract method 0x16928365. -// -// Solidity: function stakerOptOutWindowBlocks(address operator) view returns(uint256) -func (_ContractDelegationManager *ContractDelegationManagerCaller) StakerOptOutWindowBlocks(opts *bind.CallOpts, operator common.Address) (*big.Int, error) { - var out []interface{} - err := _ContractDelegationManager.contract.Call(opts, &out, "stakerOptOutWindowBlocks", operator) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// StakerOptOutWindowBlocks is a free data retrieval call binding the contract method 0x16928365. -// -// Solidity: function stakerOptOutWindowBlocks(address operator) view returns(uint256) -func (_ContractDelegationManager *ContractDelegationManagerSession) StakerOptOutWindowBlocks(operator common.Address) (*big.Int, error) { - return _ContractDelegationManager.Contract.StakerOptOutWindowBlocks(&_ContractDelegationManager.CallOpts, operator) -} - -// StakerOptOutWindowBlocks is a free data retrieval call binding the contract method 0x16928365. -// -// Solidity: function stakerOptOutWindowBlocks(address operator) view returns(uint256) -func (_ContractDelegationManager *ContractDelegationManagerCallerSession) StakerOptOutWindowBlocks(operator common.Address) (*big.Int, error) { - return _ContractDelegationManager.Contract.StakerOptOutWindowBlocks(&_ContractDelegationManager.CallOpts, operator) -} - -// StrategyManager is a free data retrieval call binding the contract method 0x39b70e38. -// -// Solidity: function strategyManager() view returns(address) -func (_ContractDelegationManager *ContractDelegationManagerCaller) StrategyManager(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _ContractDelegationManager.contract.Call(opts, &out, "strategyManager") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// StrategyManager is a free data retrieval call binding the contract method 0x39b70e38. -// -// Solidity: function strategyManager() view returns(address) -func (_ContractDelegationManager *ContractDelegationManagerSession) StrategyManager() (common.Address, error) { - return _ContractDelegationManager.Contract.StrategyManager(&_ContractDelegationManager.CallOpts) -} - -// StrategyManager is a free data retrieval call binding the contract method 0x39b70e38. -// -// Solidity: function strategyManager() view returns(address) -func (_ContractDelegationManager *ContractDelegationManagerCallerSession) StrategyManager() (common.Address, error) { - return _ContractDelegationManager.Contract.StrategyManager(&_ContractDelegationManager.CallOpts) -} - -// StrategyWithdrawalDelayBlocks is a free data retrieval call binding the contract method 0xc488375a. -// -// Solidity: function strategyWithdrawalDelayBlocks(address ) view returns(uint256) -func (_ContractDelegationManager *ContractDelegationManagerCaller) StrategyWithdrawalDelayBlocks(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) { - var out []interface{} - err := _ContractDelegationManager.contract.Call(opts, &out, "strategyWithdrawalDelayBlocks", arg0) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// StrategyWithdrawalDelayBlocks is a free data retrieval call binding the contract method 0xc488375a. -// -// Solidity: function strategyWithdrawalDelayBlocks(address ) view returns(uint256) -func (_ContractDelegationManager *ContractDelegationManagerSession) StrategyWithdrawalDelayBlocks(arg0 common.Address) (*big.Int, error) { - return _ContractDelegationManager.Contract.StrategyWithdrawalDelayBlocks(&_ContractDelegationManager.CallOpts, arg0) -} - -// StrategyWithdrawalDelayBlocks is a free data retrieval call binding the contract method 0xc488375a. -// -// Solidity: function strategyWithdrawalDelayBlocks(address ) view returns(uint256) -func (_ContractDelegationManager *ContractDelegationManagerCallerSession) StrategyWithdrawalDelayBlocks(arg0 common.Address) (*big.Int, error) { - return _ContractDelegationManager.Contract.StrategyWithdrawalDelayBlocks(&_ContractDelegationManager.CallOpts, arg0) -} - -// CompleteQueuedWithdrawal is a paid mutator transaction binding the contract method 0x60d7faed. -// -// Solidity: function completeQueuedWithdrawal((address,address,address,uint256,uint32,address[],uint256[]) withdrawal, address[] tokens, uint256 middlewareTimesIndex, bool receiveAsTokens) returns() -func (_ContractDelegationManager *ContractDelegationManagerTransactor) CompleteQueuedWithdrawal(opts *bind.TransactOpts, withdrawal IDelegationManagerWithdrawal, tokens []common.Address, middlewareTimesIndex *big.Int, receiveAsTokens bool) (*types.Transaction, error) { - return _ContractDelegationManager.contract.Transact(opts, "completeQueuedWithdrawal", withdrawal, tokens, middlewareTimesIndex, receiveAsTokens) -} - -// CompleteQueuedWithdrawal is a paid mutator transaction binding the contract method 0x60d7faed. -// -// Solidity: function completeQueuedWithdrawal((address,address,address,uint256,uint32,address[],uint256[]) withdrawal, address[] tokens, uint256 middlewareTimesIndex, bool receiveAsTokens) returns() -func (_ContractDelegationManager *ContractDelegationManagerSession) CompleteQueuedWithdrawal(withdrawal IDelegationManagerWithdrawal, tokens []common.Address, middlewareTimesIndex *big.Int, receiveAsTokens bool) (*types.Transaction, error) { - return _ContractDelegationManager.Contract.CompleteQueuedWithdrawal(&_ContractDelegationManager.TransactOpts, withdrawal, tokens, middlewareTimesIndex, receiveAsTokens) -} - -// CompleteQueuedWithdrawal is a paid mutator transaction binding the contract method 0x60d7faed. -// -// Solidity: function completeQueuedWithdrawal((address,address,address,uint256,uint32,address[],uint256[]) withdrawal, address[] tokens, uint256 middlewareTimesIndex, bool receiveAsTokens) returns() -func (_ContractDelegationManager *ContractDelegationManagerTransactorSession) CompleteQueuedWithdrawal(withdrawal IDelegationManagerWithdrawal, tokens []common.Address, middlewareTimesIndex *big.Int, receiveAsTokens bool) (*types.Transaction, error) { - return _ContractDelegationManager.Contract.CompleteQueuedWithdrawal(&_ContractDelegationManager.TransactOpts, withdrawal, tokens, middlewareTimesIndex, receiveAsTokens) -} - -// CompleteQueuedWithdrawals is a paid mutator transaction binding the contract method 0x33404396. -// -// Solidity: function completeQueuedWithdrawals((address,address,address,uint256,uint32,address[],uint256[])[] withdrawals, address[][] tokens, uint256[] middlewareTimesIndexes, bool[] receiveAsTokens) returns() -func (_ContractDelegationManager *ContractDelegationManagerTransactor) CompleteQueuedWithdrawals(opts *bind.TransactOpts, withdrawals []IDelegationManagerWithdrawal, tokens [][]common.Address, middlewareTimesIndexes []*big.Int, receiveAsTokens []bool) (*types.Transaction, error) { - return _ContractDelegationManager.contract.Transact(opts, "completeQueuedWithdrawals", withdrawals, tokens, middlewareTimesIndexes, receiveAsTokens) -} - -// CompleteQueuedWithdrawals is a paid mutator transaction binding the contract method 0x33404396. -// -// Solidity: function completeQueuedWithdrawals((address,address,address,uint256,uint32,address[],uint256[])[] withdrawals, address[][] tokens, uint256[] middlewareTimesIndexes, bool[] receiveAsTokens) returns() -func (_ContractDelegationManager *ContractDelegationManagerSession) CompleteQueuedWithdrawals(withdrawals []IDelegationManagerWithdrawal, tokens [][]common.Address, middlewareTimesIndexes []*big.Int, receiveAsTokens []bool) (*types.Transaction, error) { - return _ContractDelegationManager.Contract.CompleteQueuedWithdrawals(&_ContractDelegationManager.TransactOpts, withdrawals, tokens, middlewareTimesIndexes, receiveAsTokens) -} - -// CompleteQueuedWithdrawals is a paid mutator transaction binding the contract method 0x33404396. -// -// Solidity: function completeQueuedWithdrawals((address,address,address,uint256,uint32,address[],uint256[])[] withdrawals, address[][] tokens, uint256[] middlewareTimesIndexes, bool[] receiveAsTokens) returns() -func (_ContractDelegationManager *ContractDelegationManagerTransactorSession) CompleteQueuedWithdrawals(withdrawals []IDelegationManagerWithdrawal, tokens [][]common.Address, middlewareTimesIndexes []*big.Int, receiveAsTokens []bool) (*types.Transaction, error) { - return _ContractDelegationManager.Contract.CompleteQueuedWithdrawals(&_ContractDelegationManager.TransactOpts, withdrawals, tokens, middlewareTimesIndexes, receiveAsTokens) -} - -// DecreaseDelegatedShares is a paid mutator transaction binding the contract method 0x132d4967. -// -// Solidity: function decreaseDelegatedShares(address staker, address strategy, uint256 shares) returns() -func (_ContractDelegationManager *ContractDelegationManagerTransactor) DecreaseDelegatedShares(opts *bind.TransactOpts, staker common.Address, strategy common.Address, shares *big.Int) (*types.Transaction, error) { - return _ContractDelegationManager.contract.Transact(opts, "decreaseDelegatedShares", staker, strategy, shares) -} - -// DecreaseDelegatedShares is a paid mutator transaction binding the contract method 0x132d4967. -// -// Solidity: function decreaseDelegatedShares(address staker, address strategy, uint256 shares) returns() -func (_ContractDelegationManager *ContractDelegationManagerSession) DecreaseDelegatedShares(staker common.Address, strategy common.Address, shares *big.Int) (*types.Transaction, error) { - return _ContractDelegationManager.Contract.DecreaseDelegatedShares(&_ContractDelegationManager.TransactOpts, staker, strategy, shares) -} - -// DecreaseDelegatedShares is a paid mutator transaction binding the contract method 0x132d4967. -// -// Solidity: function decreaseDelegatedShares(address staker, address strategy, uint256 shares) returns() -func (_ContractDelegationManager *ContractDelegationManagerTransactorSession) DecreaseDelegatedShares(staker common.Address, strategy common.Address, shares *big.Int) (*types.Transaction, error) { - return _ContractDelegationManager.Contract.DecreaseDelegatedShares(&_ContractDelegationManager.TransactOpts, staker, strategy, shares) -} - -// DelegateTo is a paid mutator transaction binding the contract method 0xeea9064b. -// -// Solidity: function delegateTo(address operator, (bytes,uint256) approverSignatureAndExpiry, bytes32 approverSalt) returns() -func (_ContractDelegationManager *ContractDelegationManagerTransactor) DelegateTo(opts *bind.TransactOpts, operator common.Address, approverSignatureAndExpiry ISignatureUtilsSignatureWithExpiry, approverSalt [32]byte) (*types.Transaction, error) { - return _ContractDelegationManager.contract.Transact(opts, "delegateTo", operator, approverSignatureAndExpiry, approverSalt) -} - -// DelegateTo is a paid mutator transaction binding the contract method 0xeea9064b. -// -// Solidity: function delegateTo(address operator, (bytes,uint256) approverSignatureAndExpiry, bytes32 approverSalt) returns() -func (_ContractDelegationManager *ContractDelegationManagerSession) DelegateTo(operator common.Address, approverSignatureAndExpiry ISignatureUtilsSignatureWithExpiry, approverSalt [32]byte) (*types.Transaction, error) { - return _ContractDelegationManager.Contract.DelegateTo(&_ContractDelegationManager.TransactOpts, operator, approverSignatureAndExpiry, approverSalt) -} - -// DelegateTo is a paid mutator transaction binding the contract method 0xeea9064b. -// -// Solidity: function delegateTo(address operator, (bytes,uint256) approverSignatureAndExpiry, bytes32 approverSalt) returns() -func (_ContractDelegationManager *ContractDelegationManagerTransactorSession) DelegateTo(operator common.Address, approverSignatureAndExpiry ISignatureUtilsSignatureWithExpiry, approverSalt [32]byte) (*types.Transaction, error) { - return _ContractDelegationManager.Contract.DelegateTo(&_ContractDelegationManager.TransactOpts, operator, approverSignatureAndExpiry, approverSalt) -} - -// DelegateToBySignature is a paid mutator transaction binding the contract method 0x7f548071. -// -// Solidity: function delegateToBySignature(address staker, address operator, (bytes,uint256) stakerSignatureAndExpiry, (bytes,uint256) approverSignatureAndExpiry, bytes32 approverSalt) returns() -func (_ContractDelegationManager *ContractDelegationManagerTransactor) DelegateToBySignature(opts *bind.TransactOpts, staker common.Address, operator common.Address, stakerSignatureAndExpiry ISignatureUtilsSignatureWithExpiry, approverSignatureAndExpiry ISignatureUtilsSignatureWithExpiry, approverSalt [32]byte) (*types.Transaction, error) { - return _ContractDelegationManager.contract.Transact(opts, "delegateToBySignature", staker, operator, stakerSignatureAndExpiry, approverSignatureAndExpiry, approverSalt) -} - -// DelegateToBySignature is a paid mutator transaction binding the contract method 0x7f548071. -// -// Solidity: function delegateToBySignature(address staker, address operator, (bytes,uint256) stakerSignatureAndExpiry, (bytes,uint256) approverSignatureAndExpiry, bytes32 approverSalt) returns() -func (_ContractDelegationManager *ContractDelegationManagerSession) DelegateToBySignature(staker common.Address, operator common.Address, stakerSignatureAndExpiry ISignatureUtilsSignatureWithExpiry, approverSignatureAndExpiry ISignatureUtilsSignatureWithExpiry, approverSalt [32]byte) (*types.Transaction, error) { - return _ContractDelegationManager.Contract.DelegateToBySignature(&_ContractDelegationManager.TransactOpts, staker, operator, stakerSignatureAndExpiry, approverSignatureAndExpiry, approverSalt) -} - -// DelegateToBySignature is a paid mutator transaction binding the contract method 0x7f548071. -// -// Solidity: function delegateToBySignature(address staker, address operator, (bytes,uint256) stakerSignatureAndExpiry, (bytes,uint256) approverSignatureAndExpiry, bytes32 approverSalt) returns() -func (_ContractDelegationManager *ContractDelegationManagerTransactorSession) DelegateToBySignature(staker common.Address, operator common.Address, stakerSignatureAndExpiry ISignatureUtilsSignatureWithExpiry, approverSignatureAndExpiry ISignatureUtilsSignatureWithExpiry, approverSalt [32]byte) (*types.Transaction, error) { - return _ContractDelegationManager.Contract.DelegateToBySignature(&_ContractDelegationManager.TransactOpts, staker, operator, stakerSignatureAndExpiry, approverSignatureAndExpiry, approverSalt) -} - -// IncreaseDelegatedShares is a paid mutator transaction binding the contract method 0x28a573ae. -// -// Solidity: function increaseDelegatedShares(address staker, address strategy, uint256 shares) returns() -func (_ContractDelegationManager *ContractDelegationManagerTransactor) IncreaseDelegatedShares(opts *bind.TransactOpts, staker common.Address, strategy common.Address, shares *big.Int) (*types.Transaction, error) { - return _ContractDelegationManager.contract.Transact(opts, "increaseDelegatedShares", staker, strategy, shares) -} - -// IncreaseDelegatedShares is a paid mutator transaction binding the contract method 0x28a573ae. -// -// Solidity: function increaseDelegatedShares(address staker, address strategy, uint256 shares) returns() -func (_ContractDelegationManager *ContractDelegationManagerSession) IncreaseDelegatedShares(staker common.Address, strategy common.Address, shares *big.Int) (*types.Transaction, error) { - return _ContractDelegationManager.Contract.IncreaseDelegatedShares(&_ContractDelegationManager.TransactOpts, staker, strategy, shares) -} - -// IncreaseDelegatedShares is a paid mutator transaction binding the contract method 0x28a573ae. -// -// Solidity: function increaseDelegatedShares(address staker, address strategy, uint256 shares) returns() -func (_ContractDelegationManager *ContractDelegationManagerTransactorSession) IncreaseDelegatedShares(staker common.Address, strategy common.Address, shares *big.Int) (*types.Transaction, error) { - return _ContractDelegationManager.Contract.IncreaseDelegatedShares(&_ContractDelegationManager.TransactOpts, staker, strategy, shares) -} - -// Initialize is a paid mutator transaction binding the contract method 0x22bf40e4. -// -// Solidity: function initialize(address initialOwner, address _pauserRegistry, uint256 initialPausedStatus, uint256 _minWithdrawalDelayBlocks, address[] _strategies, uint256[] _withdrawalDelayBlocks) returns() -func (_ContractDelegationManager *ContractDelegationManagerTransactor) Initialize(opts *bind.TransactOpts, initialOwner common.Address, _pauserRegistry common.Address, initialPausedStatus *big.Int, _minWithdrawalDelayBlocks *big.Int, _strategies []common.Address, _withdrawalDelayBlocks []*big.Int) (*types.Transaction, error) { - return _ContractDelegationManager.contract.Transact(opts, "initialize", initialOwner, _pauserRegistry, initialPausedStatus, _minWithdrawalDelayBlocks, _strategies, _withdrawalDelayBlocks) -} - -// Initialize is a paid mutator transaction binding the contract method 0x22bf40e4. -// -// Solidity: function initialize(address initialOwner, address _pauserRegistry, uint256 initialPausedStatus, uint256 _minWithdrawalDelayBlocks, address[] _strategies, uint256[] _withdrawalDelayBlocks) returns() -func (_ContractDelegationManager *ContractDelegationManagerSession) Initialize(initialOwner common.Address, _pauserRegistry common.Address, initialPausedStatus *big.Int, _minWithdrawalDelayBlocks *big.Int, _strategies []common.Address, _withdrawalDelayBlocks []*big.Int) (*types.Transaction, error) { - return _ContractDelegationManager.Contract.Initialize(&_ContractDelegationManager.TransactOpts, initialOwner, _pauserRegistry, initialPausedStatus, _minWithdrawalDelayBlocks, _strategies, _withdrawalDelayBlocks) -} - -// Initialize is a paid mutator transaction binding the contract method 0x22bf40e4. -// -// Solidity: function initialize(address initialOwner, address _pauserRegistry, uint256 initialPausedStatus, uint256 _minWithdrawalDelayBlocks, address[] _strategies, uint256[] _withdrawalDelayBlocks) returns() -func (_ContractDelegationManager *ContractDelegationManagerTransactorSession) Initialize(initialOwner common.Address, _pauserRegistry common.Address, initialPausedStatus *big.Int, _minWithdrawalDelayBlocks *big.Int, _strategies []common.Address, _withdrawalDelayBlocks []*big.Int) (*types.Transaction, error) { - return _ContractDelegationManager.Contract.Initialize(&_ContractDelegationManager.TransactOpts, initialOwner, _pauserRegistry, initialPausedStatus, _minWithdrawalDelayBlocks, _strategies, _withdrawalDelayBlocks) -} - -// MigrateQueuedWithdrawals is a paid mutator transaction binding the contract method 0x5cfe8d2c. -// -// Solidity: function migrateQueuedWithdrawals((address[],uint256[],address,(address,uint96),uint32,address)[] withdrawalsToMigrate) returns() -func (_ContractDelegationManager *ContractDelegationManagerTransactor) MigrateQueuedWithdrawals(opts *bind.TransactOpts, withdrawalsToMigrate []IStrategyManagerDeprecatedStructQueuedWithdrawal) (*types.Transaction, error) { - return _ContractDelegationManager.contract.Transact(opts, "migrateQueuedWithdrawals", withdrawalsToMigrate) -} - -// MigrateQueuedWithdrawals is a paid mutator transaction binding the contract method 0x5cfe8d2c. -// -// Solidity: function migrateQueuedWithdrawals((address[],uint256[],address,(address,uint96),uint32,address)[] withdrawalsToMigrate) returns() -func (_ContractDelegationManager *ContractDelegationManagerSession) MigrateQueuedWithdrawals(withdrawalsToMigrate []IStrategyManagerDeprecatedStructQueuedWithdrawal) (*types.Transaction, error) { - return _ContractDelegationManager.Contract.MigrateQueuedWithdrawals(&_ContractDelegationManager.TransactOpts, withdrawalsToMigrate) -} - -// MigrateQueuedWithdrawals is a paid mutator transaction binding the contract method 0x5cfe8d2c. -// -// Solidity: function migrateQueuedWithdrawals((address[],uint256[],address,(address,uint96),uint32,address)[] withdrawalsToMigrate) returns() -func (_ContractDelegationManager *ContractDelegationManagerTransactorSession) MigrateQueuedWithdrawals(withdrawalsToMigrate []IStrategyManagerDeprecatedStructQueuedWithdrawal) (*types.Transaction, error) { - return _ContractDelegationManager.Contract.MigrateQueuedWithdrawals(&_ContractDelegationManager.TransactOpts, withdrawalsToMigrate) -} - -// ModifyOperatorDetails is a paid mutator transaction binding the contract method 0xf16172b0. -// -// Solidity: function modifyOperatorDetails((address,address,uint32) newOperatorDetails) returns() -func (_ContractDelegationManager *ContractDelegationManagerTransactor) ModifyOperatorDetails(opts *bind.TransactOpts, newOperatorDetails IDelegationManagerOperatorDetails) (*types.Transaction, error) { - return _ContractDelegationManager.contract.Transact(opts, "modifyOperatorDetails", newOperatorDetails) -} - -// ModifyOperatorDetails is a paid mutator transaction binding the contract method 0xf16172b0. -// -// Solidity: function modifyOperatorDetails((address,address,uint32) newOperatorDetails) returns() -func (_ContractDelegationManager *ContractDelegationManagerSession) ModifyOperatorDetails(newOperatorDetails IDelegationManagerOperatorDetails) (*types.Transaction, error) { - return _ContractDelegationManager.Contract.ModifyOperatorDetails(&_ContractDelegationManager.TransactOpts, newOperatorDetails) -} - -// ModifyOperatorDetails is a paid mutator transaction binding the contract method 0xf16172b0. -// -// Solidity: function modifyOperatorDetails((address,address,uint32) newOperatorDetails) returns() -func (_ContractDelegationManager *ContractDelegationManagerTransactorSession) ModifyOperatorDetails(newOperatorDetails IDelegationManagerOperatorDetails) (*types.Transaction, error) { - return _ContractDelegationManager.Contract.ModifyOperatorDetails(&_ContractDelegationManager.TransactOpts, newOperatorDetails) -} - -// Pause is a paid mutator transaction binding the contract method 0x136439dd. -// -// Solidity: function pause(uint256 newPausedStatus) returns() -func (_ContractDelegationManager *ContractDelegationManagerTransactor) Pause(opts *bind.TransactOpts, newPausedStatus *big.Int) (*types.Transaction, error) { - return _ContractDelegationManager.contract.Transact(opts, "pause", newPausedStatus) -} - -// Pause is a paid mutator transaction binding the contract method 0x136439dd. -// -// Solidity: function pause(uint256 newPausedStatus) returns() -func (_ContractDelegationManager *ContractDelegationManagerSession) Pause(newPausedStatus *big.Int) (*types.Transaction, error) { - return _ContractDelegationManager.Contract.Pause(&_ContractDelegationManager.TransactOpts, newPausedStatus) -} - -// Pause is a paid mutator transaction binding the contract method 0x136439dd. -// -// Solidity: function pause(uint256 newPausedStatus) returns() -func (_ContractDelegationManager *ContractDelegationManagerTransactorSession) Pause(newPausedStatus *big.Int) (*types.Transaction, error) { - return _ContractDelegationManager.Contract.Pause(&_ContractDelegationManager.TransactOpts, newPausedStatus) -} - -// PauseAll is a paid mutator transaction binding the contract method 0x595c6a67. -// -// Solidity: function pauseAll() returns() -func (_ContractDelegationManager *ContractDelegationManagerTransactor) PauseAll(opts *bind.TransactOpts) (*types.Transaction, error) { - return _ContractDelegationManager.contract.Transact(opts, "pauseAll") -} - -// PauseAll is a paid mutator transaction binding the contract method 0x595c6a67. -// -// Solidity: function pauseAll() returns() -func (_ContractDelegationManager *ContractDelegationManagerSession) PauseAll() (*types.Transaction, error) { - return _ContractDelegationManager.Contract.PauseAll(&_ContractDelegationManager.TransactOpts) -} - -// PauseAll is a paid mutator transaction binding the contract method 0x595c6a67. -// -// Solidity: function pauseAll() returns() -func (_ContractDelegationManager *ContractDelegationManagerTransactorSession) PauseAll() (*types.Transaction, error) { - return _ContractDelegationManager.Contract.PauseAll(&_ContractDelegationManager.TransactOpts) -} - -// QueueWithdrawals is a paid mutator transaction binding the contract method 0x0dd8dd02. -// -// Solidity: function queueWithdrawals((address[],uint256[],address)[] queuedWithdrawalParams) returns(bytes32[]) -func (_ContractDelegationManager *ContractDelegationManagerTransactor) QueueWithdrawals(opts *bind.TransactOpts, queuedWithdrawalParams []IDelegationManagerQueuedWithdrawalParams) (*types.Transaction, error) { - return _ContractDelegationManager.contract.Transact(opts, "queueWithdrawals", queuedWithdrawalParams) -} - -// QueueWithdrawals is a paid mutator transaction binding the contract method 0x0dd8dd02. -// -// Solidity: function queueWithdrawals((address[],uint256[],address)[] queuedWithdrawalParams) returns(bytes32[]) -func (_ContractDelegationManager *ContractDelegationManagerSession) QueueWithdrawals(queuedWithdrawalParams []IDelegationManagerQueuedWithdrawalParams) (*types.Transaction, error) { - return _ContractDelegationManager.Contract.QueueWithdrawals(&_ContractDelegationManager.TransactOpts, queuedWithdrawalParams) -} - -// QueueWithdrawals is a paid mutator transaction binding the contract method 0x0dd8dd02. -// -// Solidity: function queueWithdrawals((address[],uint256[],address)[] queuedWithdrawalParams) returns(bytes32[]) -func (_ContractDelegationManager *ContractDelegationManagerTransactorSession) QueueWithdrawals(queuedWithdrawalParams []IDelegationManagerQueuedWithdrawalParams) (*types.Transaction, error) { - return _ContractDelegationManager.Contract.QueueWithdrawals(&_ContractDelegationManager.TransactOpts, queuedWithdrawalParams) -} - -// RegisterAsOperator is a paid mutator transaction binding the contract method 0x0f589e59. -// -// Solidity: function registerAsOperator((address,address,uint32) registeringOperatorDetails, string metadataURI) returns() -func (_ContractDelegationManager *ContractDelegationManagerTransactor) RegisterAsOperator(opts *bind.TransactOpts, registeringOperatorDetails IDelegationManagerOperatorDetails, metadataURI string) (*types.Transaction, error) { - return _ContractDelegationManager.contract.Transact(opts, "registerAsOperator", registeringOperatorDetails, metadataURI) -} - -// RegisterAsOperator is a paid mutator transaction binding the contract method 0x0f589e59. -// -// Solidity: function registerAsOperator((address,address,uint32) registeringOperatorDetails, string metadataURI) returns() -func (_ContractDelegationManager *ContractDelegationManagerSession) RegisterAsOperator(registeringOperatorDetails IDelegationManagerOperatorDetails, metadataURI string) (*types.Transaction, error) { - return _ContractDelegationManager.Contract.RegisterAsOperator(&_ContractDelegationManager.TransactOpts, registeringOperatorDetails, metadataURI) -} - -// RegisterAsOperator is a paid mutator transaction binding the contract method 0x0f589e59. -// -// Solidity: function registerAsOperator((address,address,uint32) registeringOperatorDetails, string metadataURI) returns() -func (_ContractDelegationManager *ContractDelegationManagerTransactorSession) RegisterAsOperator(registeringOperatorDetails IDelegationManagerOperatorDetails, metadataURI string) (*types.Transaction, error) { - return _ContractDelegationManager.Contract.RegisterAsOperator(&_ContractDelegationManager.TransactOpts, registeringOperatorDetails, metadataURI) -} - -// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. -// -// Solidity: function renounceOwnership() returns() -func (_ContractDelegationManager *ContractDelegationManagerTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) { - return _ContractDelegationManager.contract.Transact(opts, "renounceOwnership") -} - -// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. -// -// Solidity: function renounceOwnership() returns() -func (_ContractDelegationManager *ContractDelegationManagerSession) RenounceOwnership() (*types.Transaction, error) { - return _ContractDelegationManager.Contract.RenounceOwnership(&_ContractDelegationManager.TransactOpts) -} - -// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. -// -// Solidity: function renounceOwnership() returns() -func (_ContractDelegationManager *ContractDelegationManagerTransactorSession) RenounceOwnership() (*types.Transaction, error) { - return _ContractDelegationManager.Contract.RenounceOwnership(&_ContractDelegationManager.TransactOpts) -} - -// SetPauserRegistry is a paid mutator transaction binding the contract method 0x10d67a2f. -// -// Solidity: function setPauserRegistry(address newPauserRegistry) returns() -func (_ContractDelegationManager *ContractDelegationManagerTransactor) SetPauserRegistry(opts *bind.TransactOpts, newPauserRegistry common.Address) (*types.Transaction, error) { - return _ContractDelegationManager.contract.Transact(opts, "setPauserRegistry", newPauserRegistry) -} - -// SetPauserRegistry is a paid mutator transaction binding the contract method 0x10d67a2f. -// -// Solidity: function setPauserRegistry(address newPauserRegistry) returns() -func (_ContractDelegationManager *ContractDelegationManagerSession) SetPauserRegistry(newPauserRegistry common.Address) (*types.Transaction, error) { - return _ContractDelegationManager.Contract.SetPauserRegistry(&_ContractDelegationManager.TransactOpts, newPauserRegistry) -} - -// SetPauserRegistry is a paid mutator transaction binding the contract method 0x10d67a2f. -// -// Solidity: function setPauserRegistry(address newPauserRegistry) returns() -func (_ContractDelegationManager *ContractDelegationManagerTransactorSession) SetPauserRegistry(newPauserRegistry common.Address) (*types.Transaction, error) { - return _ContractDelegationManager.Contract.SetPauserRegistry(&_ContractDelegationManager.TransactOpts, newPauserRegistry) -} - -// SetStrategyWithdrawalDelayBlocks is a paid mutator transaction binding the contract method 0x1522bf02. -// -// Solidity: function setStrategyWithdrawalDelayBlocks(address[] strategies, uint256[] withdrawalDelayBlocks) returns() -func (_ContractDelegationManager *ContractDelegationManagerTransactor) SetStrategyWithdrawalDelayBlocks(opts *bind.TransactOpts, strategies []common.Address, withdrawalDelayBlocks []*big.Int) (*types.Transaction, error) { - return _ContractDelegationManager.contract.Transact(opts, "setStrategyWithdrawalDelayBlocks", strategies, withdrawalDelayBlocks) -} - -// SetStrategyWithdrawalDelayBlocks is a paid mutator transaction binding the contract method 0x1522bf02. -// -// Solidity: function setStrategyWithdrawalDelayBlocks(address[] strategies, uint256[] withdrawalDelayBlocks) returns() -func (_ContractDelegationManager *ContractDelegationManagerSession) SetStrategyWithdrawalDelayBlocks(strategies []common.Address, withdrawalDelayBlocks []*big.Int) (*types.Transaction, error) { - return _ContractDelegationManager.Contract.SetStrategyWithdrawalDelayBlocks(&_ContractDelegationManager.TransactOpts, strategies, withdrawalDelayBlocks) -} - -// SetStrategyWithdrawalDelayBlocks is a paid mutator transaction binding the contract method 0x1522bf02. -// -// Solidity: function setStrategyWithdrawalDelayBlocks(address[] strategies, uint256[] withdrawalDelayBlocks) returns() -func (_ContractDelegationManager *ContractDelegationManagerTransactorSession) SetStrategyWithdrawalDelayBlocks(strategies []common.Address, withdrawalDelayBlocks []*big.Int) (*types.Transaction, error) { - return _ContractDelegationManager.Contract.SetStrategyWithdrawalDelayBlocks(&_ContractDelegationManager.TransactOpts, strategies, withdrawalDelayBlocks) -} - -// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. -// -// Solidity: function transferOwnership(address newOwner) returns() -func (_ContractDelegationManager *ContractDelegationManagerTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { - return _ContractDelegationManager.contract.Transact(opts, "transferOwnership", newOwner) -} - -// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. -// -// Solidity: function transferOwnership(address newOwner) returns() -func (_ContractDelegationManager *ContractDelegationManagerSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { - return _ContractDelegationManager.Contract.TransferOwnership(&_ContractDelegationManager.TransactOpts, newOwner) -} - -// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. -// -// Solidity: function transferOwnership(address newOwner) returns() -func (_ContractDelegationManager *ContractDelegationManagerTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { - return _ContractDelegationManager.Contract.TransferOwnership(&_ContractDelegationManager.TransactOpts, newOwner) -} - -// Undelegate is a paid mutator transaction binding the contract method 0xda8be864. -// -// Solidity: function undelegate(address staker) returns(bytes32[] withdrawalRoots) -func (_ContractDelegationManager *ContractDelegationManagerTransactor) Undelegate(opts *bind.TransactOpts, staker common.Address) (*types.Transaction, error) { - return _ContractDelegationManager.contract.Transact(opts, "undelegate", staker) -} - -// Undelegate is a paid mutator transaction binding the contract method 0xda8be864. -// -// Solidity: function undelegate(address staker) returns(bytes32[] withdrawalRoots) -func (_ContractDelegationManager *ContractDelegationManagerSession) Undelegate(staker common.Address) (*types.Transaction, error) { - return _ContractDelegationManager.Contract.Undelegate(&_ContractDelegationManager.TransactOpts, staker) -} - -// Undelegate is a paid mutator transaction binding the contract method 0xda8be864. -// -// Solidity: function undelegate(address staker) returns(bytes32[] withdrawalRoots) -func (_ContractDelegationManager *ContractDelegationManagerTransactorSession) Undelegate(staker common.Address) (*types.Transaction, error) { - return _ContractDelegationManager.Contract.Undelegate(&_ContractDelegationManager.TransactOpts, staker) -} - -// Unpause is a paid mutator transaction binding the contract method 0xfabc1cbc. -// -// Solidity: function unpause(uint256 newPausedStatus) returns() -func (_ContractDelegationManager *ContractDelegationManagerTransactor) Unpause(opts *bind.TransactOpts, newPausedStatus *big.Int) (*types.Transaction, error) { - return _ContractDelegationManager.contract.Transact(opts, "unpause", newPausedStatus) -} - -// Unpause is a paid mutator transaction binding the contract method 0xfabc1cbc. -// -// Solidity: function unpause(uint256 newPausedStatus) returns() -func (_ContractDelegationManager *ContractDelegationManagerSession) Unpause(newPausedStatus *big.Int) (*types.Transaction, error) { - return _ContractDelegationManager.Contract.Unpause(&_ContractDelegationManager.TransactOpts, newPausedStatus) -} - -// Unpause is a paid mutator transaction binding the contract method 0xfabc1cbc. -// -// Solidity: function unpause(uint256 newPausedStatus) returns() -func (_ContractDelegationManager *ContractDelegationManagerTransactorSession) Unpause(newPausedStatus *big.Int) (*types.Transaction, error) { - return _ContractDelegationManager.Contract.Unpause(&_ContractDelegationManager.TransactOpts, newPausedStatus) -} - -// UpdateOperatorMetadataURI is a paid mutator transaction binding the contract method 0x99be81c8. -// -// Solidity: function updateOperatorMetadataURI(string metadataURI) returns() -func (_ContractDelegationManager *ContractDelegationManagerTransactor) UpdateOperatorMetadataURI(opts *bind.TransactOpts, metadataURI string) (*types.Transaction, error) { - return _ContractDelegationManager.contract.Transact(opts, "updateOperatorMetadataURI", metadataURI) -} - -// UpdateOperatorMetadataURI is a paid mutator transaction binding the contract method 0x99be81c8. -// -// Solidity: function updateOperatorMetadataURI(string metadataURI) returns() -func (_ContractDelegationManager *ContractDelegationManagerSession) UpdateOperatorMetadataURI(metadataURI string) (*types.Transaction, error) { - return _ContractDelegationManager.Contract.UpdateOperatorMetadataURI(&_ContractDelegationManager.TransactOpts, metadataURI) -} - -// UpdateOperatorMetadataURI is a paid mutator transaction binding the contract method 0x99be81c8. -// -// Solidity: function updateOperatorMetadataURI(string metadataURI) returns() -func (_ContractDelegationManager *ContractDelegationManagerTransactorSession) UpdateOperatorMetadataURI(metadataURI string) (*types.Transaction, error) { - return _ContractDelegationManager.Contract.UpdateOperatorMetadataURI(&_ContractDelegationManager.TransactOpts, metadataURI) -} - -// ContractDelegationManagerInitializedIterator is returned from FilterInitialized and is used to iterate over the raw logs and unpacked data for Initialized events raised by the ContractDelegationManager contract. -type ContractDelegationManagerInitializedIterator struct { - Event *ContractDelegationManagerInitialized // 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 *ContractDelegationManagerInitializedIterator) 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(ContractDelegationManagerInitialized) - 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(ContractDelegationManagerInitialized) - 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 *ContractDelegationManagerInitializedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ContractDelegationManagerInitializedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ContractDelegationManagerInitialized represents a Initialized event raised by the ContractDelegationManager contract. -type ContractDelegationManagerInitialized 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 (_ContractDelegationManager *ContractDelegationManagerFilterer) FilterInitialized(opts *bind.FilterOpts) (*ContractDelegationManagerInitializedIterator, error) { - - logs, sub, err := _ContractDelegationManager.contract.FilterLogs(opts, "Initialized") - if err != nil { - return nil, err - } - return &ContractDelegationManagerInitializedIterator{contract: _ContractDelegationManager.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 (_ContractDelegationManager *ContractDelegationManagerFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *ContractDelegationManagerInitialized) (event.Subscription, error) { - - logs, sub, err := _ContractDelegationManager.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(ContractDelegationManagerInitialized) - if err := _ContractDelegationManager.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 (_ContractDelegationManager *ContractDelegationManagerFilterer) ParseInitialized(log types.Log) (*ContractDelegationManagerInitialized, error) { - event := new(ContractDelegationManagerInitialized) - if err := _ContractDelegationManager.contract.UnpackLog(event, "Initialized", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ContractDelegationManagerMinWithdrawalDelayBlocksSetIterator is returned from FilterMinWithdrawalDelayBlocksSet and is used to iterate over the raw logs and unpacked data for MinWithdrawalDelayBlocksSet events raised by the ContractDelegationManager contract. -type ContractDelegationManagerMinWithdrawalDelayBlocksSetIterator struct { - Event *ContractDelegationManagerMinWithdrawalDelayBlocksSet // 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 *ContractDelegationManagerMinWithdrawalDelayBlocksSetIterator) 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(ContractDelegationManagerMinWithdrawalDelayBlocksSet) - 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(ContractDelegationManagerMinWithdrawalDelayBlocksSet) - 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 *ContractDelegationManagerMinWithdrawalDelayBlocksSetIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ContractDelegationManagerMinWithdrawalDelayBlocksSetIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ContractDelegationManagerMinWithdrawalDelayBlocksSet represents a MinWithdrawalDelayBlocksSet event raised by the ContractDelegationManager contract. -type ContractDelegationManagerMinWithdrawalDelayBlocksSet struct { - PreviousValue *big.Int - NewValue *big.Int - Raw types.Log // Blockchain specific contextual infos -} - -// FilterMinWithdrawalDelayBlocksSet is a free log retrieval operation binding the contract event 0xafa003cd76f87ff9d62b35beea889920f33c0c42b8d45b74954d61d50f4b6b69. -// -// Solidity: event MinWithdrawalDelayBlocksSet(uint256 previousValue, uint256 newValue) -func (_ContractDelegationManager *ContractDelegationManagerFilterer) FilterMinWithdrawalDelayBlocksSet(opts *bind.FilterOpts) (*ContractDelegationManagerMinWithdrawalDelayBlocksSetIterator, error) { - - logs, sub, err := _ContractDelegationManager.contract.FilterLogs(opts, "MinWithdrawalDelayBlocksSet") - if err != nil { - return nil, err - } - return &ContractDelegationManagerMinWithdrawalDelayBlocksSetIterator{contract: _ContractDelegationManager.contract, event: "MinWithdrawalDelayBlocksSet", logs: logs, sub: sub}, nil -} - -// WatchMinWithdrawalDelayBlocksSet is a free log subscription operation binding the contract event 0xafa003cd76f87ff9d62b35beea889920f33c0c42b8d45b74954d61d50f4b6b69. -// -// Solidity: event MinWithdrawalDelayBlocksSet(uint256 previousValue, uint256 newValue) -func (_ContractDelegationManager *ContractDelegationManagerFilterer) WatchMinWithdrawalDelayBlocksSet(opts *bind.WatchOpts, sink chan<- *ContractDelegationManagerMinWithdrawalDelayBlocksSet) (event.Subscription, error) { - - logs, sub, err := _ContractDelegationManager.contract.WatchLogs(opts, "MinWithdrawalDelayBlocksSet") - 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(ContractDelegationManagerMinWithdrawalDelayBlocksSet) - if err := _ContractDelegationManager.contract.UnpackLog(event, "MinWithdrawalDelayBlocksSet", 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 -} - -// ParseMinWithdrawalDelayBlocksSet is a log parse operation binding the contract event 0xafa003cd76f87ff9d62b35beea889920f33c0c42b8d45b74954d61d50f4b6b69. -// -// Solidity: event MinWithdrawalDelayBlocksSet(uint256 previousValue, uint256 newValue) -func (_ContractDelegationManager *ContractDelegationManagerFilterer) ParseMinWithdrawalDelayBlocksSet(log types.Log) (*ContractDelegationManagerMinWithdrawalDelayBlocksSet, error) { - event := new(ContractDelegationManagerMinWithdrawalDelayBlocksSet) - if err := _ContractDelegationManager.contract.UnpackLog(event, "MinWithdrawalDelayBlocksSet", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ContractDelegationManagerOperatorDetailsModifiedIterator is returned from FilterOperatorDetailsModified and is used to iterate over the raw logs and unpacked data for OperatorDetailsModified events raised by the ContractDelegationManager contract. -type ContractDelegationManagerOperatorDetailsModifiedIterator struct { - Event *ContractDelegationManagerOperatorDetailsModified // 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 *ContractDelegationManagerOperatorDetailsModifiedIterator) 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(ContractDelegationManagerOperatorDetailsModified) - 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(ContractDelegationManagerOperatorDetailsModified) - 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 *ContractDelegationManagerOperatorDetailsModifiedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ContractDelegationManagerOperatorDetailsModifiedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ContractDelegationManagerOperatorDetailsModified represents a OperatorDetailsModified event raised by the ContractDelegationManager contract. -type ContractDelegationManagerOperatorDetailsModified struct { - Operator common.Address - NewOperatorDetails IDelegationManagerOperatorDetails - Raw types.Log // Blockchain specific contextual infos -} - -// FilterOperatorDetailsModified is a free log retrieval operation binding the contract event 0xfebe5cd24b2cbc7b065b9d0fdeb904461e4afcff57dd57acda1e7832031ba7ac. -// -// Solidity: event OperatorDetailsModified(address indexed operator, (address,address,uint32) newOperatorDetails) -func (_ContractDelegationManager *ContractDelegationManagerFilterer) FilterOperatorDetailsModified(opts *bind.FilterOpts, operator []common.Address) (*ContractDelegationManagerOperatorDetailsModifiedIterator, error) { - - var operatorRule []interface{} - for _, operatorItem := range operator { - operatorRule = append(operatorRule, operatorItem) - } - - logs, sub, err := _ContractDelegationManager.contract.FilterLogs(opts, "OperatorDetailsModified", operatorRule) - if err != nil { - return nil, err - } - return &ContractDelegationManagerOperatorDetailsModifiedIterator{contract: _ContractDelegationManager.contract, event: "OperatorDetailsModified", logs: logs, sub: sub}, nil -} - -// WatchOperatorDetailsModified is a free log subscription operation binding the contract event 0xfebe5cd24b2cbc7b065b9d0fdeb904461e4afcff57dd57acda1e7832031ba7ac. -// -// Solidity: event OperatorDetailsModified(address indexed operator, (address,address,uint32) newOperatorDetails) -func (_ContractDelegationManager *ContractDelegationManagerFilterer) WatchOperatorDetailsModified(opts *bind.WatchOpts, sink chan<- *ContractDelegationManagerOperatorDetailsModified, operator []common.Address) (event.Subscription, error) { - - var operatorRule []interface{} - for _, operatorItem := range operator { - operatorRule = append(operatorRule, operatorItem) - } - - logs, sub, err := _ContractDelegationManager.contract.WatchLogs(opts, "OperatorDetailsModified", operatorRule) - 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(ContractDelegationManagerOperatorDetailsModified) - if err := _ContractDelegationManager.contract.UnpackLog(event, "OperatorDetailsModified", 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 -} - -// ParseOperatorDetailsModified is a log parse operation binding the contract event 0xfebe5cd24b2cbc7b065b9d0fdeb904461e4afcff57dd57acda1e7832031ba7ac. -// -// Solidity: event OperatorDetailsModified(address indexed operator, (address,address,uint32) newOperatorDetails) -func (_ContractDelegationManager *ContractDelegationManagerFilterer) ParseOperatorDetailsModified(log types.Log) (*ContractDelegationManagerOperatorDetailsModified, error) { - event := new(ContractDelegationManagerOperatorDetailsModified) - if err := _ContractDelegationManager.contract.UnpackLog(event, "OperatorDetailsModified", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ContractDelegationManagerOperatorMetadataURIUpdatedIterator is returned from FilterOperatorMetadataURIUpdated and is used to iterate over the raw logs and unpacked data for OperatorMetadataURIUpdated events raised by the ContractDelegationManager contract. -type ContractDelegationManagerOperatorMetadataURIUpdatedIterator struct { - Event *ContractDelegationManagerOperatorMetadataURIUpdated // 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 *ContractDelegationManagerOperatorMetadataURIUpdatedIterator) 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(ContractDelegationManagerOperatorMetadataURIUpdated) - 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(ContractDelegationManagerOperatorMetadataURIUpdated) - 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 *ContractDelegationManagerOperatorMetadataURIUpdatedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ContractDelegationManagerOperatorMetadataURIUpdatedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ContractDelegationManagerOperatorMetadataURIUpdated represents a OperatorMetadataURIUpdated event raised by the ContractDelegationManager contract. -type ContractDelegationManagerOperatorMetadataURIUpdated struct { - Operator common.Address - MetadataURI string - Raw types.Log // Blockchain specific contextual infos -} - -// FilterOperatorMetadataURIUpdated is a free log retrieval operation binding the contract event 0x02a919ed0e2acad1dd90f17ef2fa4ae5462ee1339170034a8531cca4b6708090. -// -// Solidity: event OperatorMetadataURIUpdated(address indexed operator, string metadataURI) -func (_ContractDelegationManager *ContractDelegationManagerFilterer) FilterOperatorMetadataURIUpdated(opts *bind.FilterOpts, operator []common.Address) (*ContractDelegationManagerOperatorMetadataURIUpdatedIterator, error) { - - var operatorRule []interface{} - for _, operatorItem := range operator { - operatorRule = append(operatorRule, operatorItem) - } - - logs, sub, err := _ContractDelegationManager.contract.FilterLogs(opts, "OperatorMetadataURIUpdated", operatorRule) - if err != nil { - return nil, err - } - return &ContractDelegationManagerOperatorMetadataURIUpdatedIterator{contract: _ContractDelegationManager.contract, event: "OperatorMetadataURIUpdated", logs: logs, sub: sub}, nil -} - -// WatchOperatorMetadataURIUpdated is a free log subscription operation binding the contract event 0x02a919ed0e2acad1dd90f17ef2fa4ae5462ee1339170034a8531cca4b6708090. -// -// Solidity: event OperatorMetadataURIUpdated(address indexed operator, string metadataURI) -func (_ContractDelegationManager *ContractDelegationManagerFilterer) WatchOperatorMetadataURIUpdated(opts *bind.WatchOpts, sink chan<- *ContractDelegationManagerOperatorMetadataURIUpdated, operator []common.Address) (event.Subscription, error) { - - var operatorRule []interface{} - for _, operatorItem := range operator { - operatorRule = append(operatorRule, operatorItem) - } - - logs, sub, err := _ContractDelegationManager.contract.WatchLogs(opts, "OperatorMetadataURIUpdated", operatorRule) - 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(ContractDelegationManagerOperatorMetadataURIUpdated) - if err := _ContractDelegationManager.contract.UnpackLog(event, "OperatorMetadataURIUpdated", 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 -} - -// ParseOperatorMetadataURIUpdated is a log parse operation binding the contract event 0x02a919ed0e2acad1dd90f17ef2fa4ae5462ee1339170034a8531cca4b6708090. -// -// Solidity: event OperatorMetadataURIUpdated(address indexed operator, string metadataURI) -func (_ContractDelegationManager *ContractDelegationManagerFilterer) ParseOperatorMetadataURIUpdated(log types.Log) (*ContractDelegationManagerOperatorMetadataURIUpdated, error) { - event := new(ContractDelegationManagerOperatorMetadataURIUpdated) - if err := _ContractDelegationManager.contract.UnpackLog(event, "OperatorMetadataURIUpdated", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ContractDelegationManagerOperatorRegisteredIterator is returned from FilterOperatorRegistered and is used to iterate over the raw logs and unpacked data for OperatorRegistered events raised by the ContractDelegationManager contract. -type ContractDelegationManagerOperatorRegisteredIterator struct { - Event *ContractDelegationManagerOperatorRegistered // 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 *ContractDelegationManagerOperatorRegisteredIterator) 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(ContractDelegationManagerOperatorRegistered) - 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(ContractDelegationManagerOperatorRegistered) - 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 *ContractDelegationManagerOperatorRegisteredIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ContractDelegationManagerOperatorRegisteredIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ContractDelegationManagerOperatorRegistered represents a OperatorRegistered event raised by the ContractDelegationManager contract. -type ContractDelegationManagerOperatorRegistered struct { - Operator common.Address - OperatorDetails IDelegationManagerOperatorDetails - Raw types.Log // Blockchain specific contextual infos -} - -// FilterOperatorRegistered is a free log retrieval operation binding the contract event 0x8e8485583a2310d41f7c82b9427d0bd49bad74bb9cff9d3402a29d8f9b28a0e2. -// -// Solidity: event OperatorRegistered(address indexed operator, (address,address,uint32) operatorDetails) -func (_ContractDelegationManager *ContractDelegationManagerFilterer) FilterOperatorRegistered(opts *bind.FilterOpts, operator []common.Address) (*ContractDelegationManagerOperatorRegisteredIterator, error) { - - var operatorRule []interface{} - for _, operatorItem := range operator { - operatorRule = append(operatorRule, operatorItem) - } - - logs, sub, err := _ContractDelegationManager.contract.FilterLogs(opts, "OperatorRegistered", operatorRule) - if err != nil { - return nil, err - } - return &ContractDelegationManagerOperatorRegisteredIterator{contract: _ContractDelegationManager.contract, event: "OperatorRegistered", logs: logs, sub: sub}, nil -} - -// WatchOperatorRegistered is a free log subscription operation binding the contract event 0x8e8485583a2310d41f7c82b9427d0bd49bad74bb9cff9d3402a29d8f9b28a0e2. -// -// Solidity: event OperatorRegistered(address indexed operator, (address,address,uint32) operatorDetails) -func (_ContractDelegationManager *ContractDelegationManagerFilterer) WatchOperatorRegistered(opts *bind.WatchOpts, sink chan<- *ContractDelegationManagerOperatorRegistered, operator []common.Address) (event.Subscription, error) { - - var operatorRule []interface{} - for _, operatorItem := range operator { - operatorRule = append(operatorRule, operatorItem) - } - - logs, sub, err := _ContractDelegationManager.contract.WatchLogs(opts, "OperatorRegistered", operatorRule) - 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(ContractDelegationManagerOperatorRegistered) - if err := _ContractDelegationManager.contract.UnpackLog(event, "OperatorRegistered", 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 -} - -// ParseOperatorRegistered is a log parse operation binding the contract event 0x8e8485583a2310d41f7c82b9427d0bd49bad74bb9cff9d3402a29d8f9b28a0e2. -// -// Solidity: event OperatorRegistered(address indexed operator, (address,address,uint32) operatorDetails) -func (_ContractDelegationManager *ContractDelegationManagerFilterer) ParseOperatorRegistered(log types.Log) (*ContractDelegationManagerOperatorRegistered, error) { - event := new(ContractDelegationManagerOperatorRegistered) - if err := _ContractDelegationManager.contract.UnpackLog(event, "OperatorRegistered", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ContractDelegationManagerOperatorSharesDecreasedIterator is returned from FilterOperatorSharesDecreased and is used to iterate over the raw logs and unpacked data for OperatorSharesDecreased events raised by the ContractDelegationManager contract. -type ContractDelegationManagerOperatorSharesDecreasedIterator struct { - Event *ContractDelegationManagerOperatorSharesDecreased // 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 *ContractDelegationManagerOperatorSharesDecreasedIterator) 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(ContractDelegationManagerOperatorSharesDecreased) - 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(ContractDelegationManagerOperatorSharesDecreased) - 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 *ContractDelegationManagerOperatorSharesDecreasedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ContractDelegationManagerOperatorSharesDecreasedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ContractDelegationManagerOperatorSharesDecreased represents a OperatorSharesDecreased event raised by the ContractDelegationManager contract. -type ContractDelegationManagerOperatorSharesDecreased struct { - Operator common.Address - Staker common.Address - Strategy common.Address - Shares *big.Int - Raw types.Log // Blockchain specific contextual infos -} - -// FilterOperatorSharesDecreased is a free log retrieval operation binding the contract event 0x6909600037b75d7b4733aedd815442b5ec018a827751c832aaff64eba5d6d2dd. -// -// Solidity: event OperatorSharesDecreased(address indexed operator, address staker, address strategy, uint256 shares) -func (_ContractDelegationManager *ContractDelegationManagerFilterer) FilterOperatorSharesDecreased(opts *bind.FilterOpts, operator []common.Address) (*ContractDelegationManagerOperatorSharesDecreasedIterator, error) { - - var operatorRule []interface{} - for _, operatorItem := range operator { - operatorRule = append(operatorRule, operatorItem) - } - - logs, sub, err := _ContractDelegationManager.contract.FilterLogs(opts, "OperatorSharesDecreased", operatorRule) - if err != nil { - return nil, err - } - return &ContractDelegationManagerOperatorSharesDecreasedIterator{contract: _ContractDelegationManager.contract, event: "OperatorSharesDecreased", logs: logs, sub: sub}, nil -} - -// WatchOperatorSharesDecreased is a free log subscription operation binding the contract event 0x6909600037b75d7b4733aedd815442b5ec018a827751c832aaff64eba5d6d2dd. -// -// Solidity: event OperatorSharesDecreased(address indexed operator, address staker, address strategy, uint256 shares) -func (_ContractDelegationManager *ContractDelegationManagerFilterer) WatchOperatorSharesDecreased(opts *bind.WatchOpts, sink chan<- *ContractDelegationManagerOperatorSharesDecreased, operator []common.Address) (event.Subscription, error) { - - var operatorRule []interface{} - for _, operatorItem := range operator { - operatorRule = append(operatorRule, operatorItem) - } - - logs, sub, err := _ContractDelegationManager.contract.WatchLogs(opts, "OperatorSharesDecreased", operatorRule) - 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(ContractDelegationManagerOperatorSharesDecreased) - if err := _ContractDelegationManager.contract.UnpackLog(event, "OperatorSharesDecreased", 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 -} - -// ParseOperatorSharesDecreased is a log parse operation binding the contract event 0x6909600037b75d7b4733aedd815442b5ec018a827751c832aaff64eba5d6d2dd. -// -// Solidity: event OperatorSharesDecreased(address indexed operator, address staker, address strategy, uint256 shares) -func (_ContractDelegationManager *ContractDelegationManagerFilterer) ParseOperatorSharesDecreased(log types.Log) (*ContractDelegationManagerOperatorSharesDecreased, error) { - event := new(ContractDelegationManagerOperatorSharesDecreased) - if err := _ContractDelegationManager.contract.UnpackLog(event, "OperatorSharesDecreased", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ContractDelegationManagerOperatorSharesIncreasedIterator is returned from FilterOperatorSharesIncreased and is used to iterate over the raw logs and unpacked data for OperatorSharesIncreased events raised by the ContractDelegationManager contract. -type ContractDelegationManagerOperatorSharesIncreasedIterator struct { - Event *ContractDelegationManagerOperatorSharesIncreased // 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 *ContractDelegationManagerOperatorSharesIncreasedIterator) 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(ContractDelegationManagerOperatorSharesIncreased) - 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(ContractDelegationManagerOperatorSharesIncreased) - 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 *ContractDelegationManagerOperatorSharesIncreasedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ContractDelegationManagerOperatorSharesIncreasedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ContractDelegationManagerOperatorSharesIncreased represents a OperatorSharesIncreased event raised by the ContractDelegationManager contract. -type ContractDelegationManagerOperatorSharesIncreased struct { - Operator common.Address - Staker common.Address - Strategy common.Address - Shares *big.Int - Raw types.Log // Blockchain specific contextual infos -} - -// FilterOperatorSharesIncreased is a free log retrieval operation binding the contract event 0x1ec042c965e2edd7107b51188ee0f383e22e76179041ab3a9d18ff151405166c. -// -// Solidity: event OperatorSharesIncreased(address indexed operator, address staker, address strategy, uint256 shares) -func (_ContractDelegationManager *ContractDelegationManagerFilterer) FilterOperatorSharesIncreased(opts *bind.FilterOpts, operator []common.Address) (*ContractDelegationManagerOperatorSharesIncreasedIterator, error) { - - var operatorRule []interface{} - for _, operatorItem := range operator { - operatorRule = append(operatorRule, operatorItem) - } - - logs, sub, err := _ContractDelegationManager.contract.FilterLogs(opts, "OperatorSharesIncreased", operatorRule) - if err != nil { - return nil, err - } - return &ContractDelegationManagerOperatorSharesIncreasedIterator{contract: _ContractDelegationManager.contract, event: "OperatorSharesIncreased", logs: logs, sub: sub}, nil -} - -// WatchOperatorSharesIncreased is a free log subscription operation binding the contract event 0x1ec042c965e2edd7107b51188ee0f383e22e76179041ab3a9d18ff151405166c. -// -// Solidity: event OperatorSharesIncreased(address indexed operator, address staker, address strategy, uint256 shares) -func (_ContractDelegationManager *ContractDelegationManagerFilterer) WatchOperatorSharesIncreased(opts *bind.WatchOpts, sink chan<- *ContractDelegationManagerOperatorSharesIncreased, operator []common.Address) (event.Subscription, error) { - - var operatorRule []interface{} - for _, operatorItem := range operator { - operatorRule = append(operatorRule, operatorItem) - } - - logs, sub, err := _ContractDelegationManager.contract.WatchLogs(opts, "OperatorSharesIncreased", operatorRule) - 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(ContractDelegationManagerOperatorSharesIncreased) - if err := _ContractDelegationManager.contract.UnpackLog(event, "OperatorSharesIncreased", 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 -} - -// ParseOperatorSharesIncreased is a log parse operation binding the contract event 0x1ec042c965e2edd7107b51188ee0f383e22e76179041ab3a9d18ff151405166c. -// -// Solidity: event OperatorSharesIncreased(address indexed operator, address staker, address strategy, uint256 shares) -func (_ContractDelegationManager *ContractDelegationManagerFilterer) ParseOperatorSharesIncreased(log types.Log) (*ContractDelegationManagerOperatorSharesIncreased, error) { - event := new(ContractDelegationManagerOperatorSharesIncreased) - if err := _ContractDelegationManager.contract.UnpackLog(event, "OperatorSharesIncreased", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ContractDelegationManagerOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the ContractDelegationManager contract. -type ContractDelegationManagerOwnershipTransferredIterator struct { - Event *ContractDelegationManagerOwnershipTransferred // 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 *ContractDelegationManagerOwnershipTransferredIterator) 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(ContractDelegationManagerOwnershipTransferred) - 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(ContractDelegationManagerOwnershipTransferred) - 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 *ContractDelegationManagerOwnershipTransferredIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ContractDelegationManagerOwnershipTransferredIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ContractDelegationManagerOwnershipTransferred represents a OwnershipTransferred event raised by the ContractDelegationManager contract. -type ContractDelegationManagerOwnershipTransferred 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 (_ContractDelegationManager *ContractDelegationManagerFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*ContractDelegationManagerOwnershipTransferredIterator, 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 := _ContractDelegationManager.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) - if err != nil { - return nil, err - } - return &ContractDelegationManagerOwnershipTransferredIterator{contract: _ContractDelegationManager.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 (_ContractDelegationManager *ContractDelegationManagerFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *ContractDelegationManagerOwnershipTransferred, 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 := _ContractDelegationManager.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(ContractDelegationManagerOwnershipTransferred) - if err := _ContractDelegationManager.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 (_ContractDelegationManager *ContractDelegationManagerFilterer) ParseOwnershipTransferred(log types.Log) (*ContractDelegationManagerOwnershipTransferred, error) { - event := new(ContractDelegationManagerOwnershipTransferred) - if err := _ContractDelegationManager.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ContractDelegationManagerPausedIterator is returned from FilterPaused and is used to iterate over the raw logs and unpacked data for Paused events raised by the ContractDelegationManager contract. -type ContractDelegationManagerPausedIterator struct { - Event *ContractDelegationManagerPaused // 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 *ContractDelegationManagerPausedIterator) 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(ContractDelegationManagerPaused) - 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(ContractDelegationManagerPaused) - 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 *ContractDelegationManagerPausedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ContractDelegationManagerPausedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ContractDelegationManagerPaused represents a Paused event raised by the ContractDelegationManager contract. -type ContractDelegationManagerPaused struct { - Account common.Address - NewPausedStatus *big.Int - Raw types.Log // Blockchain specific contextual infos -} - -// FilterPaused is a free log retrieval operation binding the contract event 0xab40a374bc51de372200a8bc981af8c9ecdc08dfdaef0bb6e09f88f3c616ef3d. -// -// Solidity: event Paused(address indexed account, uint256 newPausedStatus) -func (_ContractDelegationManager *ContractDelegationManagerFilterer) FilterPaused(opts *bind.FilterOpts, account []common.Address) (*ContractDelegationManagerPausedIterator, error) { - - var accountRule []interface{} - for _, accountItem := range account { - accountRule = append(accountRule, accountItem) - } - - logs, sub, err := _ContractDelegationManager.contract.FilterLogs(opts, "Paused", accountRule) - if err != nil { - return nil, err - } - return &ContractDelegationManagerPausedIterator{contract: _ContractDelegationManager.contract, event: "Paused", logs: logs, sub: sub}, nil -} - -// WatchPaused is a free log subscription operation binding the contract event 0xab40a374bc51de372200a8bc981af8c9ecdc08dfdaef0bb6e09f88f3c616ef3d. -// -// Solidity: event Paused(address indexed account, uint256 newPausedStatus) -func (_ContractDelegationManager *ContractDelegationManagerFilterer) WatchPaused(opts *bind.WatchOpts, sink chan<- *ContractDelegationManagerPaused, account []common.Address) (event.Subscription, error) { - - var accountRule []interface{} - for _, accountItem := range account { - accountRule = append(accountRule, accountItem) - } - - logs, sub, err := _ContractDelegationManager.contract.WatchLogs(opts, "Paused", 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(ContractDelegationManagerPaused) - if err := _ContractDelegationManager.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 0xab40a374bc51de372200a8bc981af8c9ecdc08dfdaef0bb6e09f88f3c616ef3d. -// -// Solidity: event Paused(address indexed account, uint256 newPausedStatus) -func (_ContractDelegationManager *ContractDelegationManagerFilterer) ParsePaused(log types.Log) (*ContractDelegationManagerPaused, error) { - event := new(ContractDelegationManagerPaused) - if err := _ContractDelegationManager.contract.UnpackLog(event, "Paused", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ContractDelegationManagerPauserRegistrySetIterator is returned from FilterPauserRegistrySet and is used to iterate over the raw logs and unpacked data for PauserRegistrySet events raised by the ContractDelegationManager contract. -type ContractDelegationManagerPauserRegistrySetIterator struct { - Event *ContractDelegationManagerPauserRegistrySet // 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 *ContractDelegationManagerPauserRegistrySetIterator) 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(ContractDelegationManagerPauserRegistrySet) - 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(ContractDelegationManagerPauserRegistrySet) - 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 *ContractDelegationManagerPauserRegistrySetIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ContractDelegationManagerPauserRegistrySetIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ContractDelegationManagerPauserRegistrySet represents a PauserRegistrySet event raised by the ContractDelegationManager contract. -type ContractDelegationManagerPauserRegistrySet struct { - PauserRegistry common.Address - NewPauserRegistry common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterPauserRegistrySet is a free log retrieval operation binding the contract event 0x6e9fcd539896fca60e8b0f01dd580233e48a6b0f7df013b89ba7f565869acdb6. -// -// Solidity: event PauserRegistrySet(address pauserRegistry, address newPauserRegistry) -func (_ContractDelegationManager *ContractDelegationManagerFilterer) FilterPauserRegistrySet(opts *bind.FilterOpts) (*ContractDelegationManagerPauserRegistrySetIterator, error) { - - logs, sub, err := _ContractDelegationManager.contract.FilterLogs(opts, "PauserRegistrySet") - if err != nil { - return nil, err - } - return &ContractDelegationManagerPauserRegistrySetIterator{contract: _ContractDelegationManager.contract, event: "PauserRegistrySet", logs: logs, sub: sub}, nil -} - -// WatchPauserRegistrySet is a free log subscription operation binding the contract event 0x6e9fcd539896fca60e8b0f01dd580233e48a6b0f7df013b89ba7f565869acdb6. -// -// Solidity: event PauserRegistrySet(address pauserRegistry, address newPauserRegistry) -func (_ContractDelegationManager *ContractDelegationManagerFilterer) WatchPauserRegistrySet(opts *bind.WatchOpts, sink chan<- *ContractDelegationManagerPauserRegistrySet) (event.Subscription, error) { - - logs, sub, err := _ContractDelegationManager.contract.WatchLogs(opts, "PauserRegistrySet") - 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(ContractDelegationManagerPauserRegistrySet) - if err := _ContractDelegationManager.contract.UnpackLog(event, "PauserRegistrySet", 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 -} - -// ParsePauserRegistrySet is a log parse operation binding the contract event 0x6e9fcd539896fca60e8b0f01dd580233e48a6b0f7df013b89ba7f565869acdb6. -// -// Solidity: event PauserRegistrySet(address pauserRegistry, address newPauserRegistry) -func (_ContractDelegationManager *ContractDelegationManagerFilterer) ParsePauserRegistrySet(log types.Log) (*ContractDelegationManagerPauserRegistrySet, error) { - event := new(ContractDelegationManagerPauserRegistrySet) - if err := _ContractDelegationManager.contract.UnpackLog(event, "PauserRegistrySet", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ContractDelegationManagerStakerDelegatedIterator is returned from FilterStakerDelegated and is used to iterate over the raw logs and unpacked data for StakerDelegated events raised by the ContractDelegationManager contract. -type ContractDelegationManagerStakerDelegatedIterator struct { - Event *ContractDelegationManagerStakerDelegated // 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 *ContractDelegationManagerStakerDelegatedIterator) 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(ContractDelegationManagerStakerDelegated) - 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(ContractDelegationManagerStakerDelegated) - 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 *ContractDelegationManagerStakerDelegatedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ContractDelegationManagerStakerDelegatedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ContractDelegationManagerStakerDelegated represents a StakerDelegated event raised by the ContractDelegationManager contract. -type ContractDelegationManagerStakerDelegated struct { - Staker common.Address - Operator common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterStakerDelegated is a free log retrieval operation binding the contract event 0xc3ee9f2e5fda98e8066a1f745b2df9285f416fe98cf2559cd21484b3d8743304. -// -// Solidity: event StakerDelegated(address indexed staker, address indexed operator) -func (_ContractDelegationManager *ContractDelegationManagerFilterer) FilterStakerDelegated(opts *bind.FilterOpts, staker []common.Address, operator []common.Address) (*ContractDelegationManagerStakerDelegatedIterator, error) { - - var stakerRule []interface{} - for _, stakerItem := range staker { - stakerRule = append(stakerRule, stakerItem) - } - var operatorRule []interface{} - for _, operatorItem := range operator { - operatorRule = append(operatorRule, operatorItem) - } - - logs, sub, err := _ContractDelegationManager.contract.FilterLogs(opts, "StakerDelegated", stakerRule, operatorRule) - if err != nil { - return nil, err - } - return &ContractDelegationManagerStakerDelegatedIterator{contract: _ContractDelegationManager.contract, event: "StakerDelegated", logs: logs, sub: sub}, nil -} - -// WatchStakerDelegated is a free log subscription operation binding the contract event 0xc3ee9f2e5fda98e8066a1f745b2df9285f416fe98cf2559cd21484b3d8743304. -// -// Solidity: event StakerDelegated(address indexed staker, address indexed operator) -func (_ContractDelegationManager *ContractDelegationManagerFilterer) WatchStakerDelegated(opts *bind.WatchOpts, sink chan<- *ContractDelegationManagerStakerDelegated, staker []common.Address, operator []common.Address) (event.Subscription, error) { - - var stakerRule []interface{} - for _, stakerItem := range staker { - stakerRule = append(stakerRule, stakerItem) - } - var operatorRule []interface{} - for _, operatorItem := range operator { - operatorRule = append(operatorRule, operatorItem) - } - - logs, sub, err := _ContractDelegationManager.contract.WatchLogs(opts, "StakerDelegated", stakerRule, operatorRule) - 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(ContractDelegationManagerStakerDelegated) - if err := _ContractDelegationManager.contract.UnpackLog(event, "StakerDelegated", 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 -} - -// ParseStakerDelegated is a log parse operation binding the contract event 0xc3ee9f2e5fda98e8066a1f745b2df9285f416fe98cf2559cd21484b3d8743304. -// -// Solidity: event StakerDelegated(address indexed staker, address indexed operator) -func (_ContractDelegationManager *ContractDelegationManagerFilterer) ParseStakerDelegated(log types.Log) (*ContractDelegationManagerStakerDelegated, error) { - event := new(ContractDelegationManagerStakerDelegated) - if err := _ContractDelegationManager.contract.UnpackLog(event, "StakerDelegated", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ContractDelegationManagerStakerForceUndelegatedIterator is returned from FilterStakerForceUndelegated and is used to iterate over the raw logs and unpacked data for StakerForceUndelegated events raised by the ContractDelegationManager contract. -type ContractDelegationManagerStakerForceUndelegatedIterator struct { - Event *ContractDelegationManagerStakerForceUndelegated // 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 *ContractDelegationManagerStakerForceUndelegatedIterator) 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(ContractDelegationManagerStakerForceUndelegated) - 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(ContractDelegationManagerStakerForceUndelegated) - 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 *ContractDelegationManagerStakerForceUndelegatedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ContractDelegationManagerStakerForceUndelegatedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ContractDelegationManagerStakerForceUndelegated represents a StakerForceUndelegated event raised by the ContractDelegationManager contract. -type ContractDelegationManagerStakerForceUndelegated struct { - Staker common.Address - Operator common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterStakerForceUndelegated is a free log retrieval operation binding the contract event 0xf0eddf07e6ea14f388b47e1e94a0f464ecbd9eed4171130e0fc0e99fb4030a8a. -// -// Solidity: event StakerForceUndelegated(address indexed staker, address indexed operator) -func (_ContractDelegationManager *ContractDelegationManagerFilterer) FilterStakerForceUndelegated(opts *bind.FilterOpts, staker []common.Address, operator []common.Address) (*ContractDelegationManagerStakerForceUndelegatedIterator, error) { - - var stakerRule []interface{} - for _, stakerItem := range staker { - stakerRule = append(stakerRule, stakerItem) - } - var operatorRule []interface{} - for _, operatorItem := range operator { - operatorRule = append(operatorRule, operatorItem) - } - - logs, sub, err := _ContractDelegationManager.contract.FilterLogs(opts, "StakerForceUndelegated", stakerRule, operatorRule) - if err != nil { - return nil, err - } - return &ContractDelegationManagerStakerForceUndelegatedIterator{contract: _ContractDelegationManager.contract, event: "StakerForceUndelegated", logs: logs, sub: sub}, nil -} - -// WatchStakerForceUndelegated is a free log subscription operation binding the contract event 0xf0eddf07e6ea14f388b47e1e94a0f464ecbd9eed4171130e0fc0e99fb4030a8a. -// -// Solidity: event StakerForceUndelegated(address indexed staker, address indexed operator) -func (_ContractDelegationManager *ContractDelegationManagerFilterer) WatchStakerForceUndelegated(opts *bind.WatchOpts, sink chan<- *ContractDelegationManagerStakerForceUndelegated, staker []common.Address, operator []common.Address) (event.Subscription, error) { - - var stakerRule []interface{} - for _, stakerItem := range staker { - stakerRule = append(stakerRule, stakerItem) - } - var operatorRule []interface{} - for _, operatorItem := range operator { - operatorRule = append(operatorRule, operatorItem) - } - - logs, sub, err := _ContractDelegationManager.contract.WatchLogs(opts, "StakerForceUndelegated", stakerRule, operatorRule) - 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(ContractDelegationManagerStakerForceUndelegated) - if err := _ContractDelegationManager.contract.UnpackLog(event, "StakerForceUndelegated", 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 -} - -// ParseStakerForceUndelegated is a log parse operation binding the contract event 0xf0eddf07e6ea14f388b47e1e94a0f464ecbd9eed4171130e0fc0e99fb4030a8a. -// -// Solidity: event StakerForceUndelegated(address indexed staker, address indexed operator) -func (_ContractDelegationManager *ContractDelegationManagerFilterer) ParseStakerForceUndelegated(log types.Log) (*ContractDelegationManagerStakerForceUndelegated, error) { - event := new(ContractDelegationManagerStakerForceUndelegated) - if err := _ContractDelegationManager.contract.UnpackLog(event, "StakerForceUndelegated", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ContractDelegationManagerStakerUndelegatedIterator is returned from FilterStakerUndelegated and is used to iterate over the raw logs and unpacked data for StakerUndelegated events raised by the ContractDelegationManager contract. -type ContractDelegationManagerStakerUndelegatedIterator struct { - Event *ContractDelegationManagerStakerUndelegated // 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 *ContractDelegationManagerStakerUndelegatedIterator) 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(ContractDelegationManagerStakerUndelegated) - 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(ContractDelegationManagerStakerUndelegated) - 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 *ContractDelegationManagerStakerUndelegatedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ContractDelegationManagerStakerUndelegatedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ContractDelegationManagerStakerUndelegated represents a StakerUndelegated event raised by the ContractDelegationManager contract. -type ContractDelegationManagerStakerUndelegated struct { - Staker common.Address - Operator common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterStakerUndelegated is a free log retrieval operation binding the contract event 0xfee30966a256b71e14bc0ebfc94315e28ef4a97a7131a9e2b7a310a73af44676. -// -// Solidity: event StakerUndelegated(address indexed staker, address indexed operator) -func (_ContractDelegationManager *ContractDelegationManagerFilterer) FilterStakerUndelegated(opts *bind.FilterOpts, staker []common.Address, operator []common.Address) (*ContractDelegationManagerStakerUndelegatedIterator, error) { - - var stakerRule []interface{} - for _, stakerItem := range staker { - stakerRule = append(stakerRule, stakerItem) - } - var operatorRule []interface{} - for _, operatorItem := range operator { - operatorRule = append(operatorRule, operatorItem) - } - - logs, sub, err := _ContractDelegationManager.contract.FilterLogs(opts, "StakerUndelegated", stakerRule, operatorRule) - if err != nil { - return nil, err - } - return &ContractDelegationManagerStakerUndelegatedIterator{contract: _ContractDelegationManager.contract, event: "StakerUndelegated", logs: logs, sub: sub}, nil -} - -// WatchStakerUndelegated is a free log subscription operation binding the contract event 0xfee30966a256b71e14bc0ebfc94315e28ef4a97a7131a9e2b7a310a73af44676. -// -// Solidity: event StakerUndelegated(address indexed staker, address indexed operator) -func (_ContractDelegationManager *ContractDelegationManagerFilterer) WatchStakerUndelegated(opts *bind.WatchOpts, sink chan<- *ContractDelegationManagerStakerUndelegated, staker []common.Address, operator []common.Address) (event.Subscription, error) { - - var stakerRule []interface{} - for _, stakerItem := range staker { - stakerRule = append(stakerRule, stakerItem) - } - var operatorRule []interface{} - for _, operatorItem := range operator { - operatorRule = append(operatorRule, operatorItem) - } - - logs, sub, err := _ContractDelegationManager.contract.WatchLogs(opts, "StakerUndelegated", stakerRule, operatorRule) - 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(ContractDelegationManagerStakerUndelegated) - if err := _ContractDelegationManager.contract.UnpackLog(event, "StakerUndelegated", 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 -} - -// ParseStakerUndelegated is a log parse operation binding the contract event 0xfee30966a256b71e14bc0ebfc94315e28ef4a97a7131a9e2b7a310a73af44676. -// -// Solidity: event StakerUndelegated(address indexed staker, address indexed operator) -func (_ContractDelegationManager *ContractDelegationManagerFilterer) ParseStakerUndelegated(log types.Log) (*ContractDelegationManagerStakerUndelegated, error) { - event := new(ContractDelegationManagerStakerUndelegated) - if err := _ContractDelegationManager.contract.UnpackLog(event, "StakerUndelegated", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ContractDelegationManagerStrategyWithdrawalDelayBlocksSetIterator is returned from FilterStrategyWithdrawalDelayBlocksSet and is used to iterate over the raw logs and unpacked data for StrategyWithdrawalDelayBlocksSet events raised by the ContractDelegationManager contract. -type ContractDelegationManagerStrategyWithdrawalDelayBlocksSetIterator struct { - Event *ContractDelegationManagerStrategyWithdrawalDelayBlocksSet // 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 *ContractDelegationManagerStrategyWithdrawalDelayBlocksSetIterator) 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(ContractDelegationManagerStrategyWithdrawalDelayBlocksSet) - 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(ContractDelegationManagerStrategyWithdrawalDelayBlocksSet) - 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 *ContractDelegationManagerStrategyWithdrawalDelayBlocksSetIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ContractDelegationManagerStrategyWithdrawalDelayBlocksSetIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ContractDelegationManagerStrategyWithdrawalDelayBlocksSet represents a StrategyWithdrawalDelayBlocksSet event raised by the ContractDelegationManager contract. -type ContractDelegationManagerStrategyWithdrawalDelayBlocksSet struct { - Strategy common.Address - PreviousValue *big.Int - NewValue *big.Int - Raw types.Log // Blockchain specific contextual infos -} - -// FilterStrategyWithdrawalDelayBlocksSet is a free log retrieval operation binding the contract event 0x0e7efa738e8b0ce6376a0c1af471655540d2e9a81647d7b09ed823018426576d. -// -// Solidity: event StrategyWithdrawalDelayBlocksSet(address strategy, uint256 previousValue, uint256 newValue) -func (_ContractDelegationManager *ContractDelegationManagerFilterer) FilterStrategyWithdrawalDelayBlocksSet(opts *bind.FilterOpts) (*ContractDelegationManagerStrategyWithdrawalDelayBlocksSetIterator, error) { - - logs, sub, err := _ContractDelegationManager.contract.FilterLogs(opts, "StrategyWithdrawalDelayBlocksSet") - if err != nil { - return nil, err - } - return &ContractDelegationManagerStrategyWithdrawalDelayBlocksSetIterator{contract: _ContractDelegationManager.contract, event: "StrategyWithdrawalDelayBlocksSet", logs: logs, sub: sub}, nil -} - -// WatchStrategyWithdrawalDelayBlocksSet is a free log subscription operation binding the contract event 0x0e7efa738e8b0ce6376a0c1af471655540d2e9a81647d7b09ed823018426576d. -// -// Solidity: event StrategyWithdrawalDelayBlocksSet(address strategy, uint256 previousValue, uint256 newValue) -func (_ContractDelegationManager *ContractDelegationManagerFilterer) WatchStrategyWithdrawalDelayBlocksSet(opts *bind.WatchOpts, sink chan<- *ContractDelegationManagerStrategyWithdrawalDelayBlocksSet) (event.Subscription, error) { - - logs, sub, err := _ContractDelegationManager.contract.WatchLogs(opts, "StrategyWithdrawalDelayBlocksSet") - 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(ContractDelegationManagerStrategyWithdrawalDelayBlocksSet) - if err := _ContractDelegationManager.contract.UnpackLog(event, "StrategyWithdrawalDelayBlocksSet", 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 -} - -// ParseStrategyWithdrawalDelayBlocksSet is a log parse operation binding the contract event 0x0e7efa738e8b0ce6376a0c1af471655540d2e9a81647d7b09ed823018426576d. -// -// Solidity: event StrategyWithdrawalDelayBlocksSet(address strategy, uint256 previousValue, uint256 newValue) -func (_ContractDelegationManager *ContractDelegationManagerFilterer) ParseStrategyWithdrawalDelayBlocksSet(log types.Log) (*ContractDelegationManagerStrategyWithdrawalDelayBlocksSet, error) { - event := new(ContractDelegationManagerStrategyWithdrawalDelayBlocksSet) - if err := _ContractDelegationManager.contract.UnpackLog(event, "StrategyWithdrawalDelayBlocksSet", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ContractDelegationManagerUnpausedIterator is returned from FilterUnpaused and is used to iterate over the raw logs and unpacked data for Unpaused events raised by the ContractDelegationManager contract. -type ContractDelegationManagerUnpausedIterator struct { - Event *ContractDelegationManagerUnpaused // 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 *ContractDelegationManagerUnpausedIterator) 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(ContractDelegationManagerUnpaused) - 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(ContractDelegationManagerUnpaused) - 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 *ContractDelegationManagerUnpausedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ContractDelegationManagerUnpausedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ContractDelegationManagerUnpaused represents a Unpaused event raised by the ContractDelegationManager contract. -type ContractDelegationManagerUnpaused struct { - Account common.Address - NewPausedStatus *big.Int - Raw types.Log // Blockchain specific contextual infos -} - -// FilterUnpaused is a free log retrieval operation binding the contract event 0x3582d1828e26bf56bd801502bc021ac0bc8afb57c826e4986b45593c8fad389c. -// -// Solidity: event Unpaused(address indexed account, uint256 newPausedStatus) -func (_ContractDelegationManager *ContractDelegationManagerFilterer) FilterUnpaused(opts *bind.FilterOpts, account []common.Address) (*ContractDelegationManagerUnpausedIterator, error) { - - var accountRule []interface{} - for _, accountItem := range account { - accountRule = append(accountRule, accountItem) - } - - logs, sub, err := _ContractDelegationManager.contract.FilterLogs(opts, "Unpaused", accountRule) - if err != nil { - return nil, err - } - return &ContractDelegationManagerUnpausedIterator{contract: _ContractDelegationManager.contract, event: "Unpaused", logs: logs, sub: sub}, nil -} - -// WatchUnpaused is a free log subscription operation binding the contract event 0x3582d1828e26bf56bd801502bc021ac0bc8afb57c826e4986b45593c8fad389c. -// -// Solidity: event Unpaused(address indexed account, uint256 newPausedStatus) -func (_ContractDelegationManager *ContractDelegationManagerFilterer) WatchUnpaused(opts *bind.WatchOpts, sink chan<- *ContractDelegationManagerUnpaused, account []common.Address) (event.Subscription, error) { - - var accountRule []interface{} - for _, accountItem := range account { - accountRule = append(accountRule, accountItem) - } - - logs, sub, err := _ContractDelegationManager.contract.WatchLogs(opts, "Unpaused", 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(ContractDelegationManagerUnpaused) - if err := _ContractDelegationManager.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 0x3582d1828e26bf56bd801502bc021ac0bc8afb57c826e4986b45593c8fad389c. -// -// Solidity: event Unpaused(address indexed account, uint256 newPausedStatus) -func (_ContractDelegationManager *ContractDelegationManagerFilterer) ParseUnpaused(log types.Log) (*ContractDelegationManagerUnpaused, error) { - event := new(ContractDelegationManagerUnpaused) - if err := _ContractDelegationManager.contract.UnpackLog(event, "Unpaused", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ContractDelegationManagerWithdrawalCompletedIterator is returned from FilterWithdrawalCompleted and is used to iterate over the raw logs and unpacked data for WithdrawalCompleted events raised by the ContractDelegationManager contract. -type ContractDelegationManagerWithdrawalCompletedIterator struct { - Event *ContractDelegationManagerWithdrawalCompleted // 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 *ContractDelegationManagerWithdrawalCompletedIterator) 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(ContractDelegationManagerWithdrawalCompleted) - 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(ContractDelegationManagerWithdrawalCompleted) - 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 *ContractDelegationManagerWithdrawalCompletedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ContractDelegationManagerWithdrawalCompletedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ContractDelegationManagerWithdrawalCompleted represents a WithdrawalCompleted event raised by the ContractDelegationManager contract. -type ContractDelegationManagerWithdrawalCompleted struct { - WithdrawalRoot [32]byte - Raw types.Log // Blockchain specific contextual infos -} - -// FilterWithdrawalCompleted is a free log retrieval operation binding the contract event 0xc97098c2f658800b4df29001527f7324bcdffcf6e8751a699ab920a1eced5b1d. -// -// Solidity: event WithdrawalCompleted(bytes32 withdrawalRoot) -func (_ContractDelegationManager *ContractDelegationManagerFilterer) FilterWithdrawalCompleted(opts *bind.FilterOpts) (*ContractDelegationManagerWithdrawalCompletedIterator, error) { - - logs, sub, err := _ContractDelegationManager.contract.FilterLogs(opts, "WithdrawalCompleted") - if err != nil { - return nil, err - } - return &ContractDelegationManagerWithdrawalCompletedIterator{contract: _ContractDelegationManager.contract, event: "WithdrawalCompleted", logs: logs, sub: sub}, nil -} - -// WatchWithdrawalCompleted is a free log subscription operation binding the contract event 0xc97098c2f658800b4df29001527f7324bcdffcf6e8751a699ab920a1eced5b1d. -// -// Solidity: event WithdrawalCompleted(bytes32 withdrawalRoot) -func (_ContractDelegationManager *ContractDelegationManagerFilterer) WatchWithdrawalCompleted(opts *bind.WatchOpts, sink chan<- *ContractDelegationManagerWithdrawalCompleted) (event.Subscription, error) { - - logs, sub, err := _ContractDelegationManager.contract.WatchLogs(opts, "WithdrawalCompleted") - 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(ContractDelegationManagerWithdrawalCompleted) - if err := _ContractDelegationManager.contract.UnpackLog(event, "WithdrawalCompleted", 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 -} - -// ParseWithdrawalCompleted is a log parse operation binding the contract event 0xc97098c2f658800b4df29001527f7324bcdffcf6e8751a699ab920a1eced5b1d. -// -// Solidity: event WithdrawalCompleted(bytes32 withdrawalRoot) -func (_ContractDelegationManager *ContractDelegationManagerFilterer) ParseWithdrawalCompleted(log types.Log) (*ContractDelegationManagerWithdrawalCompleted, error) { - event := new(ContractDelegationManagerWithdrawalCompleted) - if err := _ContractDelegationManager.contract.UnpackLog(event, "WithdrawalCompleted", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ContractDelegationManagerWithdrawalMigratedIterator is returned from FilterWithdrawalMigrated and is used to iterate over the raw logs and unpacked data for WithdrawalMigrated events raised by the ContractDelegationManager contract. -type ContractDelegationManagerWithdrawalMigratedIterator struct { - Event *ContractDelegationManagerWithdrawalMigrated // 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 *ContractDelegationManagerWithdrawalMigratedIterator) 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(ContractDelegationManagerWithdrawalMigrated) - 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(ContractDelegationManagerWithdrawalMigrated) - 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 *ContractDelegationManagerWithdrawalMigratedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ContractDelegationManagerWithdrawalMigratedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ContractDelegationManagerWithdrawalMigrated represents a WithdrawalMigrated event raised by the ContractDelegationManager contract. -type ContractDelegationManagerWithdrawalMigrated struct { - OldWithdrawalRoot [32]byte - NewWithdrawalRoot [32]byte - Raw types.Log // Blockchain specific contextual infos -} - -// FilterWithdrawalMigrated is a free log retrieval operation binding the contract event 0xdc00758b65eef71dc3780c04ebe36cab6bdb266c3a698187e29e0f0dca012630. -// -// Solidity: event WithdrawalMigrated(bytes32 oldWithdrawalRoot, bytes32 newWithdrawalRoot) -func (_ContractDelegationManager *ContractDelegationManagerFilterer) FilterWithdrawalMigrated(opts *bind.FilterOpts) (*ContractDelegationManagerWithdrawalMigratedIterator, error) { - - logs, sub, err := _ContractDelegationManager.contract.FilterLogs(opts, "WithdrawalMigrated") - if err != nil { - return nil, err - } - return &ContractDelegationManagerWithdrawalMigratedIterator{contract: _ContractDelegationManager.contract, event: "WithdrawalMigrated", logs: logs, sub: sub}, nil -} - -// WatchWithdrawalMigrated is a free log subscription operation binding the contract event 0xdc00758b65eef71dc3780c04ebe36cab6bdb266c3a698187e29e0f0dca012630. -// -// Solidity: event WithdrawalMigrated(bytes32 oldWithdrawalRoot, bytes32 newWithdrawalRoot) -func (_ContractDelegationManager *ContractDelegationManagerFilterer) WatchWithdrawalMigrated(opts *bind.WatchOpts, sink chan<- *ContractDelegationManagerWithdrawalMigrated) (event.Subscription, error) { - - logs, sub, err := _ContractDelegationManager.contract.WatchLogs(opts, "WithdrawalMigrated") - 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(ContractDelegationManagerWithdrawalMigrated) - if err := _ContractDelegationManager.contract.UnpackLog(event, "WithdrawalMigrated", 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 -} - -// ParseWithdrawalMigrated is a log parse operation binding the contract event 0xdc00758b65eef71dc3780c04ebe36cab6bdb266c3a698187e29e0f0dca012630. -// -// Solidity: event WithdrawalMigrated(bytes32 oldWithdrawalRoot, bytes32 newWithdrawalRoot) -func (_ContractDelegationManager *ContractDelegationManagerFilterer) ParseWithdrawalMigrated(log types.Log) (*ContractDelegationManagerWithdrawalMigrated, error) { - event := new(ContractDelegationManagerWithdrawalMigrated) - if err := _ContractDelegationManager.contract.UnpackLog(event, "WithdrawalMigrated", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ContractDelegationManagerWithdrawalQueuedIterator is returned from FilterWithdrawalQueued and is used to iterate over the raw logs and unpacked data for WithdrawalQueued events raised by the ContractDelegationManager contract. -type ContractDelegationManagerWithdrawalQueuedIterator struct { - Event *ContractDelegationManagerWithdrawalQueued // 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 *ContractDelegationManagerWithdrawalQueuedIterator) 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(ContractDelegationManagerWithdrawalQueued) - 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(ContractDelegationManagerWithdrawalQueued) - 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 *ContractDelegationManagerWithdrawalQueuedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ContractDelegationManagerWithdrawalQueuedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ContractDelegationManagerWithdrawalQueued represents a WithdrawalQueued event raised by the ContractDelegationManager contract. -type ContractDelegationManagerWithdrawalQueued struct { - WithdrawalRoot [32]byte - Withdrawal IDelegationManagerWithdrawal - Raw types.Log // Blockchain specific contextual infos -} - -// FilterWithdrawalQueued is a free log retrieval operation binding the contract event 0x9009ab153e8014fbfb02f2217f5cde7aa7f9ad734ae85ca3ee3f4ca2fdd499f9. -// -// Solidity: event WithdrawalQueued(bytes32 withdrawalRoot, (address,address,address,uint256,uint32,address[],uint256[]) withdrawal) -func (_ContractDelegationManager *ContractDelegationManagerFilterer) FilterWithdrawalQueued(opts *bind.FilterOpts) (*ContractDelegationManagerWithdrawalQueuedIterator, error) { - - logs, sub, err := _ContractDelegationManager.contract.FilterLogs(opts, "WithdrawalQueued") - if err != nil { - return nil, err - } - return &ContractDelegationManagerWithdrawalQueuedIterator{contract: _ContractDelegationManager.contract, event: "WithdrawalQueued", logs: logs, sub: sub}, nil -} - -// WatchWithdrawalQueued is a free log subscription operation binding the contract event 0x9009ab153e8014fbfb02f2217f5cde7aa7f9ad734ae85ca3ee3f4ca2fdd499f9. -// -// Solidity: event WithdrawalQueued(bytes32 withdrawalRoot, (address,address,address,uint256,uint32,address[],uint256[]) withdrawal) -func (_ContractDelegationManager *ContractDelegationManagerFilterer) WatchWithdrawalQueued(opts *bind.WatchOpts, sink chan<- *ContractDelegationManagerWithdrawalQueued) (event.Subscription, error) { - - logs, sub, err := _ContractDelegationManager.contract.WatchLogs(opts, "WithdrawalQueued") - 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(ContractDelegationManagerWithdrawalQueued) - if err := _ContractDelegationManager.contract.UnpackLog(event, "WithdrawalQueued", 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 -} - -// ParseWithdrawalQueued is a log parse operation binding the contract event 0x9009ab153e8014fbfb02f2217f5cde7aa7f9ad734ae85ca3ee3f4ca2fdd499f9. -// -// Solidity: event WithdrawalQueued(bytes32 withdrawalRoot, (address,address,address,uint256,uint32,address[],uint256[]) withdrawal) -func (_ContractDelegationManager *ContractDelegationManagerFilterer) ParseWithdrawalQueued(log types.Log) (*ContractDelegationManagerWithdrawalQueued, error) { - event := new(ContractDelegationManagerWithdrawalQueued) - if err := _ContractDelegationManager.contract.UnpackLog(event, "WithdrawalQueued", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} diff --git a/contracts/bindings/EOConfig/binding.go b/contracts/bindings/EOConfig/binding.go index f193f0f..0abc33f 100644 --- a/contracts/bindings/EOConfig/binding.go +++ b/contracts/bindings/EOConfig/binding.go @@ -29,135 +29,113 @@ var ( _ = abi.ConvertType ) -// EoconfigMetaData contains all meta data concerning the Eoconfig contract. -var EoconfigMetaData = &bind.MetaData{ +// EOConfigMetaData contains all meta data concerning the EOConfig contract. +var EOConfigMetaData = &bind.MetaData{ ABI: "[{\"type\":\"receive\",\"stateMutability\":\"payable\"},{\"type\":\"function\",\"name\":\"addSource\",\"inputs\":[{\"name\":\"name\",\"type\":\"bytes24\",\"internalType\":\"bytes24\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"addSources\",\"inputs\":[{\"name\":\"names\",\"type\":\"bytes24[]\",\"internalType\":\"bytes24[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"addSymbol\",\"inputs\":[{\"name\":\"name\",\"type\":\"bytes8\",\"internalType\":\"bytes8\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"addSymbols\",\"inputs\":[{\"name\":\"names\",\"type\":\"bytes8[]\",\"internalType\":\"bytes8[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"aggregator\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIEOAggregator\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"aliasToOperator\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"assignAlias\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorAlias\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"chainManager\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"changeAlias\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"newAlias\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"declareAlias\",\"inputs\":[{\"name\":\"operatorAlias\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"evmSourceConfig\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getSourceSymbolId\",\"inputs\":[{\"name\":\"source\",\"type\":\"uint16\",\"internalType\":\"uint16\"},{\"name\":\"symbol\",\"type\":\"uint16\",\"internalType\":\"uint16\"}],\"outputs\":[{\"name\":\"\",\"type\":\"string\",\"internalType\":\"string\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getSourceSymbols\",\"inputs\":[{\"name\":\"id\",\"type\":\"uint16\",\"internalType\":\"uint16\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint16[]\",\"internalType\":\"uint16[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getSymbolSources\",\"inputs\":[{\"name\":\"id\",\"type\":\"uint16\",\"internalType\":\"uint16\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint16[]\",\"internalType\":\"uint16[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"isIdAllowed\",\"inputs\":[{\"name\":\"\",\"type\":\"bytes4\",\"internalType\":\"bytes4\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"notify\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"onStateReceive\",\"inputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"sender\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"data\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"operatorToAlias\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"operatorToRegistrationData\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"owner\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"packPair\",\"inputs\":[{\"name\":\"source\",\"type\":\"uint16\",\"internalType\":\"uint16\"},{\"name\":\"symbol\",\"type\":\"uint16\",\"internalType\":\"uint16\"}],\"outputs\":[{\"name\":\"id\",\"type\":\"bytes4\",\"internalType\":\"bytes4\"}],\"stateMutability\":\"pure\"},{\"type\":\"function\",\"name\":\"removeSource\",\"inputs\":[{\"name\":\"id\",\"type\":\"uint16\",\"internalType\":\"uint16\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"removeSymbol\",\"inputs\":[{\"name\":\"id\",\"type\":\"uint16\",\"internalType\":\"uint16\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"renounceOwnership\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setAggregator\",\"inputs\":[{\"name\":\"_aggregator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setChainManager\",\"inputs\":[{\"name\":\"_chainManager\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setEvmSourceConfig\",\"inputs\":[{\"name\":\"_evmSourceConfig\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setSourceSymbolIds\",\"inputs\":[{\"name\":\"source\",\"type\":\"uint16\",\"internalType\":\"uint16\"},{\"name\":\"symbols\",\"type\":\"uint16[]\",\"internalType\":\"uint16[]\"},{\"name\":\"names\",\"type\":\"string[]\",\"internalType\":\"string[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"sourceById\",\"inputs\":[{\"name\":\"\",\"type\":\"uint16\",\"internalType\":\"uint16\"}],\"outputs\":[{\"name\":\"name\",\"type\":\"bytes24\",\"internalType\":\"bytes24\"},{\"name\":\"id\",\"type\":\"uint16\",\"internalType\":\"uint16\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"sourceId\",\"inputs\":[{\"name\":\"\",\"type\":\"bytes24\",\"internalType\":\"bytes24\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint16\",\"internalType\":\"uint16\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"sourceIds\",\"inputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint16\",\"internalType\":\"uint16\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"sourceIdsLength\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint16\",\"internalType\":\"uint16\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"sourceSymbolOverrides\",\"inputs\":[{\"name\":\"\",\"type\":\"uint16\",\"internalType\":\"uint16\"},{\"name\":\"\",\"type\":\"uint16\",\"internalType\":\"uint16\"}],\"outputs\":[{\"name\":\"\",\"type\":\"string\",\"internalType\":\"string\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"subscribe\",\"inputs\":[{\"name\":\"listener\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"symbolById\",\"inputs\":[{\"name\":\"\",\"type\":\"uint16\",\"internalType\":\"uint16\"}],\"outputs\":[{\"name\":\"name\",\"type\":\"bytes8\",\"internalType\":\"bytes8\"},{\"name\":\"id\",\"type\":\"uint16\",\"internalType\":\"uint16\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"symbolId\",\"inputs\":[{\"name\":\"\",\"type\":\"bytes8\",\"internalType\":\"bytes8\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint16\",\"internalType\":\"uint16\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"symbolIds\",\"inputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint16\",\"internalType\":\"uint16\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"symbolIdsLength\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint16\",\"internalType\":\"uint16\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"transferOwnership\",\"inputs\":[{\"name\":\"newOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"unsubscribe\",\"inputs\":[{\"name\":\"listener\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"updateSource\",\"inputs\":[{\"name\":\"_sourceId\",\"type\":\"uint16\",\"internalType\":\"uint16\"},{\"name\":\"name\",\"type\":\"bytes24\",\"internalType\":\"bytes24\"},{\"name\":\"_symbols\",\"type\":\"uint16[]\",\"internalType\":\"uint16[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"updateSymbol\",\"inputs\":[{\"name\":\"_symbolId\",\"type\":\"uint16\",\"internalType\":\"uint16\"},{\"name\":\"name\",\"type\":\"bytes8\",\"internalType\":\"bytes8\"},{\"name\":\"_sources\",\"type\":\"uint16[]\",\"internalType\":\"uint16[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"Initialized\",\"inputs\":[{\"name\":\"version\",\"type\":\"uint8\",\"indexed\":false,\"internalType\":\"uint8\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OnConfigChange\",\"inputs\":[],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OnSourceAdded\",\"inputs\":[{\"name\":\"id\",\"type\":\"uint16\",\"indexed\":false,\"internalType\":\"uint16\"},{\"name\":\"name\",\"type\":\"bytes24\",\"indexed\":false,\"internalType\":\"bytes24\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OnSourceRemoved\",\"inputs\":[{\"name\":\"id\",\"type\":\"uint16\",\"indexed\":false,\"internalType\":\"uint16\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OnSourceUpdated\",\"inputs\":[{\"name\":\"id\",\"type\":\"uint16\",\"indexed\":false,\"internalType\":\"uint16\"},{\"name\":\"name\",\"type\":\"bytes24\",\"indexed\":false,\"internalType\":\"bytes24\"},{\"name\":\"symbols\",\"type\":\"uint16[]\",\"indexed\":false,\"internalType\":\"uint16[]\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OnSymbolAdded\",\"inputs\":[{\"name\":\"id\",\"type\":\"uint16\",\"indexed\":false,\"internalType\":\"uint16\"},{\"name\":\"name\",\"type\":\"bytes8\",\"indexed\":false,\"internalType\":\"bytes8\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OnSymbolRemoved\",\"inputs\":[{\"name\":\"id\",\"type\":\"uint16\",\"indexed\":false,\"internalType\":\"uint16\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OnSymbolUpdated\",\"inputs\":[{\"name\":\"id\",\"type\":\"uint16\",\"indexed\":false,\"internalType\":\"uint16\"},{\"name\":\"name\",\"type\":\"bytes8\",\"indexed\":false,\"internalType\":\"bytes8\"},{\"name\":\"sources\",\"type\":\"uint16[]\",\"indexed\":false,\"internalType\":\"uint16[]\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OwnershipTransferred\",\"inputs\":[{\"name\":\"previousOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false}]", - Bin: "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", } -// EoconfigABI is the input ABI used to generate the binding from. -// Deprecated: Use EoconfigMetaData.ABI instead. -var EoconfigABI = EoconfigMetaData.ABI +// EOConfigABI is the input ABI used to generate the binding from. +// Deprecated: Use EOConfigMetaData.ABI instead. +var EOConfigABI = EOConfigMetaData.ABI -// EoconfigBin is the compiled bytecode used for deploying new contracts. -// Deprecated: Use EoconfigMetaData.Bin instead. -var EoconfigBin = EoconfigMetaData.Bin - -// DeployEoconfig deploys a new Ethereum contract, binding an instance of Eoconfig to it. -func DeployEoconfig(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Eoconfig, error) { - parsed, err := EoconfigMetaData.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(EoconfigBin), backend) - if err != nil { - return common.Address{}, nil, nil, err - } - return address, tx, &Eoconfig{EoconfigCaller: EoconfigCaller{contract: contract}, EoconfigTransactor: EoconfigTransactor{contract: contract}, EoconfigFilterer: EoconfigFilterer{contract: contract}}, nil -} - -// Eoconfig is an auto generated Go binding around an Ethereum contract. -type Eoconfig struct { - EoconfigCaller // Read-only binding to the contract - EoconfigTransactor // Write-only binding to the contract - EoconfigFilterer // Log filterer for contract events +// EOConfig is an auto generated Go binding around an Ethereum contract. +type EOConfig struct { + EOConfigCaller // Read-only binding to the contract + EOConfigTransactor // Write-only binding to the contract + EOConfigFilterer // Log filterer for contract events } -// EoconfigCaller is an auto generated read-only Go binding around an Ethereum contract. -type EoconfigCaller struct { +// EOConfigCaller is an auto generated read-only Go binding around an Ethereum contract. +type EOConfigCaller struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } -// EoconfigTransactor is an auto generated write-only Go binding around an Ethereum contract. -type EoconfigTransactor struct { +// EOConfigTransactor is an auto generated write-only Go binding around an Ethereum contract. +type EOConfigTransactor struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } -// EoconfigFilterer is an auto generated log filtering Go binding around an Ethereum contract events. -type EoconfigFilterer struct { +// EOConfigFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type EOConfigFilterer struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } -// EoconfigSession is an auto generated Go binding around an Ethereum contract, +// EOConfigSession is an auto generated Go binding around an Ethereum contract, // with pre-set call and transact options. -type EoconfigSession struct { - Contract *Eoconfig // Generic contract binding to set the session for +type EOConfigSession struct { + Contract *EOConfig // 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 } -// EoconfigCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// EOConfigCallerSession is an auto generated read-only Go binding around an Ethereum contract, // with pre-set call options. -type EoconfigCallerSession struct { - Contract *EoconfigCaller // Generic contract caller binding to set the session for +type EOConfigCallerSession struct { + Contract *EOConfigCaller // Generic contract caller binding to set the session for CallOpts bind.CallOpts // Call options to use throughout this session } -// EoconfigTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// EOConfigTransactorSession is an auto generated write-only Go binding around an Ethereum contract, // with pre-set transact options. -type EoconfigTransactorSession struct { - Contract *EoconfigTransactor // Generic contract transactor binding to set the session for +type EOConfigTransactorSession struct { + Contract *EOConfigTransactor // Generic contract transactor binding to set the session for TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session } -// EoconfigRaw is an auto generated low-level Go binding around an Ethereum contract. -type EoconfigRaw struct { - Contract *Eoconfig // Generic contract binding to access the raw methods on +// EOConfigRaw is an auto generated low-level Go binding around an Ethereum contract. +type EOConfigRaw struct { + Contract *EOConfig // Generic contract binding to access the raw methods on } -// EoconfigCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. -type EoconfigCallerRaw struct { - Contract *EoconfigCaller // Generic read-only contract binding to access the raw methods on +// EOConfigCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type EOConfigCallerRaw struct { + Contract *EOConfigCaller // Generic read-only contract binding to access the raw methods on } -// EoconfigTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. -type EoconfigTransactorRaw struct { - Contract *EoconfigTransactor // Generic write-only contract binding to access the raw methods on +// EOConfigTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type EOConfigTransactorRaw struct { + Contract *EOConfigTransactor // Generic write-only contract binding to access the raw methods on } -// NewEoconfig creates a new instance of Eoconfig, bound to a specific deployed contract. -func NewEoconfig(address common.Address, backend bind.ContractBackend) (*Eoconfig, error) { - contract, err := bindEoconfig(address, backend, backend, backend) +// NewEOConfig creates a new instance of EOConfig, bound to a specific deployed contract. +func NewEOConfig(address common.Address, backend bind.ContractBackend) (*EOConfig, error) { + contract, err := bindEOConfig(address, backend, backend, backend) if err != nil { return nil, err } - return &Eoconfig{EoconfigCaller: EoconfigCaller{contract: contract}, EoconfigTransactor: EoconfigTransactor{contract: contract}, EoconfigFilterer: EoconfigFilterer{contract: contract}}, nil + return &EOConfig{EOConfigCaller: EOConfigCaller{contract: contract}, EOConfigTransactor: EOConfigTransactor{contract: contract}, EOConfigFilterer: EOConfigFilterer{contract: contract}}, nil } -// NewEoconfigCaller creates a new read-only instance of Eoconfig, bound to a specific deployed contract. -func NewEoconfigCaller(address common.Address, caller bind.ContractCaller) (*EoconfigCaller, error) { - contract, err := bindEoconfig(address, caller, nil, nil) +// NewEOConfigCaller creates a new read-only instance of EOConfig, bound to a specific deployed contract. +func NewEOConfigCaller(address common.Address, caller bind.ContractCaller) (*EOConfigCaller, error) { + contract, err := bindEOConfig(address, caller, nil, nil) if err != nil { return nil, err } - return &EoconfigCaller{contract: contract}, nil + return &EOConfigCaller{contract: contract}, nil } -// NewEoconfigTransactor creates a new write-only instance of Eoconfig, bound to a specific deployed contract. -func NewEoconfigTransactor(address common.Address, transactor bind.ContractTransactor) (*EoconfigTransactor, error) { - contract, err := bindEoconfig(address, nil, transactor, nil) +// NewEOConfigTransactor creates a new write-only instance of EOConfig, bound to a specific deployed contract. +func NewEOConfigTransactor(address common.Address, transactor bind.ContractTransactor) (*EOConfigTransactor, error) { + contract, err := bindEOConfig(address, nil, transactor, nil) if err != nil { return nil, err } - return &EoconfigTransactor{contract: contract}, nil + return &EOConfigTransactor{contract: contract}, nil } -// NewEoconfigFilterer creates a new log filterer instance of Eoconfig, bound to a specific deployed contract. -func NewEoconfigFilterer(address common.Address, filterer bind.ContractFilterer) (*EoconfigFilterer, error) { - contract, err := bindEoconfig(address, nil, nil, filterer) +// NewEOConfigFilterer creates a new log filterer instance of EOConfig, bound to a specific deployed contract. +func NewEOConfigFilterer(address common.Address, filterer bind.ContractFilterer) (*EOConfigFilterer, error) { + contract, err := bindEOConfig(address, nil, nil, filterer) if err != nil { return nil, err } - return &EoconfigFilterer{contract: contract}, nil + return &EOConfigFilterer{contract: contract}, nil } -// bindEoconfig binds a generic wrapper to an already deployed contract. -func bindEoconfig(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { - parsed, err := EoconfigMetaData.GetAbi() +// bindEOConfig binds a generic wrapper to an already deployed contract. +func bindEOConfig(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := EOConfigMetaData.GetAbi() if err != nil { return nil, err } @@ -168,46 +146,46 @@ func bindEoconfig(address common.Address, caller bind.ContractCaller, transactor // 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 (_Eoconfig *EoconfigRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _Eoconfig.Contract.EoconfigCaller.contract.Call(opts, result, method, params...) +func (_EOConfig *EOConfigRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _EOConfig.Contract.EOConfigCaller.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 (_Eoconfig *EoconfigRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _Eoconfig.Contract.EoconfigTransactor.contract.Transfer(opts) +func (_EOConfig *EOConfigRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _EOConfig.Contract.EOConfigTransactor.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. -func (_Eoconfig *EoconfigRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _Eoconfig.Contract.EoconfigTransactor.contract.Transact(opts, method, params...) +func (_EOConfig *EOConfigRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _EOConfig.Contract.EOConfigTransactor.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 (_Eoconfig *EoconfigCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _Eoconfig.Contract.contract.Call(opts, result, method, params...) +func (_EOConfig *EOConfigCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _EOConfig.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 (_Eoconfig *EoconfigTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _Eoconfig.Contract.contract.Transfer(opts) +func (_EOConfig *EOConfigTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _EOConfig.Contract.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. -func (_Eoconfig *EoconfigTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _Eoconfig.Contract.contract.Transact(opts, method, params...) +func (_EOConfig *EOConfigTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _EOConfig.Contract.contract.Transact(opts, method, params...) } // Aggregator is a free data retrieval call binding the contract method 0x245a7bfc. // // Solidity: function aggregator() view returns(address) -func (_Eoconfig *EoconfigCaller) Aggregator(opts *bind.CallOpts) (common.Address, error) { +func (_EOConfig *EOConfigCaller) Aggregator(opts *bind.CallOpts) (common.Address, error) { var out []interface{} - err := _Eoconfig.contract.Call(opts, &out, "aggregator") + err := _EOConfig.contract.Call(opts, &out, "aggregator") if err != nil { return *new(common.Address), err @@ -222,23 +200,23 @@ func (_Eoconfig *EoconfigCaller) Aggregator(opts *bind.CallOpts) (common.Address // Aggregator is a free data retrieval call binding the contract method 0x245a7bfc. // // Solidity: function aggregator() view returns(address) -func (_Eoconfig *EoconfigSession) Aggregator() (common.Address, error) { - return _Eoconfig.Contract.Aggregator(&_Eoconfig.CallOpts) +func (_EOConfig *EOConfigSession) Aggregator() (common.Address, error) { + return _EOConfig.Contract.Aggregator(&_EOConfig.CallOpts) } // Aggregator is a free data retrieval call binding the contract method 0x245a7bfc. // // Solidity: function aggregator() view returns(address) -func (_Eoconfig *EoconfigCallerSession) Aggregator() (common.Address, error) { - return _Eoconfig.Contract.Aggregator(&_Eoconfig.CallOpts) +func (_EOConfig *EOConfigCallerSession) Aggregator() (common.Address, error) { + return _EOConfig.Contract.Aggregator(&_EOConfig.CallOpts) } // AliasToOperator is a free data retrieval call binding the contract method 0xbfa65472. // // Solidity: function aliasToOperator(address ) view returns(address) -func (_Eoconfig *EoconfigCaller) AliasToOperator(opts *bind.CallOpts, arg0 common.Address) (common.Address, error) { +func (_EOConfig *EOConfigCaller) AliasToOperator(opts *bind.CallOpts, arg0 common.Address) (common.Address, error) { var out []interface{} - err := _Eoconfig.contract.Call(opts, &out, "aliasToOperator", arg0) + err := _EOConfig.contract.Call(opts, &out, "aliasToOperator", arg0) if err != nil { return *new(common.Address), err @@ -253,23 +231,23 @@ func (_Eoconfig *EoconfigCaller) AliasToOperator(opts *bind.CallOpts, arg0 commo // AliasToOperator is a free data retrieval call binding the contract method 0xbfa65472. // // Solidity: function aliasToOperator(address ) view returns(address) -func (_Eoconfig *EoconfigSession) AliasToOperator(arg0 common.Address) (common.Address, error) { - return _Eoconfig.Contract.AliasToOperator(&_Eoconfig.CallOpts, arg0) +func (_EOConfig *EOConfigSession) AliasToOperator(arg0 common.Address) (common.Address, error) { + return _EOConfig.Contract.AliasToOperator(&_EOConfig.CallOpts, arg0) } // AliasToOperator is a free data retrieval call binding the contract method 0xbfa65472. // // Solidity: function aliasToOperator(address ) view returns(address) -func (_Eoconfig *EoconfigCallerSession) AliasToOperator(arg0 common.Address) (common.Address, error) { - return _Eoconfig.Contract.AliasToOperator(&_Eoconfig.CallOpts, arg0) +func (_EOConfig *EOConfigCallerSession) AliasToOperator(arg0 common.Address) (common.Address, error) { + return _EOConfig.Contract.AliasToOperator(&_EOConfig.CallOpts, arg0) } // ChainManager is a free data retrieval call binding the contract method 0x5d824812. // // Solidity: function chainManager() view returns(address) -func (_Eoconfig *EoconfigCaller) ChainManager(opts *bind.CallOpts) (common.Address, error) { +func (_EOConfig *EOConfigCaller) ChainManager(opts *bind.CallOpts) (common.Address, error) { var out []interface{} - err := _Eoconfig.contract.Call(opts, &out, "chainManager") + err := _EOConfig.contract.Call(opts, &out, "chainManager") if err != nil { return *new(common.Address), err @@ -284,23 +262,23 @@ func (_Eoconfig *EoconfigCaller) ChainManager(opts *bind.CallOpts) (common.Addre // ChainManager is a free data retrieval call binding the contract method 0x5d824812. // // Solidity: function chainManager() view returns(address) -func (_Eoconfig *EoconfigSession) ChainManager() (common.Address, error) { - return _Eoconfig.Contract.ChainManager(&_Eoconfig.CallOpts) +func (_EOConfig *EOConfigSession) ChainManager() (common.Address, error) { + return _EOConfig.Contract.ChainManager(&_EOConfig.CallOpts) } // ChainManager is a free data retrieval call binding the contract method 0x5d824812. // // Solidity: function chainManager() view returns(address) -func (_Eoconfig *EoconfigCallerSession) ChainManager() (common.Address, error) { - return _Eoconfig.Contract.ChainManager(&_Eoconfig.CallOpts) +func (_EOConfig *EOConfigCallerSession) ChainManager() (common.Address, error) { + return _EOConfig.Contract.ChainManager(&_EOConfig.CallOpts) } // EvmSourceConfig is a free data retrieval call binding the contract method 0x980690cf. // // Solidity: function evmSourceConfig() view returns(address) -func (_Eoconfig *EoconfigCaller) EvmSourceConfig(opts *bind.CallOpts) (common.Address, error) { +func (_EOConfig *EOConfigCaller) EvmSourceConfig(opts *bind.CallOpts) (common.Address, error) { var out []interface{} - err := _Eoconfig.contract.Call(opts, &out, "evmSourceConfig") + err := _EOConfig.contract.Call(opts, &out, "evmSourceConfig") if err != nil { return *new(common.Address), err @@ -315,23 +293,23 @@ func (_Eoconfig *EoconfigCaller) EvmSourceConfig(opts *bind.CallOpts) (common.Ad // EvmSourceConfig is a free data retrieval call binding the contract method 0x980690cf. // // Solidity: function evmSourceConfig() view returns(address) -func (_Eoconfig *EoconfigSession) EvmSourceConfig() (common.Address, error) { - return _Eoconfig.Contract.EvmSourceConfig(&_Eoconfig.CallOpts) +func (_EOConfig *EOConfigSession) EvmSourceConfig() (common.Address, error) { + return _EOConfig.Contract.EvmSourceConfig(&_EOConfig.CallOpts) } // EvmSourceConfig is a free data retrieval call binding the contract method 0x980690cf. // // Solidity: function evmSourceConfig() view returns(address) -func (_Eoconfig *EoconfigCallerSession) EvmSourceConfig() (common.Address, error) { - return _Eoconfig.Contract.EvmSourceConfig(&_Eoconfig.CallOpts) +func (_EOConfig *EOConfigCallerSession) EvmSourceConfig() (common.Address, error) { + return _EOConfig.Contract.EvmSourceConfig(&_EOConfig.CallOpts) } // GetSourceSymbolId is a free data retrieval call binding the contract method 0xce2fc469. // // Solidity: function getSourceSymbolId(uint16 source, uint16 symbol) view returns(string) -func (_Eoconfig *EoconfigCaller) GetSourceSymbolId(opts *bind.CallOpts, source uint16, symbol uint16) (string, error) { +func (_EOConfig *EOConfigCaller) GetSourceSymbolId(opts *bind.CallOpts, source uint16, symbol uint16) (string, error) { var out []interface{} - err := _Eoconfig.contract.Call(opts, &out, "getSourceSymbolId", source, symbol) + err := _EOConfig.contract.Call(opts, &out, "getSourceSymbolId", source, symbol) if err != nil { return *new(string), err @@ -346,23 +324,23 @@ func (_Eoconfig *EoconfigCaller) GetSourceSymbolId(opts *bind.CallOpts, source u // GetSourceSymbolId is a free data retrieval call binding the contract method 0xce2fc469. // // Solidity: function getSourceSymbolId(uint16 source, uint16 symbol) view returns(string) -func (_Eoconfig *EoconfigSession) GetSourceSymbolId(source uint16, symbol uint16) (string, error) { - return _Eoconfig.Contract.GetSourceSymbolId(&_Eoconfig.CallOpts, source, symbol) +func (_EOConfig *EOConfigSession) GetSourceSymbolId(source uint16, symbol uint16) (string, error) { + return _EOConfig.Contract.GetSourceSymbolId(&_EOConfig.CallOpts, source, symbol) } // GetSourceSymbolId is a free data retrieval call binding the contract method 0xce2fc469. // // Solidity: function getSourceSymbolId(uint16 source, uint16 symbol) view returns(string) -func (_Eoconfig *EoconfigCallerSession) GetSourceSymbolId(source uint16, symbol uint16) (string, error) { - return _Eoconfig.Contract.GetSourceSymbolId(&_Eoconfig.CallOpts, source, symbol) +func (_EOConfig *EOConfigCallerSession) GetSourceSymbolId(source uint16, symbol uint16) (string, error) { + return _EOConfig.Contract.GetSourceSymbolId(&_EOConfig.CallOpts, source, symbol) } // GetSourceSymbols is a free data retrieval call binding the contract method 0x3ae23dfb. // // Solidity: function getSourceSymbols(uint16 id) view returns(uint16[]) -func (_Eoconfig *EoconfigCaller) GetSourceSymbols(opts *bind.CallOpts, id uint16) ([]uint16, error) { +func (_EOConfig *EOConfigCaller) GetSourceSymbols(opts *bind.CallOpts, id uint16) ([]uint16, error) { var out []interface{} - err := _Eoconfig.contract.Call(opts, &out, "getSourceSymbols", id) + err := _EOConfig.contract.Call(opts, &out, "getSourceSymbols", id) if err != nil { return *new([]uint16), err @@ -377,23 +355,23 @@ func (_Eoconfig *EoconfigCaller) GetSourceSymbols(opts *bind.CallOpts, id uint16 // GetSourceSymbols is a free data retrieval call binding the contract method 0x3ae23dfb. // // Solidity: function getSourceSymbols(uint16 id) view returns(uint16[]) -func (_Eoconfig *EoconfigSession) GetSourceSymbols(id uint16) ([]uint16, error) { - return _Eoconfig.Contract.GetSourceSymbols(&_Eoconfig.CallOpts, id) +func (_EOConfig *EOConfigSession) GetSourceSymbols(id uint16) ([]uint16, error) { + return _EOConfig.Contract.GetSourceSymbols(&_EOConfig.CallOpts, id) } // GetSourceSymbols is a free data retrieval call binding the contract method 0x3ae23dfb. // // Solidity: function getSourceSymbols(uint16 id) view returns(uint16[]) -func (_Eoconfig *EoconfigCallerSession) GetSourceSymbols(id uint16) ([]uint16, error) { - return _Eoconfig.Contract.GetSourceSymbols(&_Eoconfig.CallOpts, id) +func (_EOConfig *EOConfigCallerSession) GetSourceSymbols(id uint16) ([]uint16, error) { + return _EOConfig.Contract.GetSourceSymbols(&_EOConfig.CallOpts, id) } // GetSymbolSources is a free data retrieval call binding the contract method 0x14832bc8. // // Solidity: function getSymbolSources(uint16 id) view returns(uint16[]) -func (_Eoconfig *EoconfigCaller) GetSymbolSources(opts *bind.CallOpts, id uint16) ([]uint16, error) { +func (_EOConfig *EOConfigCaller) GetSymbolSources(opts *bind.CallOpts, id uint16) ([]uint16, error) { var out []interface{} - err := _Eoconfig.contract.Call(opts, &out, "getSymbolSources", id) + err := _EOConfig.contract.Call(opts, &out, "getSymbolSources", id) if err != nil { return *new([]uint16), err @@ -408,23 +386,23 @@ func (_Eoconfig *EoconfigCaller) GetSymbolSources(opts *bind.CallOpts, id uint16 // GetSymbolSources is a free data retrieval call binding the contract method 0x14832bc8. // // Solidity: function getSymbolSources(uint16 id) view returns(uint16[]) -func (_Eoconfig *EoconfigSession) GetSymbolSources(id uint16) ([]uint16, error) { - return _Eoconfig.Contract.GetSymbolSources(&_Eoconfig.CallOpts, id) +func (_EOConfig *EOConfigSession) GetSymbolSources(id uint16) ([]uint16, error) { + return _EOConfig.Contract.GetSymbolSources(&_EOConfig.CallOpts, id) } // GetSymbolSources is a free data retrieval call binding the contract method 0x14832bc8. // // Solidity: function getSymbolSources(uint16 id) view returns(uint16[]) -func (_Eoconfig *EoconfigCallerSession) GetSymbolSources(id uint16) ([]uint16, error) { - return _Eoconfig.Contract.GetSymbolSources(&_Eoconfig.CallOpts, id) +func (_EOConfig *EOConfigCallerSession) GetSymbolSources(id uint16) ([]uint16, error) { + return _EOConfig.Contract.GetSymbolSources(&_EOConfig.CallOpts, id) } // IsIdAllowed is a free data retrieval call binding the contract method 0x04495eb1. // // Solidity: function isIdAllowed(bytes4 ) view returns(bool) -func (_Eoconfig *EoconfigCaller) IsIdAllowed(opts *bind.CallOpts, arg0 [4]byte) (bool, error) { +func (_EOConfig *EOConfigCaller) IsIdAllowed(opts *bind.CallOpts, arg0 [4]byte) (bool, error) { var out []interface{} - err := _Eoconfig.contract.Call(opts, &out, "isIdAllowed", arg0) + err := _EOConfig.contract.Call(opts, &out, "isIdAllowed", arg0) if err != nil { return *new(bool), err @@ -439,23 +417,23 @@ func (_Eoconfig *EoconfigCaller) IsIdAllowed(opts *bind.CallOpts, arg0 [4]byte) // IsIdAllowed is a free data retrieval call binding the contract method 0x04495eb1. // // Solidity: function isIdAllowed(bytes4 ) view returns(bool) -func (_Eoconfig *EoconfigSession) IsIdAllowed(arg0 [4]byte) (bool, error) { - return _Eoconfig.Contract.IsIdAllowed(&_Eoconfig.CallOpts, arg0) +func (_EOConfig *EOConfigSession) IsIdAllowed(arg0 [4]byte) (bool, error) { + return _EOConfig.Contract.IsIdAllowed(&_EOConfig.CallOpts, arg0) } // IsIdAllowed is a free data retrieval call binding the contract method 0x04495eb1. // // Solidity: function isIdAllowed(bytes4 ) view returns(bool) -func (_Eoconfig *EoconfigCallerSession) IsIdAllowed(arg0 [4]byte) (bool, error) { - return _Eoconfig.Contract.IsIdAllowed(&_Eoconfig.CallOpts, arg0) +func (_EOConfig *EOConfigCallerSession) IsIdAllowed(arg0 [4]byte) (bool, error) { + return _EOConfig.Contract.IsIdAllowed(&_EOConfig.CallOpts, arg0) } // OperatorToAlias is a free data retrieval call binding the contract method 0x92c94ab5. // // Solidity: function operatorToAlias(address ) view returns(address) -func (_Eoconfig *EoconfigCaller) OperatorToAlias(opts *bind.CallOpts, arg0 common.Address) (common.Address, error) { +func (_EOConfig *EOConfigCaller) OperatorToAlias(opts *bind.CallOpts, arg0 common.Address) (common.Address, error) { var out []interface{} - err := _Eoconfig.contract.Call(opts, &out, "operatorToAlias", arg0) + err := _EOConfig.contract.Call(opts, &out, "operatorToAlias", arg0) if err != nil { return *new(common.Address), err @@ -470,23 +448,23 @@ func (_Eoconfig *EoconfigCaller) OperatorToAlias(opts *bind.CallOpts, arg0 commo // OperatorToAlias is a free data retrieval call binding the contract method 0x92c94ab5. // // Solidity: function operatorToAlias(address ) view returns(address) -func (_Eoconfig *EoconfigSession) OperatorToAlias(arg0 common.Address) (common.Address, error) { - return _Eoconfig.Contract.OperatorToAlias(&_Eoconfig.CallOpts, arg0) +func (_EOConfig *EOConfigSession) OperatorToAlias(arg0 common.Address) (common.Address, error) { + return _EOConfig.Contract.OperatorToAlias(&_EOConfig.CallOpts, arg0) } // OperatorToAlias is a free data retrieval call binding the contract method 0x92c94ab5. // // Solidity: function operatorToAlias(address ) view returns(address) -func (_Eoconfig *EoconfigCallerSession) OperatorToAlias(arg0 common.Address) (common.Address, error) { - return _Eoconfig.Contract.OperatorToAlias(&_Eoconfig.CallOpts, arg0) +func (_EOConfig *EOConfigCallerSession) OperatorToAlias(arg0 common.Address) (common.Address, error) { + return _EOConfig.Contract.OperatorToAlias(&_EOConfig.CallOpts, arg0) } // OperatorToRegistrationData is a free data retrieval call binding the contract method 0x4a9910fa. // // Solidity: function operatorToRegistrationData(address ) view returns(bytes) -func (_Eoconfig *EoconfigCaller) OperatorToRegistrationData(opts *bind.CallOpts, arg0 common.Address) ([]byte, error) { +func (_EOConfig *EOConfigCaller) OperatorToRegistrationData(opts *bind.CallOpts, arg0 common.Address) ([]byte, error) { var out []interface{} - err := _Eoconfig.contract.Call(opts, &out, "operatorToRegistrationData", arg0) + err := _EOConfig.contract.Call(opts, &out, "operatorToRegistrationData", arg0) if err != nil { return *new([]byte), err @@ -501,23 +479,23 @@ func (_Eoconfig *EoconfigCaller) OperatorToRegistrationData(opts *bind.CallOpts, // OperatorToRegistrationData is a free data retrieval call binding the contract method 0x4a9910fa. // // Solidity: function operatorToRegistrationData(address ) view returns(bytes) -func (_Eoconfig *EoconfigSession) OperatorToRegistrationData(arg0 common.Address) ([]byte, error) { - return _Eoconfig.Contract.OperatorToRegistrationData(&_Eoconfig.CallOpts, arg0) +func (_EOConfig *EOConfigSession) OperatorToRegistrationData(arg0 common.Address) ([]byte, error) { + return _EOConfig.Contract.OperatorToRegistrationData(&_EOConfig.CallOpts, arg0) } // OperatorToRegistrationData is a free data retrieval call binding the contract method 0x4a9910fa. // // Solidity: function operatorToRegistrationData(address ) view returns(bytes) -func (_Eoconfig *EoconfigCallerSession) OperatorToRegistrationData(arg0 common.Address) ([]byte, error) { - return _Eoconfig.Contract.OperatorToRegistrationData(&_Eoconfig.CallOpts, arg0) +func (_EOConfig *EOConfigCallerSession) OperatorToRegistrationData(arg0 common.Address) ([]byte, error) { + return _EOConfig.Contract.OperatorToRegistrationData(&_EOConfig.CallOpts, arg0) } // Owner is a free data retrieval call binding the contract method 0x8da5cb5b. // // Solidity: function owner() view returns(address) -func (_Eoconfig *EoconfigCaller) Owner(opts *bind.CallOpts) (common.Address, error) { +func (_EOConfig *EOConfigCaller) Owner(opts *bind.CallOpts) (common.Address, error) { var out []interface{} - err := _Eoconfig.contract.Call(opts, &out, "owner") + err := _EOConfig.contract.Call(opts, &out, "owner") if err != nil { return *new(common.Address), err @@ -532,23 +510,23 @@ func (_Eoconfig *EoconfigCaller) Owner(opts *bind.CallOpts) (common.Address, err // Owner is a free data retrieval call binding the contract method 0x8da5cb5b. // // Solidity: function owner() view returns(address) -func (_Eoconfig *EoconfigSession) Owner() (common.Address, error) { - return _Eoconfig.Contract.Owner(&_Eoconfig.CallOpts) +func (_EOConfig *EOConfigSession) Owner() (common.Address, error) { + return _EOConfig.Contract.Owner(&_EOConfig.CallOpts) } // Owner is a free data retrieval call binding the contract method 0x8da5cb5b. // // Solidity: function owner() view returns(address) -func (_Eoconfig *EoconfigCallerSession) Owner() (common.Address, error) { - return _Eoconfig.Contract.Owner(&_Eoconfig.CallOpts) +func (_EOConfig *EOConfigCallerSession) Owner() (common.Address, error) { + return _EOConfig.Contract.Owner(&_EOConfig.CallOpts) } // PackPair is a free data retrieval call binding the contract method 0xc18cb7b0. // // Solidity: function packPair(uint16 source, uint16 symbol) pure returns(bytes4 id) -func (_Eoconfig *EoconfigCaller) PackPair(opts *bind.CallOpts, source uint16, symbol uint16) ([4]byte, error) { +func (_EOConfig *EOConfigCaller) PackPair(opts *bind.CallOpts, source uint16, symbol uint16) ([4]byte, error) { var out []interface{} - err := _Eoconfig.contract.Call(opts, &out, "packPair", source, symbol) + err := _EOConfig.contract.Call(opts, &out, "packPair", source, symbol) if err != nil { return *new([4]byte), err @@ -563,26 +541,26 @@ func (_Eoconfig *EoconfigCaller) PackPair(opts *bind.CallOpts, source uint16, sy // PackPair is a free data retrieval call binding the contract method 0xc18cb7b0. // // Solidity: function packPair(uint16 source, uint16 symbol) pure returns(bytes4 id) -func (_Eoconfig *EoconfigSession) PackPair(source uint16, symbol uint16) ([4]byte, error) { - return _Eoconfig.Contract.PackPair(&_Eoconfig.CallOpts, source, symbol) +func (_EOConfig *EOConfigSession) PackPair(source uint16, symbol uint16) ([4]byte, error) { + return _EOConfig.Contract.PackPair(&_EOConfig.CallOpts, source, symbol) } // PackPair is a free data retrieval call binding the contract method 0xc18cb7b0. // // Solidity: function packPair(uint16 source, uint16 symbol) pure returns(bytes4 id) -func (_Eoconfig *EoconfigCallerSession) PackPair(source uint16, symbol uint16) ([4]byte, error) { - return _Eoconfig.Contract.PackPair(&_Eoconfig.CallOpts, source, symbol) +func (_EOConfig *EOConfigCallerSession) PackPair(source uint16, symbol uint16) ([4]byte, error) { + return _EOConfig.Contract.PackPair(&_EOConfig.CallOpts, source, symbol) } // SourceById is a free data retrieval call binding the contract method 0xbf81551e. // // Solidity: function sourceById(uint16 ) view returns(bytes24 name, uint16 id) -func (_Eoconfig *EoconfigCaller) SourceById(opts *bind.CallOpts, arg0 uint16) (struct { +func (_EOConfig *EOConfigCaller) SourceById(opts *bind.CallOpts, arg0 uint16) (struct { Name [24]byte Id uint16 }, error) { var out []interface{} - err := _Eoconfig.contract.Call(opts, &out, "sourceById", arg0) + err := _EOConfig.contract.Call(opts, &out, "sourceById", arg0) outstruct := new(struct { Name [24]byte @@ -602,29 +580,29 @@ func (_Eoconfig *EoconfigCaller) SourceById(opts *bind.CallOpts, arg0 uint16) (s // SourceById is a free data retrieval call binding the contract method 0xbf81551e. // // Solidity: function sourceById(uint16 ) view returns(bytes24 name, uint16 id) -func (_Eoconfig *EoconfigSession) SourceById(arg0 uint16) (struct { +func (_EOConfig *EOConfigSession) SourceById(arg0 uint16) (struct { Name [24]byte Id uint16 }, error) { - return _Eoconfig.Contract.SourceById(&_Eoconfig.CallOpts, arg0) + return _EOConfig.Contract.SourceById(&_EOConfig.CallOpts, arg0) } // SourceById is a free data retrieval call binding the contract method 0xbf81551e. // // Solidity: function sourceById(uint16 ) view returns(bytes24 name, uint16 id) -func (_Eoconfig *EoconfigCallerSession) SourceById(arg0 uint16) (struct { +func (_EOConfig *EOConfigCallerSession) SourceById(arg0 uint16) (struct { Name [24]byte Id uint16 }, error) { - return _Eoconfig.Contract.SourceById(&_Eoconfig.CallOpts, arg0) + return _EOConfig.Contract.SourceById(&_EOConfig.CallOpts, arg0) } // SourceId is a free data retrieval call binding the contract method 0x88dea97d. // // Solidity: function sourceId(bytes24 ) view returns(uint16) -func (_Eoconfig *EoconfigCaller) SourceId(opts *bind.CallOpts, arg0 [24]byte) (uint16, error) { +func (_EOConfig *EOConfigCaller) SourceId(opts *bind.CallOpts, arg0 [24]byte) (uint16, error) { var out []interface{} - err := _Eoconfig.contract.Call(opts, &out, "sourceId", arg0) + err := _EOConfig.contract.Call(opts, &out, "sourceId", arg0) if err != nil { return *new(uint16), err @@ -639,23 +617,23 @@ func (_Eoconfig *EoconfigCaller) SourceId(opts *bind.CallOpts, arg0 [24]byte) (u // SourceId is a free data retrieval call binding the contract method 0x88dea97d. // // Solidity: function sourceId(bytes24 ) view returns(uint16) -func (_Eoconfig *EoconfigSession) SourceId(arg0 [24]byte) (uint16, error) { - return _Eoconfig.Contract.SourceId(&_Eoconfig.CallOpts, arg0) +func (_EOConfig *EOConfigSession) SourceId(arg0 [24]byte) (uint16, error) { + return _EOConfig.Contract.SourceId(&_EOConfig.CallOpts, arg0) } // SourceId is a free data retrieval call binding the contract method 0x88dea97d. // // Solidity: function sourceId(bytes24 ) view returns(uint16) -func (_Eoconfig *EoconfigCallerSession) SourceId(arg0 [24]byte) (uint16, error) { - return _Eoconfig.Contract.SourceId(&_Eoconfig.CallOpts, arg0) +func (_EOConfig *EOConfigCallerSession) SourceId(arg0 [24]byte) (uint16, error) { + return _EOConfig.Contract.SourceId(&_EOConfig.CallOpts, arg0) } // SourceIds is a free data retrieval call binding the contract method 0x6d34c28b. // // Solidity: function sourceIds(uint256 ) view returns(uint16) -func (_Eoconfig *EoconfigCaller) SourceIds(opts *bind.CallOpts, arg0 *big.Int) (uint16, error) { +func (_EOConfig *EOConfigCaller) SourceIds(opts *bind.CallOpts, arg0 *big.Int) (uint16, error) { var out []interface{} - err := _Eoconfig.contract.Call(opts, &out, "sourceIds", arg0) + err := _EOConfig.contract.Call(opts, &out, "sourceIds", arg0) if err != nil { return *new(uint16), err @@ -670,23 +648,23 @@ func (_Eoconfig *EoconfigCaller) SourceIds(opts *bind.CallOpts, arg0 *big.Int) ( // SourceIds is a free data retrieval call binding the contract method 0x6d34c28b. // // Solidity: function sourceIds(uint256 ) view returns(uint16) -func (_Eoconfig *EoconfigSession) SourceIds(arg0 *big.Int) (uint16, error) { - return _Eoconfig.Contract.SourceIds(&_Eoconfig.CallOpts, arg0) +func (_EOConfig *EOConfigSession) SourceIds(arg0 *big.Int) (uint16, error) { + return _EOConfig.Contract.SourceIds(&_EOConfig.CallOpts, arg0) } // SourceIds is a free data retrieval call binding the contract method 0x6d34c28b. // // Solidity: function sourceIds(uint256 ) view returns(uint16) -func (_Eoconfig *EoconfigCallerSession) SourceIds(arg0 *big.Int) (uint16, error) { - return _Eoconfig.Contract.SourceIds(&_Eoconfig.CallOpts, arg0) +func (_EOConfig *EOConfigCallerSession) SourceIds(arg0 *big.Int) (uint16, error) { + return _EOConfig.Contract.SourceIds(&_EOConfig.CallOpts, arg0) } // SourceIdsLength is a free data retrieval call binding the contract method 0x009c03fb. // // Solidity: function sourceIdsLength() view returns(uint16) -func (_Eoconfig *EoconfigCaller) SourceIdsLength(opts *bind.CallOpts) (uint16, error) { +func (_EOConfig *EOConfigCaller) SourceIdsLength(opts *bind.CallOpts) (uint16, error) { var out []interface{} - err := _Eoconfig.contract.Call(opts, &out, "sourceIdsLength") + err := _EOConfig.contract.Call(opts, &out, "sourceIdsLength") if err != nil { return *new(uint16), err @@ -701,23 +679,23 @@ func (_Eoconfig *EoconfigCaller) SourceIdsLength(opts *bind.CallOpts) (uint16, e // SourceIdsLength is a free data retrieval call binding the contract method 0x009c03fb. // // Solidity: function sourceIdsLength() view returns(uint16) -func (_Eoconfig *EoconfigSession) SourceIdsLength() (uint16, error) { - return _Eoconfig.Contract.SourceIdsLength(&_Eoconfig.CallOpts) +func (_EOConfig *EOConfigSession) SourceIdsLength() (uint16, error) { + return _EOConfig.Contract.SourceIdsLength(&_EOConfig.CallOpts) } // SourceIdsLength is a free data retrieval call binding the contract method 0x009c03fb. // // Solidity: function sourceIdsLength() view returns(uint16) -func (_Eoconfig *EoconfigCallerSession) SourceIdsLength() (uint16, error) { - return _Eoconfig.Contract.SourceIdsLength(&_Eoconfig.CallOpts) +func (_EOConfig *EOConfigCallerSession) SourceIdsLength() (uint16, error) { + return _EOConfig.Contract.SourceIdsLength(&_EOConfig.CallOpts) } // SourceSymbolOverrides is a free data retrieval call binding the contract method 0x98332e91. // // Solidity: function sourceSymbolOverrides(uint16 , uint16 ) view returns(string) -func (_Eoconfig *EoconfigCaller) SourceSymbolOverrides(opts *bind.CallOpts, arg0 uint16, arg1 uint16) (string, error) { +func (_EOConfig *EOConfigCaller) SourceSymbolOverrides(opts *bind.CallOpts, arg0 uint16, arg1 uint16) (string, error) { var out []interface{} - err := _Eoconfig.contract.Call(opts, &out, "sourceSymbolOverrides", arg0, arg1) + err := _EOConfig.contract.Call(opts, &out, "sourceSymbolOverrides", arg0, arg1) if err != nil { return *new(string), err @@ -732,26 +710,26 @@ func (_Eoconfig *EoconfigCaller) SourceSymbolOverrides(opts *bind.CallOpts, arg0 // SourceSymbolOverrides is a free data retrieval call binding the contract method 0x98332e91. // // Solidity: function sourceSymbolOverrides(uint16 , uint16 ) view returns(string) -func (_Eoconfig *EoconfigSession) SourceSymbolOverrides(arg0 uint16, arg1 uint16) (string, error) { - return _Eoconfig.Contract.SourceSymbolOverrides(&_Eoconfig.CallOpts, arg0, arg1) +func (_EOConfig *EOConfigSession) SourceSymbolOverrides(arg0 uint16, arg1 uint16) (string, error) { + return _EOConfig.Contract.SourceSymbolOverrides(&_EOConfig.CallOpts, arg0, arg1) } // SourceSymbolOverrides is a free data retrieval call binding the contract method 0x98332e91. // // Solidity: function sourceSymbolOverrides(uint16 , uint16 ) view returns(string) -func (_Eoconfig *EoconfigCallerSession) SourceSymbolOverrides(arg0 uint16, arg1 uint16) (string, error) { - return _Eoconfig.Contract.SourceSymbolOverrides(&_Eoconfig.CallOpts, arg0, arg1) +func (_EOConfig *EOConfigCallerSession) SourceSymbolOverrides(arg0 uint16, arg1 uint16) (string, error) { + return _EOConfig.Contract.SourceSymbolOverrides(&_EOConfig.CallOpts, arg0, arg1) } // SymbolById is a free data retrieval call binding the contract method 0xa0a79a7c. // // Solidity: function symbolById(uint16 ) view returns(bytes8 name, uint16 id) -func (_Eoconfig *EoconfigCaller) SymbolById(opts *bind.CallOpts, arg0 uint16) (struct { +func (_EOConfig *EOConfigCaller) SymbolById(opts *bind.CallOpts, arg0 uint16) (struct { Name [8]byte Id uint16 }, error) { var out []interface{} - err := _Eoconfig.contract.Call(opts, &out, "symbolById", arg0) + err := _EOConfig.contract.Call(opts, &out, "symbolById", arg0) outstruct := new(struct { Name [8]byte @@ -771,29 +749,29 @@ func (_Eoconfig *EoconfigCaller) SymbolById(opts *bind.CallOpts, arg0 uint16) (s // SymbolById is a free data retrieval call binding the contract method 0xa0a79a7c. // // Solidity: function symbolById(uint16 ) view returns(bytes8 name, uint16 id) -func (_Eoconfig *EoconfigSession) SymbolById(arg0 uint16) (struct { +func (_EOConfig *EOConfigSession) SymbolById(arg0 uint16) (struct { Name [8]byte Id uint16 }, error) { - return _Eoconfig.Contract.SymbolById(&_Eoconfig.CallOpts, arg0) + return _EOConfig.Contract.SymbolById(&_EOConfig.CallOpts, arg0) } // SymbolById is a free data retrieval call binding the contract method 0xa0a79a7c. // // Solidity: function symbolById(uint16 ) view returns(bytes8 name, uint16 id) -func (_Eoconfig *EoconfigCallerSession) SymbolById(arg0 uint16) (struct { +func (_EOConfig *EOConfigCallerSession) SymbolById(arg0 uint16) (struct { Name [8]byte Id uint16 }, error) { - return _Eoconfig.Contract.SymbolById(&_Eoconfig.CallOpts, arg0) + return _EOConfig.Contract.SymbolById(&_EOConfig.CallOpts, arg0) } // SymbolId is a free data retrieval call binding the contract method 0x2d75981c. // // Solidity: function symbolId(bytes8 ) view returns(uint16) -func (_Eoconfig *EoconfigCaller) SymbolId(opts *bind.CallOpts, arg0 [8]byte) (uint16, error) { +func (_EOConfig *EOConfigCaller) SymbolId(opts *bind.CallOpts, arg0 [8]byte) (uint16, error) { var out []interface{} - err := _Eoconfig.contract.Call(opts, &out, "symbolId", arg0) + err := _EOConfig.contract.Call(opts, &out, "symbolId", arg0) if err != nil { return *new(uint16), err @@ -808,23 +786,23 @@ func (_Eoconfig *EoconfigCaller) SymbolId(opts *bind.CallOpts, arg0 [8]byte) (ui // SymbolId is a free data retrieval call binding the contract method 0x2d75981c. // // Solidity: function symbolId(bytes8 ) view returns(uint16) -func (_Eoconfig *EoconfigSession) SymbolId(arg0 [8]byte) (uint16, error) { - return _Eoconfig.Contract.SymbolId(&_Eoconfig.CallOpts, arg0) +func (_EOConfig *EOConfigSession) SymbolId(arg0 [8]byte) (uint16, error) { + return _EOConfig.Contract.SymbolId(&_EOConfig.CallOpts, arg0) } // SymbolId is a free data retrieval call binding the contract method 0x2d75981c. // // Solidity: function symbolId(bytes8 ) view returns(uint16) -func (_Eoconfig *EoconfigCallerSession) SymbolId(arg0 [8]byte) (uint16, error) { - return _Eoconfig.Contract.SymbolId(&_Eoconfig.CallOpts, arg0) +func (_EOConfig *EOConfigCallerSession) SymbolId(arg0 [8]byte) (uint16, error) { + return _EOConfig.Contract.SymbolId(&_EOConfig.CallOpts, arg0) } // SymbolIds is a free data retrieval call binding the contract method 0xedc24d69. // // Solidity: function symbolIds(uint256 ) view returns(uint16) -func (_Eoconfig *EoconfigCaller) SymbolIds(opts *bind.CallOpts, arg0 *big.Int) (uint16, error) { +func (_EOConfig *EOConfigCaller) SymbolIds(opts *bind.CallOpts, arg0 *big.Int) (uint16, error) { var out []interface{} - err := _Eoconfig.contract.Call(opts, &out, "symbolIds", arg0) + err := _EOConfig.contract.Call(opts, &out, "symbolIds", arg0) if err != nil { return *new(uint16), err @@ -839,23 +817,23 @@ func (_Eoconfig *EoconfigCaller) SymbolIds(opts *bind.CallOpts, arg0 *big.Int) ( // SymbolIds is a free data retrieval call binding the contract method 0xedc24d69. // // Solidity: function symbolIds(uint256 ) view returns(uint16) -func (_Eoconfig *EoconfigSession) SymbolIds(arg0 *big.Int) (uint16, error) { - return _Eoconfig.Contract.SymbolIds(&_Eoconfig.CallOpts, arg0) +func (_EOConfig *EOConfigSession) SymbolIds(arg0 *big.Int) (uint16, error) { + return _EOConfig.Contract.SymbolIds(&_EOConfig.CallOpts, arg0) } // SymbolIds is a free data retrieval call binding the contract method 0xedc24d69. // // Solidity: function symbolIds(uint256 ) view returns(uint16) -func (_Eoconfig *EoconfigCallerSession) SymbolIds(arg0 *big.Int) (uint16, error) { - return _Eoconfig.Contract.SymbolIds(&_Eoconfig.CallOpts, arg0) +func (_EOConfig *EOConfigCallerSession) SymbolIds(arg0 *big.Int) (uint16, error) { + return _EOConfig.Contract.SymbolIds(&_EOConfig.CallOpts, arg0) } // SymbolIdsLength is a free data retrieval call binding the contract method 0x20a332a4. // // Solidity: function symbolIdsLength() view returns(uint16) -func (_Eoconfig *EoconfigCaller) SymbolIdsLength(opts *bind.CallOpts) (uint16, error) { +func (_EOConfig *EOConfigCaller) SymbolIdsLength(opts *bind.CallOpts) (uint16, error) { var out []interface{} - err := _Eoconfig.contract.Call(opts, &out, "symbolIdsLength") + err := _EOConfig.contract.Call(opts, &out, "symbolIdsLength") if err != nil { return *new(uint16), err @@ -870,503 +848,503 @@ func (_Eoconfig *EoconfigCaller) SymbolIdsLength(opts *bind.CallOpts) (uint16, e // SymbolIdsLength is a free data retrieval call binding the contract method 0x20a332a4. // // Solidity: function symbolIdsLength() view returns(uint16) -func (_Eoconfig *EoconfigSession) SymbolIdsLength() (uint16, error) { - return _Eoconfig.Contract.SymbolIdsLength(&_Eoconfig.CallOpts) +func (_EOConfig *EOConfigSession) SymbolIdsLength() (uint16, error) { + return _EOConfig.Contract.SymbolIdsLength(&_EOConfig.CallOpts) } // SymbolIdsLength is a free data retrieval call binding the contract method 0x20a332a4. // // Solidity: function symbolIdsLength() view returns(uint16) -func (_Eoconfig *EoconfigCallerSession) SymbolIdsLength() (uint16, error) { - return _Eoconfig.Contract.SymbolIdsLength(&_Eoconfig.CallOpts) +func (_EOConfig *EOConfigCallerSession) SymbolIdsLength() (uint16, error) { + return _EOConfig.Contract.SymbolIdsLength(&_EOConfig.CallOpts) } // AddSource is a paid mutator transaction binding the contract method 0x13996105. // // Solidity: function addSource(bytes24 name) returns() -func (_Eoconfig *EoconfigTransactor) AddSource(opts *bind.TransactOpts, name [24]byte) (*types.Transaction, error) { - return _Eoconfig.contract.Transact(opts, "addSource", name) +func (_EOConfig *EOConfigTransactor) AddSource(opts *bind.TransactOpts, name [24]byte) (*types.Transaction, error) { + return _EOConfig.contract.Transact(opts, "addSource", name) } // AddSource is a paid mutator transaction binding the contract method 0x13996105. // // Solidity: function addSource(bytes24 name) returns() -func (_Eoconfig *EoconfigSession) AddSource(name [24]byte) (*types.Transaction, error) { - return _Eoconfig.Contract.AddSource(&_Eoconfig.TransactOpts, name) +func (_EOConfig *EOConfigSession) AddSource(name [24]byte) (*types.Transaction, error) { + return _EOConfig.Contract.AddSource(&_EOConfig.TransactOpts, name) } // AddSource is a paid mutator transaction binding the contract method 0x13996105. // // Solidity: function addSource(bytes24 name) returns() -func (_Eoconfig *EoconfigTransactorSession) AddSource(name [24]byte) (*types.Transaction, error) { - return _Eoconfig.Contract.AddSource(&_Eoconfig.TransactOpts, name) +func (_EOConfig *EOConfigTransactorSession) AddSource(name [24]byte) (*types.Transaction, error) { + return _EOConfig.Contract.AddSource(&_EOConfig.TransactOpts, name) } // AddSources is a paid mutator transaction binding the contract method 0xb2ee3c95. // // Solidity: function addSources(bytes24[] names) returns() -func (_Eoconfig *EoconfigTransactor) AddSources(opts *bind.TransactOpts, names [][24]byte) (*types.Transaction, error) { - return _Eoconfig.contract.Transact(opts, "addSources", names) +func (_EOConfig *EOConfigTransactor) AddSources(opts *bind.TransactOpts, names [][24]byte) (*types.Transaction, error) { + return _EOConfig.contract.Transact(opts, "addSources", names) } // AddSources is a paid mutator transaction binding the contract method 0xb2ee3c95. // // Solidity: function addSources(bytes24[] names) returns() -func (_Eoconfig *EoconfigSession) AddSources(names [][24]byte) (*types.Transaction, error) { - return _Eoconfig.Contract.AddSources(&_Eoconfig.TransactOpts, names) +func (_EOConfig *EOConfigSession) AddSources(names [][24]byte) (*types.Transaction, error) { + return _EOConfig.Contract.AddSources(&_EOConfig.TransactOpts, names) } // AddSources is a paid mutator transaction binding the contract method 0xb2ee3c95. // // Solidity: function addSources(bytes24[] names) returns() -func (_Eoconfig *EoconfigTransactorSession) AddSources(names [][24]byte) (*types.Transaction, error) { - return _Eoconfig.Contract.AddSources(&_Eoconfig.TransactOpts, names) +func (_EOConfig *EOConfigTransactorSession) AddSources(names [][24]byte) (*types.Transaction, error) { + return _EOConfig.Contract.AddSources(&_EOConfig.TransactOpts, names) } // AddSymbol is a paid mutator transaction binding the contract method 0x08059117. // // Solidity: function addSymbol(bytes8 name) returns() -func (_Eoconfig *EoconfigTransactor) AddSymbol(opts *bind.TransactOpts, name [8]byte) (*types.Transaction, error) { - return _Eoconfig.contract.Transact(opts, "addSymbol", name) +func (_EOConfig *EOConfigTransactor) AddSymbol(opts *bind.TransactOpts, name [8]byte) (*types.Transaction, error) { + return _EOConfig.contract.Transact(opts, "addSymbol", name) } // AddSymbol is a paid mutator transaction binding the contract method 0x08059117. // // Solidity: function addSymbol(bytes8 name) returns() -func (_Eoconfig *EoconfigSession) AddSymbol(name [8]byte) (*types.Transaction, error) { - return _Eoconfig.Contract.AddSymbol(&_Eoconfig.TransactOpts, name) +func (_EOConfig *EOConfigSession) AddSymbol(name [8]byte) (*types.Transaction, error) { + return _EOConfig.Contract.AddSymbol(&_EOConfig.TransactOpts, name) } // AddSymbol is a paid mutator transaction binding the contract method 0x08059117. // // Solidity: function addSymbol(bytes8 name) returns() -func (_Eoconfig *EoconfigTransactorSession) AddSymbol(name [8]byte) (*types.Transaction, error) { - return _Eoconfig.Contract.AddSymbol(&_Eoconfig.TransactOpts, name) +func (_EOConfig *EOConfigTransactorSession) AddSymbol(name [8]byte) (*types.Transaction, error) { + return _EOConfig.Contract.AddSymbol(&_EOConfig.TransactOpts, name) } // AddSymbols is a paid mutator transaction binding the contract method 0xba868392. // // Solidity: function addSymbols(bytes8[] names) returns() -func (_Eoconfig *EoconfigTransactor) AddSymbols(opts *bind.TransactOpts, names [][8]byte) (*types.Transaction, error) { - return _Eoconfig.contract.Transact(opts, "addSymbols", names) +func (_EOConfig *EOConfigTransactor) AddSymbols(opts *bind.TransactOpts, names [][8]byte) (*types.Transaction, error) { + return _EOConfig.contract.Transact(opts, "addSymbols", names) } // AddSymbols is a paid mutator transaction binding the contract method 0xba868392. // // Solidity: function addSymbols(bytes8[] names) returns() -func (_Eoconfig *EoconfigSession) AddSymbols(names [][8]byte) (*types.Transaction, error) { - return _Eoconfig.Contract.AddSymbols(&_Eoconfig.TransactOpts, names) +func (_EOConfig *EOConfigSession) AddSymbols(names [][8]byte) (*types.Transaction, error) { + return _EOConfig.Contract.AddSymbols(&_EOConfig.TransactOpts, names) } // AddSymbols is a paid mutator transaction binding the contract method 0xba868392. // // Solidity: function addSymbols(bytes8[] names) returns() -func (_Eoconfig *EoconfigTransactorSession) AddSymbols(names [][8]byte) (*types.Transaction, error) { - return _Eoconfig.Contract.AddSymbols(&_Eoconfig.TransactOpts, names) +func (_EOConfig *EOConfigTransactorSession) AddSymbols(names [][8]byte) (*types.Transaction, error) { + return _EOConfig.Contract.AddSymbols(&_EOConfig.TransactOpts, names) } // AssignAlias is a paid mutator transaction binding the contract method 0x2e0ec10c. // // Solidity: function assignAlias(address operator, address operatorAlias) returns() -func (_Eoconfig *EoconfigTransactor) AssignAlias(opts *bind.TransactOpts, operator common.Address, operatorAlias common.Address) (*types.Transaction, error) { - return _Eoconfig.contract.Transact(opts, "assignAlias", operator, operatorAlias) +func (_EOConfig *EOConfigTransactor) AssignAlias(opts *bind.TransactOpts, operator common.Address, operatorAlias common.Address) (*types.Transaction, error) { + return _EOConfig.contract.Transact(opts, "assignAlias", operator, operatorAlias) } // AssignAlias is a paid mutator transaction binding the contract method 0x2e0ec10c. // // Solidity: function assignAlias(address operator, address operatorAlias) returns() -func (_Eoconfig *EoconfigSession) AssignAlias(operator common.Address, operatorAlias common.Address) (*types.Transaction, error) { - return _Eoconfig.Contract.AssignAlias(&_Eoconfig.TransactOpts, operator, operatorAlias) +func (_EOConfig *EOConfigSession) AssignAlias(operator common.Address, operatorAlias common.Address) (*types.Transaction, error) { + return _EOConfig.Contract.AssignAlias(&_EOConfig.TransactOpts, operator, operatorAlias) } // AssignAlias is a paid mutator transaction binding the contract method 0x2e0ec10c. // // Solidity: function assignAlias(address operator, address operatorAlias) returns() -func (_Eoconfig *EoconfigTransactorSession) AssignAlias(operator common.Address, operatorAlias common.Address) (*types.Transaction, error) { - return _Eoconfig.Contract.AssignAlias(&_Eoconfig.TransactOpts, operator, operatorAlias) +func (_EOConfig *EOConfigTransactorSession) AssignAlias(operator common.Address, operatorAlias common.Address) (*types.Transaction, error) { + return _EOConfig.Contract.AssignAlias(&_EOConfig.TransactOpts, operator, operatorAlias) } // ChangeAlias is a paid mutator transaction binding the contract method 0x5c7c8b9a. // // Solidity: function changeAlias(address operator, address newAlias) returns() -func (_Eoconfig *EoconfigTransactor) ChangeAlias(opts *bind.TransactOpts, operator common.Address, newAlias common.Address) (*types.Transaction, error) { - return _Eoconfig.contract.Transact(opts, "changeAlias", operator, newAlias) +func (_EOConfig *EOConfigTransactor) ChangeAlias(opts *bind.TransactOpts, operator common.Address, newAlias common.Address) (*types.Transaction, error) { + return _EOConfig.contract.Transact(opts, "changeAlias", operator, newAlias) } // ChangeAlias is a paid mutator transaction binding the contract method 0x5c7c8b9a. // // Solidity: function changeAlias(address operator, address newAlias) returns() -func (_Eoconfig *EoconfigSession) ChangeAlias(operator common.Address, newAlias common.Address) (*types.Transaction, error) { - return _Eoconfig.Contract.ChangeAlias(&_Eoconfig.TransactOpts, operator, newAlias) +func (_EOConfig *EOConfigSession) ChangeAlias(operator common.Address, newAlias common.Address) (*types.Transaction, error) { + return _EOConfig.Contract.ChangeAlias(&_EOConfig.TransactOpts, operator, newAlias) } // ChangeAlias is a paid mutator transaction binding the contract method 0x5c7c8b9a. // // Solidity: function changeAlias(address operator, address newAlias) returns() -func (_Eoconfig *EoconfigTransactorSession) ChangeAlias(operator common.Address, newAlias common.Address) (*types.Transaction, error) { - return _Eoconfig.Contract.ChangeAlias(&_Eoconfig.TransactOpts, operator, newAlias) +func (_EOConfig *EOConfigTransactorSession) ChangeAlias(operator common.Address, newAlias common.Address) (*types.Transaction, error) { + return _EOConfig.Contract.ChangeAlias(&_EOConfig.TransactOpts, operator, newAlias) } // DeclareAlias is a paid mutator transaction binding the contract method 0xf405566d. // // Solidity: function declareAlias(address operatorAlias) returns() -func (_Eoconfig *EoconfigTransactor) DeclareAlias(opts *bind.TransactOpts, operatorAlias common.Address) (*types.Transaction, error) { - return _Eoconfig.contract.Transact(opts, "declareAlias", operatorAlias) +func (_EOConfig *EOConfigTransactor) DeclareAlias(opts *bind.TransactOpts, operatorAlias common.Address) (*types.Transaction, error) { + return _EOConfig.contract.Transact(opts, "declareAlias", operatorAlias) } // DeclareAlias is a paid mutator transaction binding the contract method 0xf405566d. // // Solidity: function declareAlias(address operatorAlias) returns() -func (_Eoconfig *EoconfigSession) DeclareAlias(operatorAlias common.Address) (*types.Transaction, error) { - return _Eoconfig.Contract.DeclareAlias(&_Eoconfig.TransactOpts, operatorAlias) +func (_EOConfig *EOConfigSession) DeclareAlias(operatorAlias common.Address) (*types.Transaction, error) { + return _EOConfig.Contract.DeclareAlias(&_EOConfig.TransactOpts, operatorAlias) } // DeclareAlias is a paid mutator transaction binding the contract method 0xf405566d. // // Solidity: function declareAlias(address operatorAlias) returns() -func (_Eoconfig *EoconfigTransactorSession) DeclareAlias(operatorAlias common.Address) (*types.Transaction, error) { - return _Eoconfig.Contract.DeclareAlias(&_Eoconfig.TransactOpts, operatorAlias) +func (_EOConfig *EOConfigTransactorSession) DeclareAlias(operatorAlias common.Address) (*types.Transaction, error) { + return _EOConfig.Contract.DeclareAlias(&_EOConfig.TransactOpts, operatorAlias) } // Initialize is a paid mutator transaction binding the contract method 0x8129fc1c. // // Solidity: function initialize() returns() -func (_Eoconfig *EoconfigTransactor) Initialize(opts *bind.TransactOpts) (*types.Transaction, error) { - return _Eoconfig.contract.Transact(opts, "initialize") +func (_EOConfig *EOConfigTransactor) Initialize(opts *bind.TransactOpts) (*types.Transaction, error) { + return _EOConfig.contract.Transact(opts, "initialize") } // Initialize is a paid mutator transaction binding the contract method 0x8129fc1c. // // Solidity: function initialize() returns() -func (_Eoconfig *EoconfigSession) Initialize() (*types.Transaction, error) { - return _Eoconfig.Contract.Initialize(&_Eoconfig.TransactOpts) +func (_EOConfig *EOConfigSession) Initialize() (*types.Transaction, error) { + return _EOConfig.Contract.Initialize(&_EOConfig.TransactOpts) } // Initialize is a paid mutator transaction binding the contract method 0x8129fc1c. // // Solidity: function initialize() returns() -func (_Eoconfig *EoconfigTransactorSession) Initialize() (*types.Transaction, error) { - return _Eoconfig.Contract.Initialize(&_Eoconfig.TransactOpts) +func (_EOConfig *EOConfigTransactorSession) Initialize() (*types.Transaction, error) { + return _EOConfig.Contract.Initialize(&_EOConfig.TransactOpts) } // Notify is a paid mutator transaction binding the contract method 0x899f5898. // // Solidity: function notify() returns() -func (_Eoconfig *EoconfigTransactor) Notify(opts *bind.TransactOpts) (*types.Transaction, error) { - return _Eoconfig.contract.Transact(opts, "notify") +func (_EOConfig *EOConfigTransactor) Notify(opts *bind.TransactOpts) (*types.Transaction, error) { + return _EOConfig.contract.Transact(opts, "notify") } // Notify is a paid mutator transaction binding the contract method 0x899f5898. // // Solidity: function notify() returns() -func (_Eoconfig *EoconfigSession) Notify() (*types.Transaction, error) { - return _Eoconfig.Contract.Notify(&_Eoconfig.TransactOpts) +func (_EOConfig *EOConfigSession) Notify() (*types.Transaction, error) { + return _EOConfig.Contract.Notify(&_EOConfig.TransactOpts) } // Notify is a paid mutator transaction binding the contract method 0x899f5898. // // Solidity: function notify() returns() -func (_Eoconfig *EoconfigTransactorSession) Notify() (*types.Transaction, error) { - return _Eoconfig.Contract.Notify(&_Eoconfig.TransactOpts) +func (_EOConfig *EOConfigTransactorSession) Notify() (*types.Transaction, error) { + return _EOConfig.Contract.Notify(&_EOConfig.TransactOpts) } // OnStateReceive is a paid mutator transaction binding the contract method 0xeeb49945. // // Solidity: function onStateReceive(uint256 , address sender, bytes data) returns() -func (_Eoconfig *EoconfigTransactor) OnStateReceive(opts *bind.TransactOpts, arg0 *big.Int, sender common.Address, data []byte) (*types.Transaction, error) { - return _Eoconfig.contract.Transact(opts, "onStateReceive", arg0, sender, data) +func (_EOConfig *EOConfigTransactor) OnStateReceive(opts *bind.TransactOpts, arg0 *big.Int, sender common.Address, data []byte) (*types.Transaction, error) { + return _EOConfig.contract.Transact(opts, "onStateReceive", arg0, sender, data) } // OnStateReceive is a paid mutator transaction binding the contract method 0xeeb49945. // // Solidity: function onStateReceive(uint256 , address sender, bytes data) returns() -func (_Eoconfig *EoconfigSession) OnStateReceive(arg0 *big.Int, sender common.Address, data []byte) (*types.Transaction, error) { - return _Eoconfig.Contract.OnStateReceive(&_Eoconfig.TransactOpts, arg0, sender, data) +func (_EOConfig *EOConfigSession) OnStateReceive(arg0 *big.Int, sender common.Address, data []byte) (*types.Transaction, error) { + return _EOConfig.Contract.OnStateReceive(&_EOConfig.TransactOpts, arg0, sender, data) } // OnStateReceive is a paid mutator transaction binding the contract method 0xeeb49945. // // Solidity: function onStateReceive(uint256 , address sender, bytes data) returns() -func (_Eoconfig *EoconfigTransactorSession) OnStateReceive(arg0 *big.Int, sender common.Address, data []byte) (*types.Transaction, error) { - return _Eoconfig.Contract.OnStateReceive(&_Eoconfig.TransactOpts, arg0, sender, data) +func (_EOConfig *EOConfigTransactorSession) OnStateReceive(arg0 *big.Int, sender common.Address, data []byte) (*types.Transaction, error) { + return _EOConfig.Contract.OnStateReceive(&_EOConfig.TransactOpts, arg0, sender, data) } // RemoveSource is a paid mutator transaction binding the contract method 0x7672db8e. // // Solidity: function removeSource(uint16 id) returns() -func (_Eoconfig *EoconfigTransactor) RemoveSource(opts *bind.TransactOpts, id uint16) (*types.Transaction, error) { - return _Eoconfig.contract.Transact(opts, "removeSource", id) +func (_EOConfig *EOConfigTransactor) RemoveSource(opts *bind.TransactOpts, id uint16) (*types.Transaction, error) { + return _EOConfig.contract.Transact(opts, "removeSource", id) } // RemoveSource is a paid mutator transaction binding the contract method 0x7672db8e. // // Solidity: function removeSource(uint16 id) returns() -func (_Eoconfig *EoconfigSession) RemoveSource(id uint16) (*types.Transaction, error) { - return _Eoconfig.Contract.RemoveSource(&_Eoconfig.TransactOpts, id) +func (_EOConfig *EOConfigSession) RemoveSource(id uint16) (*types.Transaction, error) { + return _EOConfig.Contract.RemoveSource(&_EOConfig.TransactOpts, id) } // RemoveSource is a paid mutator transaction binding the contract method 0x7672db8e. // // Solidity: function removeSource(uint16 id) returns() -func (_Eoconfig *EoconfigTransactorSession) RemoveSource(id uint16) (*types.Transaction, error) { - return _Eoconfig.Contract.RemoveSource(&_Eoconfig.TransactOpts, id) +func (_EOConfig *EOConfigTransactorSession) RemoveSource(id uint16) (*types.Transaction, error) { + return _EOConfig.Contract.RemoveSource(&_EOConfig.TransactOpts, id) } // RemoveSymbol is a paid mutator transaction binding the contract method 0x5aa264e4. // // Solidity: function removeSymbol(uint16 id) returns() -func (_Eoconfig *EoconfigTransactor) RemoveSymbol(opts *bind.TransactOpts, id uint16) (*types.Transaction, error) { - return _Eoconfig.contract.Transact(opts, "removeSymbol", id) +func (_EOConfig *EOConfigTransactor) RemoveSymbol(opts *bind.TransactOpts, id uint16) (*types.Transaction, error) { + return _EOConfig.contract.Transact(opts, "removeSymbol", id) } // RemoveSymbol is a paid mutator transaction binding the contract method 0x5aa264e4. // // Solidity: function removeSymbol(uint16 id) returns() -func (_Eoconfig *EoconfigSession) RemoveSymbol(id uint16) (*types.Transaction, error) { - return _Eoconfig.Contract.RemoveSymbol(&_Eoconfig.TransactOpts, id) +func (_EOConfig *EOConfigSession) RemoveSymbol(id uint16) (*types.Transaction, error) { + return _EOConfig.Contract.RemoveSymbol(&_EOConfig.TransactOpts, id) } // RemoveSymbol is a paid mutator transaction binding the contract method 0x5aa264e4. // // Solidity: function removeSymbol(uint16 id) returns() -func (_Eoconfig *EoconfigTransactorSession) RemoveSymbol(id uint16) (*types.Transaction, error) { - return _Eoconfig.Contract.RemoveSymbol(&_Eoconfig.TransactOpts, id) +func (_EOConfig *EOConfigTransactorSession) RemoveSymbol(id uint16) (*types.Transaction, error) { + return _EOConfig.Contract.RemoveSymbol(&_EOConfig.TransactOpts, id) } // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. // // Solidity: function renounceOwnership() returns() -func (_Eoconfig *EoconfigTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) { - return _Eoconfig.contract.Transact(opts, "renounceOwnership") +func (_EOConfig *EOConfigTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) { + return _EOConfig.contract.Transact(opts, "renounceOwnership") } // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. // // Solidity: function renounceOwnership() returns() -func (_Eoconfig *EoconfigSession) RenounceOwnership() (*types.Transaction, error) { - return _Eoconfig.Contract.RenounceOwnership(&_Eoconfig.TransactOpts) +func (_EOConfig *EOConfigSession) RenounceOwnership() (*types.Transaction, error) { + return _EOConfig.Contract.RenounceOwnership(&_EOConfig.TransactOpts) } // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. // // Solidity: function renounceOwnership() returns() -func (_Eoconfig *EoconfigTransactorSession) RenounceOwnership() (*types.Transaction, error) { - return _Eoconfig.Contract.RenounceOwnership(&_Eoconfig.TransactOpts) +func (_EOConfig *EOConfigTransactorSession) RenounceOwnership() (*types.Transaction, error) { + return _EOConfig.Contract.RenounceOwnership(&_EOConfig.TransactOpts) } // SetAggregator is a paid mutator transaction binding the contract method 0xf9120af6. // // Solidity: function setAggregator(address _aggregator) returns() -func (_Eoconfig *EoconfigTransactor) SetAggregator(opts *bind.TransactOpts, _aggregator common.Address) (*types.Transaction, error) { - return _Eoconfig.contract.Transact(opts, "setAggregator", _aggregator) +func (_EOConfig *EOConfigTransactor) SetAggregator(opts *bind.TransactOpts, _aggregator common.Address) (*types.Transaction, error) { + return _EOConfig.contract.Transact(opts, "setAggregator", _aggregator) } // SetAggregator is a paid mutator transaction binding the contract method 0xf9120af6. // // Solidity: function setAggregator(address _aggregator) returns() -func (_Eoconfig *EoconfigSession) SetAggregator(_aggregator common.Address) (*types.Transaction, error) { - return _Eoconfig.Contract.SetAggregator(&_Eoconfig.TransactOpts, _aggregator) +func (_EOConfig *EOConfigSession) SetAggregator(_aggregator common.Address) (*types.Transaction, error) { + return _EOConfig.Contract.SetAggregator(&_EOConfig.TransactOpts, _aggregator) } // SetAggregator is a paid mutator transaction binding the contract method 0xf9120af6. // // Solidity: function setAggregator(address _aggregator) returns() -func (_Eoconfig *EoconfigTransactorSession) SetAggregator(_aggregator common.Address) (*types.Transaction, error) { - return _Eoconfig.Contract.SetAggregator(&_Eoconfig.TransactOpts, _aggregator) +func (_EOConfig *EOConfigTransactorSession) SetAggregator(_aggregator common.Address) (*types.Transaction, error) { + return _EOConfig.Contract.SetAggregator(&_EOConfig.TransactOpts, _aggregator) } // SetChainManager is a paid mutator transaction binding the contract method 0xd70cf0ed. // // Solidity: function setChainManager(address _chainManager) returns() -func (_Eoconfig *EoconfigTransactor) SetChainManager(opts *bind.TransactOpts, _chainManager common.Address) (*types.Transaction, error) { - return _Eoconfig.contract.Transact(opts, "setChainManager", _chainManager) +func (_EOConfig *EOConfigTransactor) SetChainManager(opts *bind.TransactOpts, _chainManager common.Address) (*types.Transaction, error) { + return _EOConfig.contract.Transact(opts, "setChainManager", _chainManager) } // SetChainManager is a paid mutator transaction binding the contract method 0xd70cf0ed. // // Solidity: function setChainManager(address _chainManager) returns() -func (_Eoconfig *EoconfigSession) SetChainManager(_chainManager common.Address) (*types.Transaction, error) { - return _Eoconfig.Contract.SetChainManager(&_Eoconfig.TransactOpts, _chainManager) +func (_EOConfig *EOConfigSession) SetChainManager(_chainManager common.Address) (*types.Transaction, error) { + return _EOConfig.Contract.SetChainManager(&_EOConfig.TransactOpts, _chainManager) } // SetChainManager is a paid mutator transaction binding the contract method 0xd70cf0ed. // // Solidity: function setChainManager(address _chainManager) returns() -func (_Eoconfig *EoconfigTransactorSession) SetChainManager(_chainManager common.Address) (*types.Transaction, error) { - return _Eoconfig.Contract.SetChainManager(&_Eoconfig.TransactOpts, _chainManager) +func (_EOConfig *EOConfigTransactorSession) SetChainManager(_chainManager common.Address) (*types.Transaction, error) { + return _EOConfig.Contract.SetChainManager(&_EOConfig.TransactOpts, _chainManager) } // SetEvmSourceConfig is a paid mutator transaction binding the contract method 0x4571adf1. // // Solidity: function setEvmSourceConfig(address _evmSourceConfig) returns() -func (_Eoconfig *EoconfigTransactor) SetEvmSourceConfig(opts *bind.TransactOpts, _evmSourceConfig common.Address) (*types.Transaction, error) { - return _Eoconfig.contract.Transact(opts, "setEvmSourceConfig", _evmSourceConfig) +func (_EOConfig *EOConfigTransactor) SetEvmSourceConfig(opts *bind.TransactOpts, _evmSourceConfig common.Address) (*types.Transaction, error) { + return _EOConfig.contract.Transact(opts, "setEvmSourceConfig", _evmSourceConfig) } // SetEvmSourceConfig is a paid mutator transaction binding the contract method 0x4571adf1. // // Solidity: function setEvmSourceConfig(address _evmSourceConfig) returns() -func (_Eoconfig *EoconfigSession) SetEvmSourceConfig(_evmSourceConfig common.Address) (*types.Transaction, error) { - return _Eoconfig.Contract.SetEvmSourceConfig(&_Eoconfig.TransactOpts, _evmSourceConfig) +func (_EOConfig *EOConfigSession) SetEvmSourceConfig(_evmSourceConfig common.Address) (*types.Transaction, error) { + return _EOConfig.Contract.SetEvmSourceConfig(&_EOConfig.TransactOpts, _evmSourceConfig) } // SetEvmSourceConfig is a paid mutator transaction binding the contract method 0x4571adf1. // // Solidity: function setEvmSourceConfig(address _evmSourceConfig) returns() -func (_Eoconfig *EoconfigTransactorSession) SetEvmSourceConfig(_evmSourceConfig common.Address) (*types.Transaction, error) { - return _Eoconfig.Contract.SetEvmSourceConfig(&_Eoconfig.TransactOpts, _evmSourceConfig) +func (_EOConfig *EOConfigTransactorSession) SetEvmSourceConfig(_evmSourceConfig common.Address) (*types.Transaction, error) { + return _EOConfig.Contract.SetEvmSourceConfig(&_EOConfig.TransactOpts, _evmSourceConfig) } // SetSourceSymbolIds is a paid mutator transaction binding the contract method 0xe000b072. // // Solidity: function setSourceSymbolIds(uint16 source, uint16[] symbols, string[] names) returns() -func (_Eoconfig *EoconfigTransactor) SetSourceSymbolIds(opts *bind.TransactOpts, source uint16, symbols []uint16, names []string) (*types.Transaction, error) { - return _Eoconfig.contract.Transact(opts, "setSourceSymbolIds", source, symbols, names) +func (_EOConfig *EOConfigTransactor) SetSourceSymbolIds(opts *bind.TransactOpts, source uint16, symbols []uint16, names []string) (*types.Transaction, error) { + return _EOConfig.contract.Transact(opts, "setSourceSymbolIds", source, symbols, names) } // SetSourceSymbolIds is a paid mutator transaction binding the contract method 0xe000b072. // // Solidity: function setSourceSymbolIds(uint16 source, uint16[] symbols, string[] names) returns() -func (_Eoconfig *EoconfigSession) SetSourceSymbolIds(source uint16, symbols []uint16, names []string) (*types.Transaction, error) { - return _Eoconfig.Contract.SetSourceSymbolIds(&_Eoconfig.TransactOpts, source, symbols, names) +func (_EOConfig *EOConfigSession) SetSourceSymbolIds(source uint16, symbols []uint16, names []string) (*types.Transaction, error) { + return _EOConfig.Contract.SetSourceSymbolIds(&_EOConfig.TransactOpts, source, symbols, names) } // SetSourceSymbolIds is a paid mutator transaction binding the contract method 0xe000b072. // // Solidity: function setSourceSymbolIds(uint16 source, uint16[] symbols, string[] names) returns() -func (_Eoconfig *EoconfigTransactorSession) SetSourceSymbolIds(source uint16, symbols []uint16, names []string) (*types.Transaction, error) { - return _Eoconfig.Contract.SetSourceSymbolIds(&_Eoconfig.TransactOpts, source, symbols, names) +func (_EOConfig *EOConfigTransactorSession) SetSourceSymbolIds(source uint16, symbols []uint16, names []string) (*types.Transaction, error) { + return _EOConfig.Contract.SetSourceSymbolIds(&_EOConfig.TransactOpts, source, symbols, names) } // Subscribe is a paid mutator transaction binding the contract method 0x41a7726a. // // Solidity: function subscribe(address listener) returns() -func (_Eoconfig *EoconfigTransactor) Subscribe(opts *bind.TransactOpts, listener common.Address) (*types.Transaction, error) { - return _Eoconfig.contract.Transact(opts, "subscribe", listener) +func (_EOConfig *EOConfigTransactor) Subscribe(opts *bind.TransactOpts, listener common.Address) (*types.Transaction, error) { + return _EOConfig.contract.Transact(opts, "subscribe", listener) } // Subscribe is a paid mutator transaction binding the contract method 0x41a7726a. // // Solidity: function subscribe(address listener) returns() -func (_Eoconfig *EoconfigSession) Subscribe(listener common.Address) (*types.Transaction, error) { - return _Eoconfig.Contract.Subscribe(&_Eoconfig.TransactOpts, listener) +func (_EOConfig *EOConfigSession) Subscribe(listener common.Address) (*types.Transaction, error) { + return _EOConfig.Contract.Subscribe(&_EOConfig.TransactOpts, listener) } // Subscribe is a paid mutator transaction binding the contract method 0x41a7726a. // // Solidity: function subscribe(address listener) returns() -func (_Eoconfig *EoconfigTransactorSession) Subscribe(listener common.Address) (*types.Transaction, error) { - return _Eoconfig.Contract.Subscribe(&_Eoconfig.TransactOpts, listener) +func (_EOConfig *EOConfigTransactorSession) Subscribe(listener common.Address) (*types.Transaction, error) { + return _EOConfig.Contract.Subscribe(&_EOConfig.TransactOpts, listener) } // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. // // Solidity: function transferOwnership(address newOwner) returns() -func (_Eoconfig *EoconfigTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { - return _Eoconfig.contract.Transact(opts, "transferOwnership", newOwner) +func (_EOConfig *EOConfigTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { + return _EOConfig.contract.Transact(opts, "transferOwnership", newOwner) } // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. // // Solidity: function transferOwnership(address newOwner) returns() -func (_Eoconfig *EoconfigSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { - return _Eoconfig.Contract.TransferOwnership(&_Eoconfig.TransactOpts, newOwner) +func (_EOConfig *EOConfigSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _EOConfig.Contract.TransferOwnership(&_EOConfig.TransactOpts, newOwner) } // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. // // Solidity: function transferOwnership(address newOwner) returns() -func (_Eoconfig *EoconfigTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { - return _Eoconfig.Contract.TransferOwnership(&_Eoconfig.TransactOpts, newOwner) +func (_EOConfig *EOConfigTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _EOConfig.Contract.TransferOwnership(&_EOConfig.TransactOpts, newOwner) } // Unsubscribe is a paid mutator transaction binding the contract method 0x7262561c. // // Solidity: function unsubscribe(address listener) returns() -func (_Eoconfig *EoconfigTransactor) Unsubscribe(opts *bind.TransactOpts, listener common.Address) (*types.Transaction, error) { - return _Eoconfig.contract.Transact(opts, "unsubscribe", listener) +func (_EOConfig *EOConfigTransactor) Unsubscribe(opts *bind.TransactOpts, listener common.Address) (*types.Transaction, error) { + return _EOConfig.contract.Transact(opts, "unsubscribe", listener) } // Unsubscribe is a paid mutator transaction binding the contract method 0x7262561c. // // Solidity: function unsubscribe(address listener) returns() -func (_Eoconfig *EoconfigSession) Unsubscribe(listener common.Address) (*types.Transaction, error) { - return _Eoconfig.Contract.Unsubscribe(&_Eoconfig.TransactOpts, listener) +func (_EOConfig *EOConfigSession) Unsubscribe(listener common.Address) (*types.Transaction, error) { + return _EOConfig.Contract.Unsubscribe(&_EOConfig.TransactOpts, listener) } // Unsubscribe is a paid mutator transaction binding the contract method 0x7262561c. // // Solidity: function unsubscribe(address listener) returns() -func (_Eoconfig *EoconfigTransactorSession) Unsubscribe(listener common.Address) (*types.Transaction, error) { - return _Eoconfig.Contract.Unsubscribe(&_Eoconfig.TransactOpts, listener) +func (_EOConfig *EOConfigTransactorSession) Unsubscribe(listener common.Address) (*types.Transaction, error) { + return _EOConfig.Contract.Unsubscribe(&_EOConfig.TransactOpts, listener) } // UpdateSource is a paid mutator transaction binding the contract method 0x88c54990. // // Solidity: function updateSource(uint16 _sourceId, bytes24 name, uint16[] _symbols) returns() -func (_Eoconfig *EoconfigTransactor) UpdateSource(opts *bind.TransactOpts, _sourceId uint16, name [24]byte, _symbols []uint16) (*types.Transaction, error) { - return _Eoconfig.contract.Transact(opts, "updateSource", _sourceId, name, _symbols) +func (_EOConfig *EOConfigTransactor) UpdateSource(opts *bind.TransactOpts, _sourceId uint16, name [24]byte, _symbols []uint16) (*types.Transaction, error) { + return _EOConfig.contract.Transact(opts, "updateSource", _sourceId, name, _symbols) } // UpdateSource is a paid mutator transaction binding the contract method 0x88c54990. // // Solidity: function updateSource(uint16 _sourceId, bytes24 name, uint16[] _symbols) returns() -func (_Eoconfig *EoconfigSession) UpdateSource(_sourceId uint16, name [24]byte, _symbols []uint16) (*types.Transaction, error) { - return _Eoconfig.Contract.UpdateSource(&_Eoconfig.TransactOpts, _sourceId, name, _symbols) +func (_EOConfig *EOConfigSession) UpdateSource(_sourceId uint16, name [24]byte, _symbols []uint16) (*types.Transaction, error) { + return _EOConfig.Contract.UpdateSource(&_EOConfig.TransactOpts, _sourceId, name, _symbols) } // UpdateSource is a paid mutator transaction binding the contract method 0x88c54990. // // Solidity: function updateSource(uint16 _sourceId, bytes24 name, uint16[] _symbols) returns() -func (_Eoconfig *EoconfigTransactorSession) UpdateSource(_sourceId uint16, name [24]byte, _symbols []uint16) (*types.Transaction, error) { - return _Eoconfig.Contract.UpdateSource(&_Eoconfig.TransactOpts, _sourceId, name, _symbols) +func (_EOConfig *EOConfigTransactorSession) UpdateSource(_sourceId uint16, name [24]byte, _symbols []uint16) (*types.Transaction, error) { + return _EOConfig.Contract.UpdateSource(&_EOConfig.TransactOpts, _sourceId, name, _symbols) } // UpdateSymbol is a paid mutator transaction binding the contract method 0x9483a58d. // // Solidity: function updateSymbol(uint16 _symbolId, bytes8 name, uint16[] _sources) returns() -func (_Eoconfig *EoconfigTransactor) UpdateSymbol(opts *bind.TransactOpts, _symbolId uint16, name [8]byte, _sources []uint16) (*types.Transaction, error) { - return _Eoconfig.contract.Transact(opts, "updateSymbol", _symbolId, name, _sources) +func (_EOConfig *EOConfigTransactor) UpdateSymbol(opts *bind.TransactOpts, _symbolId uint16, name [8]byte, _sources []uint16) (*types.Transaction, error) { + return _EOConfig.contract.Transact(opts, "updateSymbol", _symbolId, name, _sources) } // UpdateSymbol is a paid mutator transaction binding the contract method 0x9483a58d. // // Solidity: function updateSymbol(uint16 _symbolId, bytes8 name, uint16[] _sources) returns() -func (_Eoconfig *EoconfigSession) UpdateSymbol(_symbolId uint16, name [8]byte, _sources []uint16) (*types.Transaction, error) { - return _Eoconfig.Contract.UpdateSymbol(&_Eoconfig.TransactOpts, _symbolId, name, _sources) +func (_EOConfig *EOConfigSession) UpdateSymbol(_symbolId uint16, name [8]byte, _sources []uint16) (*types.Transaction, error) { + return _EOConfig.Contract.UpdateSymbol(&_EOConfig.TransactOpts, _symbolId, name, _sources) } // UpdateSymbol is a paid mutator transaction binding the contract method 0x9483a58d. // // Solidity: function updateSymbol(uint16 _symbolId, bytes8 name, uint16[] _sources) returns() -func (_Eoconfig *EoconfigTransactorSession) UpdateSymbol(_symbolId uint16, name [8]byte, _sources []uint16) (*types.Transaction, error) { - return _Eoconfig.Contract.UpdateSymbol(&_Eoconfig.TransactOpts, _symbolId, name, _sources) +func (_EOConfig *EOConfigTransactorSession) UpdateSymbol(_symbolId uint16, name [8]byte, _sources []uint16) (*types.Transaction, error) { + return _EOConfig.Contract.UpdateSymbol(&_EOConfig.TransactOpts, _symbolId, name, _sources) } // Receive is a paid mutator transaction binding the contract receive function. // // Solidity: receive() payable returns() -func (_Eoconfig *EoconfigTransactor) Receive(opts *bind.TransactOpts) (*types.Transaction, error) { - return _Eoconfig.contract.RawTransact(opts, nil) // calldata is disallowed for receive function +func (_EOConfig *EOConfigTransactor) Receive(opts *bind.TransactOpts) (*types.Transaction, error) { + return _EOConfig.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 (_Eoconfig *EoconfigSession) Receive() (*types.Transaction, error) { - return _Eoconfig.Contract.Receive(&_Eoconfig.TransactOpts) +func (_EOConfig *EOConfigSession) Receive() (*types.Transaction, error) { + return _EOConfig.Contract.Receive(&_EOConfig.TransactOpts) } // Receive is a paid mutator transaction binding the contract receive function. // // Solidity: receive() payable returns() -func (_Eoconfig *EoconfigTransactorSession) Receive() (*types.Transaction, error) { - return _Eoconfig.Contract.Receive(&_Eoconfig.TransactOpts) +func (_EOConfig *EOConfigTransactorSession) Receive() (*types.Transaction, error) { + return _EOConfig.Contract.Receive(&_EOConfig.TransactOpts) } -// EoconfigInitializedIterator is returned from FilterInitialized and is used to iterate over the raw logs and unpacked data for Initialized events raised by the Eoconfig contract. -type EoconfigInitializedIterator struct { - Event *EoconfigInitialized // Event containing the contract specifics and raw log +// EOConfigInitializedIterator is returned from FilterInitialized and is used to iterate over the raw logs and unpacked data for Initialized events raised by the EOConfig contract. +type EOConfigInitializedIterator struct { + Event *EOConfigInitialized // 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 @@ -1380,7 +1358,7 @@ type EoconfigInitializedIterator struct { // 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 *EoconfigInitializedIterator) Next() bool { +func (it *EOConfigInitializedIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -1389,7 +1367,7 @@ func (it *EoconfigInitializedIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(EoconfigInitialized) + it.Event = new(EOConfigInitialized) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1404,7 +1382,7 @@ func (it *EoconfigInitializedIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(EoconfigInitialized) + it.Event = new(EOConfigInitialized) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1420,19 +1398,19 @@ func (it *EoconfigInitializedIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *EoconfigInitializedIterator) Error() error { +func (it *EOConfigInitializedIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *EoconfigInitializedIterator) Close() error { +func (it *EOConfigInitializedIterator) Close() error { it.sub.Unsubscribe() return nil } -// EoconfigInitialized represents a Initialized event raised by the Eoconfig contract. -type EoconfigInitialized struct { +// EOConfigInitialized represents a Initialized event raised by the EOConfig contract. +type EOConfigInitialized struct { Version uint8 Raw types.Log // Blockchain specific contextual infos } @@ -1440,21 +1418,21 @@ type EoconfigInitialized struct { // FilterInitialized is a free log retrieval operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. // // Solidity: event Initialized(uint8 version) -func (_Eoconfig *EoconfigFilterer) FilterInitialized(opts *bind.FilterOpts) (*EoconfigInitializedIterator, error) { +func (_EOConfig *EOConfigFilterer) FilterInitialized(opts *bind.FilterOpts) (*EOConfigInitializedIterator, error) { - logs, sub, err := _Eoconfig.contract.FilterLogs(opts, "Initialized") + logs, sub, err := _EOConfig.contract.FilterLogs(opts, "Initialized") if err != nil { return nil, err } - return &EoconfigInitializedIterator{contract: _Eoconfig.contract, event: "Initialized", logs: logs, sub: sub}, nil + return &EOConfigInitializedIterator{contract: _EOConfig.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 (_Eoconfig *EoconfigFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *EoconfigInitialized) (event.Subscription, error) { +func (_EOConfig *EOConfigFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *EOConfigInitialized) (event.Subscription, error) { - logs, sub, err := _Eoconfig.contract.WatchLogs(opts, "Initialized") + logs, sub, err := _EOConfig.contract.WatchLogs(opts, "Initialized") if err != nil { return nil, err } @@ -1464,8 +1442,8 @@ func (_Eoconfig *EoconfigFilterer) WatchInitialized(opts *bind.WatchOpts, sink c select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(EoconfigInitialized) - if err := _Eoconfig.contract.UnpackLog(event, "Initialized", log); err != nil { + event := new(EOConfigInitialized) + if err := _EOConfig.contract.UnpackLog(event, "Initialized", log); err != nil { return err } event.Raw = log @@ -1489,18 +1467,18 @@ func (_Eoconfig *EoconfigFilterer) WatchInitialized(opts *bind.WatchOpts, sink c // ParseInitialized is a log parse operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. // // Solidity: event Initialized(uint8 version) -func (_Eoconfig *EoconfigFilterer) ParseInitialized(log types.Log) (*EoconfigInitialized, error) { - event := new(EoconfigInitialized) - if err := _Eoconfig.contract.UnpackLog(event, "Initialized", log); err != nil { +func (_EOConfig *EOConfigFilterer) ParseInitialized(log types.Log) (*EOConfigInitialized, error) { + event := new(EOConfigInitialized) + if err := _EOConfig.contract.UnpackLog(event, "Initialized", log); err != nil { return nil, err } event.Raw = log return event, nil } -// EoconfigOnConfigChangeIterator is returned from FilterOnConfigChange and is used to iterate over the raw logs and unpacked data for OnConfigChange events raised by the Eoconfig contract. -type EoconfigOnConfigChangeIterator struct { - Event *EoconfigOnConfigChange // Event containing the contract specifics and raw log +// EOConfigOnConfigChangeIterator is returned from FilterOnConfigChange and is used to iterate over the raw logs and unpacked data for OnConfigChange events raised by the EOConfig contract. +type EOConfigOnConfigChangeIterator struct { + Event *EOConfigOnConfigChange // 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 @@ -1514,7 +1492,7 @@ type EoconfigOnConfigChangeIterator struct { // 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 *EoconfigOnConfigChangeIterator) Next() bool { +func (it *EOConfigOnConfigChangeIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -1523,7 +1501,7 @@ func (it *EoconfigOnConfigChangeIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(EoconfigOnConfigChange) + it.Event = new(EOConfigOnConfigChange) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1538,7 +1516,7 @@ func (it *EoconfigOnConfigChangeIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(EoconfigOnConfigChange) + it.Event = new(EOConfigOnConfigChange) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1554,40 +1532,40 @@ func (it *EoconfigOnConfigChangeIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *EoconfigOnConfigChangeIterator) Error() error { +func (it *EOConfigOnConfigChangeIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *EoconfigOnConfigChangeIterator) Close() error { +func (it *EOConfigOnConfigChangeIterator) Close() error { it.sub.Unsubscribe() return nil } -// EoconfigOnConfigChange represents a OnConfigChange event raised by the Eoconfig contract. -type EoconfigOnConfigChange struct { +// EOConfigOnConfigChange represents a OnConfigChange event raised by the EOConfig contract. +type EOConfigOnConfigChange struct { Raw types.Log // Blockchain specific contextual infos } // FilterOnConfigChange is a free log retrieval operation binding the contract event 0x662f307c99b27e8c90dbce053f13da64171deb8c531b3ae9c9446ab010da7fdc. // // Solidity: event OnConfigChange() -func (_Eoconfig *EoconfigFilterer) FilterOnConfigChange(opts *bind.FilterOpts) (*EoconfigOnConfigChangeIterator, error) { +func (_EOConfig *EOConfigFilterer) FilterOnConfigChange(opts *bind.FilterOpts) (*EOConfigOnConfigChangeIterator, error) { - logs, sub, err := _Eoconfig.contract.FilterLogs(opts, "OnConfigChange") + logs, sub, err := _EOConfig.contract.FilterLogs(opts, "OnConfigChange") if err != nil { return nil, err } - return &EoconfigOnConfigChangeIterator{contract: _Eoconfig.contract, event: "OnConfigChange", logs: logs, sub: sub}, nil + return &EOConfigOnConfigChangeIterator{contract: _EOConfig.contract, event: "OnConfigChange", logs: logs, sub: sub}, nil } // WatchOnConfigChange is a free log subscription operation binding the contract event 0x662f307c99b27e8c90dbce053f13da64171deb8c531b3ae9c9446ab010da7fdc. // // Solidity: event OnConfigChange() -func (_Eoconfig *EoconfigFilterer) WatchOnConfigChange(opts *bind.WatchOpts, sink chan<- *EoconfigOnConfigChange) (event.Subscription, error) { +func (_EOConfig *EOConfigFilterer) WatchOnConfigChange(opts *bind.WatchOpts, sink chan<- *EOConfigOnConfigChange) (event.Subscription, error) { - logs, sub, err := _Eoconfig.contract.WatchLogs(opts, "OnConfigChange") + logs, sub, err := _EOConfig.contract.WatchLogs(opts, "OnConfigChange") if err != nil { return nil, err } @@ -1597,8 +1575,8 @@ func (_Eoconfig *EoconfigFilterer) WatchOnConfigChange(opts *bind.WatchOpts, sin select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(EoconfigOnConfigChange) - if err := _Eoconfig.contract.UnpackLog(event, "OnConfigChange", log); err != nil { + event := new(EOConfigOnConfigChange) + if err := _EOConfig.contract.UnpackLog(event, "OnConfigChange", log); err != nil { return err } event.Raw = log @@ -1622,18 +1600,18 @@ func (_Eoconfig *EoconfigFilterer) WatchOnConfigChange(opts *bind.WatchOpts, sin // ParseOnConfigChange is a log parse operation binding the contract event 0x662f307c99b27e8c90dbce053f13da64171deb8c531b3ae9c9446ab010da7fdc. // // Solidity: event OnConfigChange() -func (_Eoconfig *EoconfigFilterer) ParseOnConfigChange(log types.Log) (*EoconfigOnConfigChange, error) { - event := new(EoconfigOnConfigChange) - if err := _Eoconfig.contract.UnpackLog(event, "OnConfigChange", log); err != nil { +func (_EOConfig *EOConfigFilterer) ParseOnConfigChange(log types.Log) (*EOConfigOnConfigChange, error) { + event := new(EOConfigOnConfigChange) + if err := _EOConfig.contract.UnpackLog(event, "OnConfigChange", log); err != nil { return nil, err } event.Raw = log return event, nil } -// EoconfigOnSourceAddedIterator is returned from FilterOnSourceAdded and is used to iterate over the raw logs and unpacked data for OnSourceAdded events raised by the Eoconfig contract. -type EoconfigOnSourceAddedIterator struct { - Event *EoconfigOnSourceAdded // Event containing the contract specifics and raw log +// EOConfigOnSourceAddedIterator is returned from FilterOnSourceAdded and is used to iterate over the raw logs and unpacked data for OnSourceAdded events raised by the EOConfig contract. +type EOConfigOnSourceAddedIterator struct { + Event *EOConfigOnSourceAdded // 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 @@ -1647,7 +1625,7 @@ type EoconfigOnSourceAddedIterator struct { // 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 *EoconfigOnSourceAddedIterator) Next() bool { +func (it *EOConfigOnSourceAddedIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -1656,7 +1634,7 @@ func (it *EoconfigOnSourceAddedIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(EoconfigOnSourceAdded) + it.Event = new(EOConfigOnSourceAdded) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1671,7 +1649,7 @@ func (it *EoconfigOnSourceAddedIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(EoconfigOnSourceAdded) + it.Event = new(EOConfigOnSourceAdded) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1687,19 +1665,19 @@ func (it *EoconfigOnSourceAddedIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *EoconfigOnSourceAddedIterator) Error() error { +func (it *EOConfigOnSourceAddedIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *EoconfigOnSourceAddedIterator) Close() error { +func (it *EOConfigOnSourceAddedIterator) Close() error { it.sub.Unsubscribe() return nil } -// EoconfigOnSourceAdded represents a OnSourceAdded event raised by the Eoconfig contract. -type EoconfigOnSourceAdded struct { +// EOConfigOnSourceAdded represents a OnSourceAdded event raised by the EOConfig contract. +type EOConfigOnSourceAdded struct { Id uint16 Name [24]byte Raw types.Log // Blockchain specific contextual infos @@ -1708,21 +1686,21 @@ type EoconfigOnSourceAdded struct { // FilterOnSourceAdded is a free log retrieval operation binding the contract event 0x209da2b4b51d7df154f686f6190e38bf6eb987bf19f48df080b9a14111762d88. // // Solidity: event OnSourceAdded(uint16 id, bytes24 name) -func (_Eoconfig *EoconfigFilterer) FilterOnSourceAdded(opts *bind.FilterOpts) (*EoconfigOnSourceAddedIterator, error) { +func (_EOConfig *EOConfigFilterer) FilterOnSourceAdded(opts *bind.FilterOpts) (*EOConfigOnSourceAddedIterator, error) { - logs, sub, err := _Eoconfig.contract.FilterLogs(opts, "OnSourceAdded") + logs, sub, err := _EOConfig.contract.FilterLogs(opts, "OnSourceAdded") if err != nil { return nil, err } - return &EoconfigOnSourceAddedIterator{contract: _Eoconfig.contract, event: "OnSourceAdded", logs: logs, sub: sub}, nil + return &EOConfigOnSourceAddedIterator{contract: _EOConfig.contract, event: "OnSourceAdded", logs: logs, sub: sub}, nil } // WatchOnSourceAdded is a free log subscription operation binding the contract event 0x209da2b4b51d7df154f686f6190e38bf6eb987bf19f48df080b9a14111762d88. // // Solidity: event OnSourceAdded(uint16 id, bytes24 name) -func (_Eoconfig *EoconfigFilterer) WatchOnSourceAdded(opts *bind.WatchOpts, sink chan<- *EoconfigOnSourceAdded) (event.Subscription, error) { +func (_EOConfig *EOConfigFilterer) WatchOnSourceAdded(opts *bind.WatchOpts, sink chan<- *EOConfigOnSourceAdded) (event.Subscription, error) { - logs, sub, err := _Eoconfig.contract.WatchLogs(opts, "OnSourceAdded") + logs, sub, err := _EOConfig.contract.WatchLogs(opts, "OnSourceAdded") if err != nil { return nil, err } @@ -1732,8 +1710,8 @@ func (_Eoconfig *EoconfigFilterer) WatchOnSourceAdded(opts *bind.WatchOpts, sink select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(EoconfigOnSourceAdded) - if err := _Eoconfig.contract.UnpackLog(event, "OnSourceAdded", log); err != nil { + event := new(EOConfigOnSourceAdded) + if err := _EOConfig.contract.UnpackLog(event, "OnSourceAdded", log); err != nil { return err } event.Raw = log @@ -1757,18 +1735,18 @@ func (_Eoconfig *EoconfigFilterer) WatchOnSourceAdded(opts *bind.WatchOpts, sink // ParseOnSourceAdded is a log parse operation binding the contract event 0x209da2b4b51d7df154f686f6190e38bf6eb987bf19f48df080b9a14111762d88. // // Solidity: event OnSourceAdded(uint16 id, bytes24 name) -func (_Eoconfig *EoconfigFilterer) ParseOnSourceAdded(log types.Log) (*EoconfigOnSourceAdded, error) { - event := new(EoconfigOnSourceAdded) - if err := _Eoconfig.contract.UnpackLog(event, "OnSourceAdded", log); err != nil { +func (_EOConfig *EOConfigFilterer) ParseOnSourceAdded(log types.Log) (*EOConfigOnSourceAdded, error) { + event := new(EOConfigOnSourceAdded) + if err := _EOConfig.contract.UnpackLog(event, "OnSourceAdded", log); err != nil { return nil, err } event.Raw = log return event, nil } -// EoconfigOnSourceRemovedIterator is returned from FilterOnSourceRemoved and is used to iterate over the raw logs and unpacked data for OnSourceRemoved events raised by the Eoconfig contract. -type EoconfigOnSourceRemovedIterator struct { - Event *EoconfigOnSourceRemoved // Event containing the contract specifics and raw log +// EOConfigOnSourceRemovedIterator is returned from FilterOnSourceRemoved and is used to iterate over the raw logs and unpacked data for OnSourceRemoved events raised by the EOConfig contract. +type EOConfigOnSourceRemovedIterator struct { + Event *EOConfigOnSourceRemoved // 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 @@ -1782,7 +1760,7 @@ type EoconfigOnSourceRemovedIterator struct { // 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 *EoconfigOnSourceRemovedIterator) Next() bool { +func (it *EOConfigOnSourceRemovedIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -1791,7 +1769,7 @@ func (it *EoconfigOnSourceRemovedIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(EoconfigOnSourceRemoved) + it.Event = new(EOConfigOnSourceRemoved) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1806,7 +1784,7 @@ func (it *EoconfigOnSourceRemovedIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(EoconfigOnSourceRemoved) + it.Event = new(EOConfigOnSourceRemoved) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1822,19 +1800,19 @@ func (it *EoconfigOnSourceRemovedIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *EoconfigOnSourceRemovedIterator) Error() error { +func (it *EOConfigOnSourceRemovedIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *EoconfigOnSourceRemovedIterator) Close() error { +func (it *EOConfigOnSourceRemovedIterator) Close() error { it.sub.Unsubscribe() return nil } -// EoconfigOnSourceRemoved represents a OnSourceRemoved event raised by the Eoconfig contract. -type EoconfigOnSourceRemoved struct { +// EOConfigOnSourceRemoved represents a OnSourceRemoved event raised by the EOConfig contract. +type EOConfigOnSourceRemoved struct { Id uint16 Raw types.Log // Blockchain specific contextual infos } @@ -1842,21 +1820,21 @@ type EoconfigOnSourceRemoved struct { // FilterOnSourceRemoved is a free log retrieval operation binding the contract event 0xce77a2b83741e02bd444c230b0f3ab40ea28201581cd73d3fe76809d16cca361. // // Solidity: event OnSourceRemoved(uint16 id) -func (_Eoconfig *EoconfigFilterer) FilterOnSourceRemoved(opts *bind.FilterOpts) (*EoconfigOnSourceRemovedIterator, error) { +func (_EOConfig *EOConfigFilterer) FilterOnSourceRemoved(opts *bind.FilterOpts) (*EOConfigOnSourceRemovedIterator, error) { - logs, sub, err := _Eoconfig.contract.FilterLogs(opts, "OnSourceRemoved") + logs, sub, err := _EOConfig.contract.FilterLogs(opts, "OnSourceRemoved") if err != nil { return nil, err } - return &EoconfigOnSourceRemovedIterator{contract: _Eoconfig.contract, event: "OnSourceRemoved", logs: logs, sub: sub}, nil + return &EOConfigOnSourceRemovedIterator{contract: _EOConfig.contract, event: "OnSourceRemoved", logs: logs, sub: sub}, nil } // WatchOnSourceRemoved is a free log subscription operation binding the contract event 0xce77a2b83741e02bd444c230b0f3ab40ea28201581cd73d3fe76809d16cca361. // // Solidity: event OnSourceRemoved(uint16 id) -func (_Eoconfig *EoconfigFilterer) WatchOnSourceRemoved(opts *bind.WatchOpts, sink chan<- *EoconfigOnSourceRemoved) (event.Subscription, error) { +func (_EOConfig *EOConfigFilterer) WatchOnSourceRemoved(opts *bind.WatchOpts, sink chan<- *EOConfigOnSourceRemoved) (event.Subscription, error) { - logs, sub, err := _Eoconfig.contract.WatchLogs(opts, "OnSourceRemoved") + logs, sub, err := _EOConfig.contract.WatchLogs(opts, "OnSourceRemoved") if err != nil { return nil, err } @@ -1866,8 +1844,8 @@ func (_Eoconfig *EoconfigFilterer) WatchOnSourceRemoved(opts *bind.WatchOpts, si select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(EoconfigOnSourceRemoved) - if err := _Eoconfig.contract.UnpackLog(event, "OnSourceRemoved", log); err != nil { + event := new(EOConfigOnSourceRemoved) + if err := _EOConfig.contract.UnpackLog(event, "OnSourceRemoved", log); err != nil { return err } event.Raw = log @@ -1891,18 +1869,18 @@ func (_Eoconfig *EoconfigFilterer) WatchOnSourceRemoved(opts *bind.WatchOpts, si // ParseOnSourceRemoved is a log parse operation binding the contract event 0xce77a2b83741e02bd444c230b0f3ab40ea28201581cd73d3fe76809d16cca361. // // Solidity: event OnSourceRemoved(uint16 id) -func (_Eoconfig *EoconfigFilterer) ParseOnSourceRemoved(log types.Log) (*EoconfigOnSourceRemoved, error) { - event := new(EoconfigOnSourceRemoved) - if err := _Eoconfig.contract.UnpackLog(event, "OnSourceRemoved", log); err != nil { +func (_EOConfig *EOConfigFilterer) ParseOnSourceRemoved(log types.Log) (*EOConfigOnSourceRemoved, error) { + event := new(EOConfigOnSourceRemoved) + if err := _EOConfig.contract.UnpackLog(event, "OnSourceRemoved", log); err != nil { return nil, err } event.Raw = log return event, nil } -// EoconfigOnSourceUpdatedIterator is returned from FilterOnSourceUpdated and is used to iterate over the raw logs and unpacked data for OnSourceUpdated events raised by the Eoconfig contract. -type EoconfigOnSourceUpdatedIterator struct { - Event *EoconfigOnSourceUpdated // Event containing the contract specifics and raw log +// EOConfigOnSourceUpdatedIterator is returned from FilterOnSourceUpdated and is used to iterate over the raw logs and unpacked data for OnSourceUpdated events raised by the EOConfig contract. +type EOConfigOnSourceUpdatedIterator struct { + Event *EOConfigOnSourceUpdated // 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 @@ -1916,7 +1894,7 @@ type EoconfigOnSourceUpdatedIterator struct { // 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 *EoconfigOnSourceUpdatedIterator) Next() bool { +func (it *EOConfigOnSourceUpdatedIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -1925,7 +1903,7 @@ func (it *EoconfigOnSourceUpdatedIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(EoconfigOnSourceUpdated) + it.Event = new(EOConfigOnSourceUpdated) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1940,7 +1918,7 @@ func (it *EoconfigOnSourceUpdatedIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(EoconfigOnSourceUpdated) + it.Event = new(EOConfigOnSourceUpdated) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1956,19 +1934,19 @@ func (it *EoconfigOnSourceUpdatedIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *EoconfigOnSourceUpdatedIterator) Error() error { +func (it *EOConfigOnSourceUpdatedIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *EoconfigOnSourceUpdatedIterator) Close() error { +func (it *EOConfigOnSourceUpdatedIterator) Close() error { it.sub.Unsubscribe() return nil } -// EoconfigOnSourceUpdated represents a OnSourceUpdated event raised by the Eoconfig contract. -type EoconfigOnSourceUpdated struct { +// EOConfigOnSourceUpdated represents a OnSourceUpdated event raised by the EOConfig contract. +type EOConfigOnSourceUpdated struct { Id uint16 Name [24]byte Symbols []uint16 @@ -1978,21 +1956,21 @@ type EoconfigOnSourceUpdated struct { // FilterOnSourceUpdated is a free log retrieval operation binding the contract event 0x051fa95d237354f8475b41634acc198ae4da9758585b7ab07f2f6839f71492a2. // // Solidity: event OnSourceUpdated(uint16 id, bytes24 name, uint16[] symbols) -func (_Eoconfig *EoconfigFilterer) FilterOnSourceUpdated(opts *bind.FilterOpts) (*EoconfigOnSourceUpdatedIterator, error) { +func (_EOConfig *EOConfigFilterer) FilterOnSourceUpdated(opts *bind.FilterOpts) (*EOConfigOnSourceUpdatedIterator, error) { - logs, sub, err := _Eoconfig.contract.FilterLogs(opts, "OnSourceUpdated") + logs, sub, err := _EOConfig.contract.FilterLogs(opts, "OnSourceUpdated") if err != nil { return nil, err } - return &EoconfigOnSourceUpdatedIterator{contract: _Eoconfig.contract, event: "OnSourceUpdated", logs: logs, sub: sub}, nil + return &EOConfigOnSourceUpdatedIterator{contract: _EOConfig.contract, event: "OnSourceUpdated", logs: logs, sub: sub}, nil } // WatchOnSourceUpdated is a free log subscription operation binding the contract event 0x051fa95d237354f8475b41634acc198ae4da9758585b7ab07f2f6839f71492a2. // // Solidity: event OnSourceUpdated(uint16 id, bytes24 name, uint16[] symbols) -func (_Eoconfig *EoconfigFilterer) WatchOnSourceUpdated(opts *bind.WatchOpts, sink chan<- *EoconfigOnSourceUpdated) (event.Subscription, error) { +func (_EOConfig *EOConfigFilterer) WatchOnSourceUpdated(opts *bind.WatchOpts, sink chan<- *EOConfigOnSourceUpdated) (event.Subscription, error) { - logs, sub, err := _Eoconfig.contract.WatchLogs(opts, "OnSourceUpdated") + logs, sub, err := _EOConfig.contract.WatchLogs(opts, "OnSourceUpdated") if err != nil { return nil, err } @@ -2002,8 +1980,8 @@ func (_Eoconfig *EoconfigFilterer) WatchOnSourceUpdated(opts *bind.WatchOpts, si select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(EoconfigOnSourceUpdated) - if err := _Eoconfig.contract.UnpackLog(event, "OnSourceUpdated", log); err != nil { + event := new(EOConfigOnSourceUpdated) + if err := _EOConfig.contract.UnpackLog(event, "OnSourceUpdated", log); err != nil { return err } event.Raw = log @@ -2027,18 +2005,18 @@ func (_Eoconfig *EoconfigFilterer) WatchOnSourceUpdated(opts *bind.WatchOpts, si // ParseOnSourceUpdated is a log parse operation binding the contract event 0x051fa95d237354f8475b41634acc198ae4da9758585b7ab07f2f6839f71492a2. // // Solidity: event OnSourceUpdated(uint16 id, bytes24 name, uint16[] symbols) -func (_Eoconfig *EoconfigFilterer) ParseOnSourceUpdated(log types.Log) (*EoconfigOnSourceUpdated, error) { - event := new(EoconfigOnSourceUpdated) - if err := _Eoconfig.contract.UnpackLog(event, "OnSourceUpdated", log); err != nil { +func (_EOConfig *EOConfigFilterer) ParseOnSourceUpdated(log types.Log) (*EOConfigOnSourceUpdated, error) { + event := new(EOConfigOnSourceUpdated) + if err := _EOConfig.contract.UnpackLog(event, "OnSourceUpdated", log); err != nil { return nil, err } event.Raw = log return event, nil } -// EoconfigOnSymbolAddedIterator is returned from FilterOnSymbolAdded and is used to iterate over the raw logs and unpacked data for OnSymbolAdded events raised by the Eoconfig contract. -type EoconfigOnSymbolAddedIterator struct { - Event *EoconfigOnSymbolAdded // Event containing the contract specifics and raw log +// EOConfigOnSymbolAddedIterator is returned from FilterOnSymbolAdded and is used to iterate over the raw logs and unpacked data for OnSymbolAdded events raised by the EOConfig contract. +type EOConfigOnSymbolAddedIterator struct { + Event *EOConfigOnSymbolAdded // 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 @@ -2052,7 +2030,7 @@ type EoconfigOnSymbolAddedIterator struct { // 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 *EoconfigOnSymbolAddedIterator) Next() bool { +func (it *EOConfigOnSymbolAddedIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -2061,7 +2039,7 @@ func (it *EoconfigOnSymbolAddedIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(EoconfigOnSymbolAdded) + it.Event = new(EOConfigOnSymbolAdded) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -2076,7 +2054,7 @@ func (it *EoconfigOnSymbolAddedIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(EoconfigOnSymbolAdded) + it.Event = new(EOConfigOnSymbolAdded) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -2092,19 +2070,19 @@ func (it *EoconfigOnSymbolAddedIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *EoconfigOnSymbolAddedIterator) Error() error { +func (it *EOConfigOnSymbolAddedIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *EoconfigOnSymbolAddedIterator) Close() error { +func (it *EOConfigOnSymbolAddedIterator) Close() error { it.sub.Unsubscribe() return nil } -// EoconfigOnSymbolAdded represents a OnSymbolAdded event raised by the Eoconfig contract. -type EoconfigOnSymbolAdded struct { +// EOConfigOnSymbolAdded represents a OnSymbolAdded event raised by the EOConfig contract. +type EOConfigOnSymbolAdded struct { Id uint16 Name [8]byte Raw types.Log // Blockchain specific contextual infos @@ -2113,21 +2091,21 @@ type EoconfigOnSymbolAdded struct { // FilterOnSymbolAdded is a free log retrieval operation binding the contract event 0x17c9d771a4294ad678b91f00d84d6c838ce1f073b54b67bf7070320331667e99. // // Solidity: event OnSymbolAdded(uint16 id, bytes8 name) -func (_Eoconfig *EoconfigFilterer) FilterOnSymbolAdded(opts *bind.FilterOpts) (*EoconfigOnSymbolAddedIterator, error) { +func (_EOConfig *EOConfigFilterer) FilterOnSymbolAdded(opts *bind.FilterOpts) (*EOConfigOnSymbolAddedIterator, error) { - logs, sub, err := _Eoconfig.contract.FilterLogs(opts, "OnSymbolAdded") + logs, sub, err := _EOConfig.contract.FilterLogs(opts, "OnSymbolAdded") if err != nil { return nil, err } - return &EoconfigOnSymbolAddedIterator{contract: _Eoconfig.contract, event: "OnSymbolAdded", logs: logs, sub: sub}, nil + return &EOConfigOnSymbolAddedIterator{contract: _EOConfig.contract, event: "OnSymbolAdded", logs: logs, sub: sub}, nil } // WatchOnSymbolAdded is a free log subscription operation binding the contract event 0x17c9d771a4294ad678b91f00d84d6c838ce1f073b54b67bf7070320331667e99. // // Solidity: event OnSymbolAdded(uint16 id, bytes8 name) -func (_Eoconfig *EoconfigFilterer) WatchOnSymbolAdded(opts *bind.WatchOpts, sink chan<- *EoconfigOnSymbolAdded) (event.Subscription, error) { +func (_EOConfig *EOConfigFilterer) WatchOnSymbolAdded(opts *bind.WatchOpts, sink chan<- *EOConfigOnSymbolAdded) (event.Subscription, error) { - logs, sub, err := _Eoconfig.contract.WatchLogs(opts, "OnSymbolAdded") + logs, sub, err := _EOConfig.contract.WatchLogs(opts, "OnSymbolAdded") if err != nil { return nil, err } @@ -2137,8 +2115,8 @@ func (_Eoconfig *EoconfigFilterer) WatchOnSymbolAdded(opts *bind.WatchOpts, sink select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(EoconfigOnSymbolAdded) - if err := _Eoconfig.contract.UnpackLog(event, "OnSymbolAdded", log); err != nil { + event := new(EOConfigOnSymbolAdded) + if err := _EOConfig.contract.UnpackLog(event, "OnSymbolAdded", log); err != nil { return err } event.Raw = log @@ -2162,18 +2140,18 @@ func (_Eoconfig *EoconfigFilterer) WatchOnSymbolAdded(opts *bind.WatchOpts, sink // ParseOnSymbolAdded is a log parse operation binding the contract event 0x17c9d771a4294ad678b91f00d84d6c838ce1f073b54b67bf7070320331667e99. // // Solidity: event OnSymbolAdded(uint16 id, bytes8 name) -func (_Eoconfig *EoconfigFilterer) ParseOnSymbolAdded(log types.Log) (*EoconfigOnSymbolAdded, error) { - event := new(EoconfigOnSymbolAdded) - if err := _Eoconfig.contract.UnpackLog(event, "OnSymbolAdded", log); err != nil { +func (_EOConfig *EOConfigFilterer) ParseOnSymbolAdded(log types.Log) (*EOConfigOnSymbolAdded, error) { + event := new(EOConfigOnSymbolAdded) + if err := _EOConfig.contract.UnpackLog(event, "OnSymbolAdded", log); err != nil { return nil, err } event.Raw = log return event, nil } -// EoconfigOnSymbolRemovedIterator is returned from FilterOnSymbolRemoved and is used to iterate over the raw logs and unpacked data for OnSymbolRemoved events raised by the Eoconfig contract. -type EoconfigOnSymbolRemovedIterator struct { - Event *EoconfigOnSymbolRemoved // Event containing the contract specifics and raw log +// EOConfigOnSymbolRemovedIterator is returned from FilterOnSymbolRemoved and is used to iterate over the raw logs and unpacked data for OnSymbolRemoved events raised by the EOConfig contract. +type EOConfigOnSymbolRemovedIterator struct { + Event *EOConfigOnSymbolRemoved // 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 @@ -2187,7 +2165,7 @@ type EoconfigOnSymbolRemovedIterator struct { // 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 *EoconfigOnSymbolRemovedIterator) Next() bool { +func (it *EOConfigOnSymbolRemovedIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -2196,7 +2174,7 @@ func (it *EoconfigOnSymbolRemovedIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(EoconfigOnSymbolRemoved) + it.Event = new(EOConfigOnSymbolRemoved) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -2211,7 +2189,7 @@ func (it *EoconfigOnSymbolRemovedIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(EoconfigOnSymbolRemoved) + it.Event = new(EOConfigOnSymbolRemoved) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -2227,19 +2205,19 @@ func (it *EoconfigOnSymbolRemovedIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *EoconfigOnSymbolRemovedIterator) Error() error { +func (it *EOConfigOnSymbolRemovedIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *EoconfigOnSymbolRemovedIterator) Close() error { +func (it *EOConfigOnSymbolRemovedIterator) Close() error { it.sub.Unsubscribe() return nil } -// EoconfigOnSymbolRemoved represents a OnSymbolRemoved event raised by the Eoconfig contract. -type EoconfigOnSymbolRemoved struct { +// EOConfigOnSymbolRemoved represents a OnSymbolRemoved event raised by the EOConfig contract. +type EOConfigOnSymbolRemoved struct { Id uint16 Raw types.Log // Blockchain specific contextual infos } @@ -2247,21 +2225,21 @@ type EoconfigOnSymbolRemoved struct { // FilterOnSymbolRemoved is a free log retrieval operation binding the contract event 0xaf1d0220552f1ffa37378a7942dffc37d3f6e51062806798e46e650aa95ae693. // // Solidity: event OnSymbolRemoved(uint16 id) -func (_Eoconfig *EoconfigFilterer) FilterOnSymbolRemoved(opts *bind.FilterOpts) (*EoconfigOnSymbolRemovedIterator, error) { +func (_EOConfig *EOConfigFilterer) FilterOnSymbolRemoved(opts *bind.FilterOpts) (*EOConfigOnSymbolRemovedIterator, error) { - logs, sub, err := _Eoconfig.contract.FilterLogs(opts, "OnSymbolRemoved") + logs, sub, err := _EOConfig.contract.FilterLogs(opts, "OnSymbolRemoved") if err != nil { return nil, err } - return &EoconfigOnSymbolRemovedIterator{contract: _Eoconfig.contract, event: "OnSymbolRemoved", logs: logs, sub: sub}, nil + return &EOConfigOnSymbolRemovedIterator{contract: _EOConfig.contract, event: "OnSymbolRemoved", logs: logs, sub: sub}, nil } // WatchOnSymbolRemoved is a free log subscription operation binding the contract event 0xaf1d0220552f1ffa37378a7942dffc37d3f6e51062806798e46e650aa95ae693. // // Solidity: event OnSymbolRemoved(uint16 id) -func (_Eoconfig *EoconfigFilterer) WatchOnSymbolRemoved(opts *bind.WatchOpts, sink chan<- *EoconfigOnSymbolRemoved) (event.Subscription, error) { +func (_EOConfig *EOConfigFilterer) WatchOnSymbolRemoved(opts *bind.WatchOpts, sink chan<- *EOConfigOnSymbolRemoved) (event.Subscription, error) { - logs, sub, err := _Eoconfig.contract.WatchLogs(opts, "OnSymbolRemoved") + logs, sub, err := _EOConfig.contract.WatchLogs(opts, "OnSymbolRemoved") if err != nil { return nil, err } @@ -2271,8 +2249,8 @@ func (_Eoconfig *EoconfigFilterer) WatchOnSymbolRemoved(opts *bind.WatchOpts, si select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(EoconfigOnSymbolRemoved) - if err := _Eoconfig.contract.UnpackLog(event, "OnSymbolRemoved", log); err != nil { + event := new(EOConfigOnSymbolRemoved) + if err := _EOConfig.contract.UnpackLog(event, "OnSymbolRemoved", log); err != nil { return err } event.Raw = log @@ -2296,18 +2274,18 @@ func (_Eoconfig *EoconfigFilterer) WatchOnSymbolRemoved(opts *bind.WatchOpts, si // ParseOnSymbolRemoved is a log parse operation binding the contract event 0xaf1d0220552f1ffa37378a7942dffc37d3f6e51062806798e46e650aa95ae693. // // Solidity: event OnSymbolRemoved(uint16 id) -func (_Eoconfig *EoconfigFilterer) ParseOnSymbolRemoved(log types.Log) (*EoconfigOnSymbolRemoved, error) { - event := new(EoconfigOnSymbolRemoved) - if err := _Eoconfig.contract.UnpackLog(event, "OnSymbolRemoved", log); err != nil { +func (_EOConfig *EOConfigFilterer) ParseOnSymbolRemoved(log types.Log) (*EOConfigOnSymbolRemoved, error) { + event := new(EOConfigOnSymbolRemoved) + if err := _EOConfig.contract.UnpackLog(event, "OnSymbolRemoved", log); err != nil { return nil, err } event.Raw = log return event, nil } -// EoconfigOnSymbolUpdatedIterator is returned from FilterOnSymbolUpdated and is used to iterate over the raw logs and unpacked data for OnSymbolUpdated events raised by the Eoconfig contract. -type EoconfigOnSymbolUpdatedIterator struct { - Event *EoconfigOnSymbolUpdated // Event containing the contract specifics and raw log +// EOConfigOnSymbolUpdatedIterator is returned from FilterOnSymbolUpdated and is used to iterate over the raw logs and unpacked data for OnSymbolUpdated events raised by the EOConfig contract. +type EOConfigOnSymbolUpdatedIterator struct { + Event *EOConfigOnSymbolUpdated // 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 @@ -2321,7 +2299,7 @@ type EoconfigOnSymbolUpdatedIterator struct { // 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 *EoconfigOnSymbolUpdatedIterator) Next() bool { +func (it *EOConfigOnSymbolUpdatedIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -2330,7 +2308,7 @@ func (it *EoconfigOnSymbolUpdatedIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(EoconfigOnSymbolUpdated) + it.Event = new(EOConfigOnSymbolUpdated) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -2345,7 +2323,7 @@ func (it *EoconfigOnSymbolUpdatedIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(EoconfigOnSymbolUpdated) + it.Event = new(EOConfigOnSymbolUpdated) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -2361,19 +2339,19 @@ func (it *EoconfigOnSymbolUpdatedIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *EoconfigOnSymbolUpdatedIterator) Error() error { +func (it *EOConfigOnSymbolUpdatedIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *EoconfigOnSymbolUpdatedIterator) Close() error { +func (it *EOConfigOnSymbolUpdatedIterator) Close() error { it.sub.Unsubscribe() return nil } -// EoconfigOnSymbolUpdated represents a OnSymbolUpdated event raised by the Eoconfig contract. -type EoconfigOnSymbolUpdated struct { +// EOConfigOnSymbolUpdated represents a OnSymbolUpdated event raised by the EOConfig contract. +type EOConfigOnSymbolUpdated struct { Id uint16 Name [8]byte Sources []uint16 @@ -2383,21 +2361,21 @@ type EoconfigOnSymbolUpdated struct { // FilterOnSymbolUpdated is a free log retrieval operation binding the contract event 0x05aefdf7098c008b0f258f7f5aceb8ed4e93f8faedba69832f087a0c3a09d1df. // // Solidity: event OnSymbolUpdated(uint16 id, bytes8 name, uint16[] sources) -func (_Eoconfig *EoconfigFilterer) FilterOnSymbolUpdated(opts *bind.FilterOpts) (*EoconfigOnSymbolUpdatedIterator, error) { +func (_EOConfig *EOConfigFilterer) FilterOnSymbolUpdated(opts *bind.FilterOpts) (*EOConfigOnSymbolUpdatedIterator, error) { - logs, sub, err := _Eoconfig.contract.FilterLogs(opts, "OnSymbolUpdated") + logs, sub, err := _EOConfig.contract.FilterLogs(opts, "OnSymbolUpdated") if err != nil { return nil, err } - return &EoconfigOnSymbolUpdatedIterator{contract: _Eoconfig.contract, event: "OnSymbolUpdated", logs: logs, sub: sub}, nil + return &EOConfigOnSymbolUpdatedIterator{contract: _EOConfig.contract, event: "OnSymbolUpdated", logs: logs, sub: sub}, nil } // WatchOnSymbolUpdated is a free log subscription operation binding the contract event 0x05aefdf7098c008b0f258f7f5aceb8ed4e93f8faedba69832f087a0c3a09d1df. // // Solidity: event OnSymbolUpdated(uint16 id, bytes8 name, uint16[] sources) -func (_Eoconfig *EoconfigFilterer) WatchOnSymbolUpdated(opts *bind.WatchOpts, sink chan<- *EoconfigOnSymbolUpdated) (event.Subscription, error) { +func (_EOConfig *EOConfigFilterer) WatchOnSymbolUpdated(opts *bind.WatchOpts, sink chan<- *EOConfigOnSymbolUpdated) (event.Subscription, error) { - logs, sub, err := _Eoconfig.contract.WatchLogs(opts, "OnSymbolUpdated") + logs, sub, err := _EOConfig.contract.WatchLogs(opts, "OnSymbolUpdated") if err != nil { return nil, err } @@ -2407,8 +2385,8 @@ func (_Eoconfig *EoconfigFilterer) WatchOnSymbolUpdated(opts *bind.WatchOpts, si select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(EoconfigOnSymbolUpdated) - if err := _Eoconfig.contract.UnpackLog(event, "OnSymbolUpdated", log); err != nil { + event := new(EOConfigOnSymbolUpdated) + if err := _EOConfig.contract.UnpackLog(event, "OnSymbolUpdated", log); err != nil { return err } event.Raw = log @@ -2432,18 +2410,18 @@ func (_Eoconfig *EoconfigFilterer) WatchOnSymbolUpdated(opts *bind.WatchOpts, si // ParseOnSymbolUpdated is a log parse operation binding the contract event 0x05aefdf7098c008b0f258f7f5aceb8ed4e93f8faedba69832f087a0c3a09d1df. // // Solidity: event OnSymbolUpdated(uint16 id, bytes8 name, uint16[] sources) -func (_Eoconfig *EoconfigFilterer) ParseOnSymbolUpdated(log types.Log) (*EoconfigOnSymbolUpdated, error) { - event := new(EoconfigOnSymbolUpdated) - if err := _Eoconfig.contract.UnpackLog(event, "OnSymbolUpdated", log); err != nil { +func (_EOConfig *EOConfigFilterer) ParseOnSymbolUpdated(log types.Log) (*EOConfigOnSymbolUpdated, error) { + event := new(EOConfigOnSymbolUpdated) + if err := _EOConfig.contract.UnpackLog(event, "OnSymbolUpdated", log); err != nil { return nil, err } event.Raw = log return event, nil } -// EoconfigOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the Eoconfig contract. -type EoconfigOwnershipTransferredIterator struct { - Event *EoconfigOwnershipTransferred // Event containing the contract specifics and raw log +// EOConfigOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the EOConfig contract. +type EOConfigOwnershipTransferredIterator struct { + Event *EOConfigOwnershipTransferred // 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 @@ -2457,7 +2435,7 @@ type EoconfigOwnershipTransferredIterator struct { // 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 *EoconfigOwnershipTransferredIterator) Next() bool { +func (it *EOConfigOwnershipTransferredIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -2466,7 +2444,7 @@ func (it *EoconfigOwnershipTransferredIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(EoconfigOwnershipTransferred) + it.Event = new(EOConfigOwnershipTransferred) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -2481,7 +2459,7 @@ func (it *EoconfigOwnershipTransferredIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(EoconfigOwnershipTransferred) + it.Event = new(EOConfigOwnershipTransferred) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -2497,19 +2475,19 @@ func (it *EoconfigOwnershipTransferredIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *EoconfigOwnershipTransferredIterator) Error() error { +func (it *EOConfigOwnershipTransferredIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *EoconfigOwnershipTransferredIterator) Close() error { +func (it *EOConfigOwnershipTransferredIterator) Close() error { it.sub.Unsubscribe() return nil } -// EoconfigOwnershipTransferred represents a OwnershipTransferred event raised by the Eoconfig contract. -type EoconfigOwnershipTransferred struct { +// EOConfigOwnershipTransferred represents a OwnershipTransferred event raised by the EOConfig contract. +type EOConfigOwnershipTransferred struct { PreviousOwner common.Address NewOwner common.Address Raw types.Log // Blockchain specific contextual infos @@ -2518,7 +2496,7 @@ type EoconfigOwnershipTransferred struct { // FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. // // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) -func (_Eoconfig *EoconfigFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*EoconfigOwnershipTransferredIterator, error) { +func (_EOConfig *EOConfigFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*EOConfigOwnershipTransferredIterator, error) { var previousOwnerRule []interface{} for _, previousOwnerItem := range previousOwner { @@ -2529,17 +2507,17 @@ func (_Eoconfig *EoconfigFilterer) FilterOwnershipTransferred(opts *bind.FilterO newOwnerRule = append(newOwnerRule, newOwnerItem) } - logs, sub, err := _Eoconfig.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) + logs, sub, err := _EOConfig.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) if err != nil { return nil, err } - return &EoconfigOwnershipTransferredIterator{contract: _Eoconfig.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil + return &EOConfigOwnershipTransferredIterator{contract: _EOConfig.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 (_Eoconfig *EoconfigFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *EoconfigOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) { +func (_EOConfig *EOConfigFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *EOConfigOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) { var previousOwnerRule []interface{} for _, previousOwnerItem := range previousOwner { @@ -2550,7 +2528,7 @@ func (_Eoconfig *EoconfigFilterer) WatchOwnershipTransferred(opts *bind.WatchOpt newOwnerRule = append(newOwnerRule, newOwnerItem) } - logs, sub, err := _Eoconfig.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) + logs, sub, err := _EOConfig.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) if err != nil { return nil, err } @@ -2560,8 +2538,8 @@ func (_Eoconfig *EoconfigFilterer) WatchOwnershipTransferred(opts *bind.WatchOpt select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(EoconfigOwnershipTransferred) - if err := _Eoconfig.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { + event := new(EOConfigOwnershipTransferred) + if err := _EOConfig.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { return err } event.Raw = log @@ -2585,9 +2563,9 @@ func (_Eoconfig *EoconfigFilterer) WatchOwnershipTransferred(opts *bind.WatchOpt // ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. // // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) -func (_Eoconfig *EoconfigFilterer) ParseOwnershipTransferred(log types.Log) (*EoconfigOwnershipTransferred, error) { - event := new(EoconfigOwnershipTransferred) - if err := _Eoconfig.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { +func (_EOConfig *EOConfigFilterer) ParseOwnershipTransferred(log types.Log) (*EOConfigOwnershipTransferred, error) { + event := new(EOConfigOwnershipTransferred) + if err := _EOConfig.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { return nil, err } event.Raw = log diff --git a/contracts/bindings/EORegistryCoordinator/binding.go b/contracts/bindings/EORegistryCoordinator/binding.go index 7c7564e..cee4264 100644 --- a/contracts/bindings/EORegistryCoordinator/binding.go +++ b/contracts/bindings/EORegistryCoordinator/binding.go @@ -41,350 +41,175 @@ type BN254G2Point struct { Y [2]*big.Int } -// IEOBLSApkRegistryPubkeyRegistrationParams is an auto generated low-level Go binding around an user-defined struct. -type IEOBLSApkRegistryPubkeyRegistrationParams struct { +// IBLSApkRegistryTypesPubkeyRegistrationParams is an auto generated low-level Go binding around an user-defined struct. +type IBLSApkRegistryTypesPubkeyRegistrationParams struct { PubkeyRegistrationSignature BN254G1Point - ChainValidatorSignature BN254G1Point PubkeyG1 BN254G1Point PubkeyG2 BN254G2Point } -// IEORegistryCoordinatorOperatorInfo is an auto generated low-level Go binding around an user-defined struct. -type IEORegistryCoordinatorOperatorInfo struct { +// IRegistryCoordinatorTypesRegistryCoordinatorParams is an auto generated low-level Go binding around an user-defined struct. +type IRegistryCoordinatorTypesRegistryCoordinatorParams struct { + ServiceManager common.Address + SlashingParams IRegistryCoordinatorTypesSlashingRegistryParams +} + +// IRegistryCoordinatorTypesSlashingRegistryParams is an auto generated low-level Go binding around an user-defined struct. +type IRegistryCoordinatorTypesSlashingRegistryParams struct { + StakeRegistry common.Address + BlsApkRegistry common.Address + IndexRegistry common.Address + SocketRegistry common.Address + AllocationManager common.Address + PauserRegistry common.Address +} + +// ISignatureUtilsMixinTypesSignatureWithSaltAndExpiry is an auto generated low-level Go binding around an user-defined struct. +type ISignatureUtilsMixinTypesSignatureWithSaltAndExpiry struct { + Signature []byte + Salt [32]byte + Expiry *big.Int +} + +// ISlashingRegistryCoordinatorTypesOperatorInfo is an auto generated low-level Go binding around an user-defined struct. +type ISlashingRegistryCoordinatorTypesOperatorInfo struct { OperatorId [32]byte Status uint8 } -// IEORegistryCoordinatorOperatorKickParam is an auto generated low-level Go binding around an user-defined struct. -type IEORegistryCoordinatorOperatorKickParam struct { +// ISlashingRegistryCoordinatorTypesOperatorKickParam is an auto generated low-level Go binding around an user-defined struct. +type ISlashingRegistryCoordinatorTypesOperatorKickParam struct { QuorumNumber uint8 Operator common.Address } -// IEORegistryCoordinatorOperatorSetParam is an auto generated low-level Go binding around an user-defined struct. -type IEORegistryCoordinatorOperatorSetParam struct { +// ISlashingRegistryCoordinatorTypesOperatorSetParam is an auto generated low-level Go binding around an user-defined struct. +type ISlashingRegistryCoordinatorTypesOperatorSetParam struct { MaxOperatorCount uint32 KickBIPsOfOperatorStake uint16 KickBIPsOfTotalStake uint16 } -// IEORegistryCoordinatorQuorumBitmapUpdate is an auto generated low-level Go binding around an user-defined struct. -type IEORegistryCoordinatorQuorumBitmapUpdate struct { +// ISlashingRegistryCoordinatorTypesQuorumBitmapUpdate is an auto generated low-level Go binding around an user-defined struct. +type ISlashingRegistryCoordinatorTypesQuorumBitmapUpdate struct { UpdateBlockNumber uint32 NextUpdateBlockNumber uint32 QuorumBitmap *big.Int } -// IEOStakeRegistryStrategyParams is an auto generated low-level Go binding around an user-defined struct. -type IEOStakeRegistryStrategyParams struct { +// IStakeRegistryTypesStrategyParams is an auto generated low-level Go binding around an user-defined struct. +type IStakeRegistryTypesStrategyParams struct { Strategy common.Address Multiplier *big.Int } -// ISignatureUtilsSignatureWithSaltAndExpiry is an auto generated low-level Go binding around an user-defined struct. -type ISignatureUtilsSignatureWithSaltAndExpiry struct { - Signature []byte - Salt [32]byte - Expiry *big.Int -} - -// ContractEORegistryCoordinatorMetaData contains all meta data concerning the ContractEORegistryCoordinator contract. -var ContractEORegistryCoordinatorMetaData = &bind.MetaData{ - ABI: "[{\"type\":\"constructor\",\"inputs\":[{\"name\":\"_serviceManager\",\"type\":\"address\",\"internalType\":\"contractIServiceManager\"},{\"name\":\"_stakeRegistry\",\"type\":\"address\",\"internalType\":\"contractIEOStakeRegistry\"},{\"name\":\"_blsApkRegistry\",\"type\":\"address\",\"internalType\":\"contractIEOBLSApkRegistry\"},{\"name\":\"_indexRegistry\",\"type\":\"address\",\"internalType\":\"contractIEOIndexRegistry\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"EOChainManager\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIEOChainManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"OPERATOR_CHURN_APPROVAL_TYPEHASH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"PUBKEY_REGISTRATION_TYPEHASH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"blsApkRegistry\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIEOBLSApkRegistry\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"calculateOperatorChurnApprovalDigestHash\",\"inputs\":[{\"name\":\"registeringOperator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"registeringOperatorId\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"operatorKickParams\",\"type\":\"tuple[]\",\"internalType\":\"structIEORegistryCoordinator.OperatorKickParam[]\",\"components\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"name\":\"salt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"churnApprover\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"createQuorum\",\"inputs\":[{\"name\":\"operatorSetParams\",\"type\":\"tuple\",\"internalType\":\"structIEORegistryCoordinator.OperatorSetParam\",\"components\":[{\"name\":\"maxOperatorCount\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"kickBIPsOfOperatorStake\",\"type\":\"uint16\",\"internalType\":\"uint16\"},{\"name\":\"kickBIPsOfTotalStake\",\"type\":\"uint16\",\"internalType\":\"uint16\"}]},{\"name\":\"minimumStake\",\"type\":\"uint96\",\"internalType\":\"uint96\"},{\"name\":\"strategyParams\",\"type\":\"tuple[]\",\"internalType\":\"structIEOStakeRegistry.StrategyParams[]\",\"components\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"multiplier\",\"type\":\"uint96\",\"internalType\":\"uint96\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"deregisterOperator\",\"inputs\":[{\"name\":\"quorumNumbers\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"ejectOperator\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"quorumNumbers\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"ejector\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getCurrentQuorumBitmap\",\"inputs\":[{\"name\":\"operatorId\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint192\",\"internalType\":\"uint192\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getOperator\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structIEORegistryCoordinator.OperatorInfo\",\"components\":[{\"name\":\"operatorId\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"status\",\"type\":\"uint8\",\"internalType\":\"enumIEORegistryCoordinator.OperatorStatus\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getOperatorFromId\",\"inputs\":[{\"name\":\"operatorId\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getOperatorId\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getOperatorSetParams\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structIEORegistryCoordinator.OperatorSetParam\",\"components\":[{\"name\":\"maxOperatorCount\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"kickBIPsOfOperatorStake\",\"type\":\"uint16\",\"internalType\":\"uint16\"},{\"name\":\"kickBIPsOfTotalStake\",\"type\":\"uint16\",\"internalType\":\"uint16\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getOperatorStatus\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint8\",\"internalType\":\"enumIEORegistryCoordinator.OperatorStatus\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getQuorumBitmapAtBlockNumberByIndex\",\"inputs\":[{\"name\":\"operatorId\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"blockNumber\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"index\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint192\",\"internalType\":\"uint192\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getQuorumBitmapHistoryLength\",\"inputs\":[{\"name\":\"operatorId\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getQuorumBitmapIndicesAtBlockNumber\",\"inputs\":[{\"name\":\"blockNumber\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"operatorIds\",\"type\":\"bytes32[]\",\"internalType\":\"bytes32[]\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint32[]\",\"internalType\":\"uint32[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getQuorumBitmapUpdateByIndex\",\"inputs\":[{\"name\":\"operatorId\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"index\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structIEORegistryCoordinator.QuorumBitmapUpdate\",\"components\":[{\"name\":\"updateBlockNumber\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"nextUpdateBlockNumber\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"quorumBitmap\",\"type\":\"uint192\",\"internalType\":\"uint192\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"indexRegistry\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIEOIndexRegistry\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[{\"name\":\"_initialOwner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"_churnApprover\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"_ejector\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"_pauserRegistry\",\"type\":\"address\",\"internalType\":\"contractIPauserRegistry\"},{\"name\":\"_initialPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"_operatorSetParams\",\"type\":\"tuple[]\",\"internalType\":\"structIEORegistryCoordinator.OperatorSetParam[]\",\"components\":[{\"name\":\"maxOperatorCount\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"kickBIPsOfOperatorStake\",\"type\":\"uint16\",\"internalType\":\"uint16\"},{\"name\":\"kickBIPsOfTotalStake\",\"type\":\"uint16\",\"internalType\":\"uint16\"}]},{\"name\":\"_minimumStakes\",\"type\":\"uint96[]\",\"internalType\":\"uint96[]\"},{\"name\":\"_strategyParams\",\"type\":\"tuple[][]\",\"internalType\":\"structIEOStakeRegistry.StrategyParams[][]\",\"components\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"multiplier\",\"type\":\"uint96\",\"internalType\":\"uint96\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"isChurnApproverSaltUsed\",\"inputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"numRegistries\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"owner\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pause\",\"inputs\":[{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"pauseAll\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[{\"name\":\"index\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pauserRegistry\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIPauserRegistry\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pubkeyRegistrationMessageHash\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structBN254.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"quorumCount\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"quorumUpdateBlockNumber\",\"inputs\":[{\"name\":\"\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"registerOperator\",\"inputs\":[{\"name\":\"quorumNumbers\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"params\",\"type\":\"tuple\",\"internalType\":\"structIEOBLSApkRegistry.PubkeyRegistrationParams\",\"components\":[{\"name\":\"pubkeyRegistrationSignature\",\"type\":\"tuple\",\"internalType\":\"structBN254.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"chainValidatorSignature\",\"type\":\"tuple\",\"internalType\":\"structBN254.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"pubkeyG1\",\"type\":\"tuple\",\"internalType\":\"structBN254.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"pubkeyG2\",\"type\":\"tuple\",\"internalType\":\"structBN254.G2Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256[2]\",\"internalType\":\"uint256[2]\"},{\"name\":\"Y\",\"type\":\"uint256[2]\",\"internalType\":\"uint256[2]\"}]}]},{\"name\":\"operatorSignature\",\"type\":\"tuple\",\"internalType\":\"structISignatureUtils.SignatureWithSaltAndExpiry\",\"components\":[{\"name\":\"signature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"salt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"registerOperatorWithChurn\",\"inputs\":[{\"name\":\"quorumNumbers\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"params\",\"type\":\"tuple\",\"internalType\":\"structIEOBLSApkRegistry.PubkeyRegistrationParams\",\"components\":[{\"name\":\"pubkeyRegistrationSignature\",\"type\":\"tuple\",\"internalType\":\"structBN254.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"chainValidatorSignature\",\"type\":\"tuple\",\"internalType\":\"structBN254.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"pubkeyG1\",\"type\":\"tuple\",\"internalType\":\"structBN254.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"pubkeyG2\",\"type\":\"tuple\",\"internalType\":\"structBN254.G2Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256[2]\",\"internalType\":\"uint256[2]\"},{\"name\":\"Y\",\"type\":\"uint256[2]\",\"internalType\":\"uint256[2]\"}]}]},{\"name\":\"operatorKickParams\",\"type\":\"tuple[]\",\"internalType\":\"structIEORegistryCoordinator.OperatorKickParam[]\",\"components\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"name\":\"churnApproverSignature\",\"type\":\"tuple\",\"internalType\":\"structISignatureUtils.SignatureWithSaltAndExpiry\",\"components\":[{\"name\":\"signature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"salt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"operatorSignature\",\"type\":\"tuple\",\"internalType\":\"structISignatureUtils.SignatureWithSaltAndExpiry\",\"components\":[{\"name\":\"signature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"salt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"registries\",\"inputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"renounceOwnership\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"serviceManager\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIServiceManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"setChurnApprover\",\"inputs\":[{\"name\":\"_churnApprover\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setEOChainManager\",\"inputs\":[{\"name\":\"_EOChainManager\",\"type\":\"address\",\"internalType\":\"contractIEOChainManager\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setEjector\",\"inputs\":[{\"name\":\"_ejector\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setOperatorSetParams\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"operatorSetParams\",\"type\":\"tuple\",\"internalType\":\"structIEORegistryCoordinator.OperatorSetParam\",\"components\":[{\"name\":\"maxOperatorCount\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"kickBIPsOfOperatorStake\",\"type\":\"uint16\",\"internalType\":\"uint16\"},{\"name\":\"kickBIPsOfTotalStake\",\"type\":\"uint16\",\"internalType\":\"uint16\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setPauserRegistry\",\"inputs\":[{\"name\":\"newPauserRegistry\",\"type\":\"address\",\"internalType\":\"contractIPauserRegistry\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"stakeRegistry\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIEOStakeRegistry\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"transferOwnership\",\"inputs\":[{\"name\":\"newOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"unpause\",\"inputs\":[{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"updateOperators\",\"inputs\":[{\"name\":\"operators\",\"type\":\"address[]\",\"internalType\":\"address[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"updateOperatorsForQuorum\",\"inputs\":[{\"name\":\"operatorsPerQuorum\",\"type\":\"address[][]\",\"internalType\":\"address[][]\"},{\"name\":\"quorumNumbers\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"ChurnApproverUpdated\",\"inputs\":[{\"name\":\"prevChurnApprover\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"newChurnApprover\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"EjectorUpdated\",\"inputs\":[{\"name\":\"prevEjector\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"newEjector\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Initialized\",\"inputs\":[{\"name\":\"version\",\"type\":\"uint8\",\"indexed\":false,\"internalType\":\"uint8\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorDeregistered\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"operatorId\",\"type\":\"bytes32\",\"indexed\":true,\"internalType\":\"bytes32\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorRegistered\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"operatorId\",\"type\":\"bytes32\",\"indexed\":true,\"internalType\":\"bytes32\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorSetParamsUpdated\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"indexed\":true,\"internalType\":\"uint8\"},{\"name\":\"operatorSetParams\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structIEORegistryCoordinator.OperatorSetParam\",\"components\":[{\"name\":\"maxOperatorCount\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"kickBIPsOfOperatorStake\",\"type\":\"uint16\",\"internalType\":\"uint16\"},{\"name\":\"kickBIPsOfTotalStake\",\"type\":\"uint16\",\"internalType\":\"uint16\"}]}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OwnershipTransferred\",\"inputs\":[{\"name\":\"previousOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Paused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"PauserRegistrySet\",\"inputs\":[{\"name\":\"pauserRegistry\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIPauserRegistry\"},{\"name\":\"newPauserRegistry\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIPauserRegistry\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"QuorumBlockNumberUpdated\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"indexed\":true,\"internalType\":\"uint8\"},{\"name\":\"blocknumber\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Unpaused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false}]", - Bin: "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", -} - -// ContractEORegistryCoordinatorABI is the input ABI used to generate the binding from. -// Deprecated: Use ContractEORegistryCoordinatorMetaData.ABI instead. -var ContractEORegistryCoordinatorABI = ContractEORegistryCoordinatorMetaData.ABI - -// ContractEORegistryCoordinatorBin is the compiled bytecode used for deploying new contracts. -// Deprecated: Use ContractEORegistryCoordinatorMetaData.Bin instead. -var ContractEORegistryCoordinatorBin = ContractEORegistryCoordinatorMetaData.Bin - -// DeployContractEORegistryCoordinator deploys a new Ethereum contract, binding an instance of ContractEORegistryCoordinator to it. -func DeployContractEORegistryCoordinator(auth *bind.TransactOpts, backend bind.ContractBackend, _serviceManager common.Address, _stakeRegistry common.Address, _blsApkRegistry common.Address, _indexRegistry common.Address) (common.Address, *types.Transaction, *ContractEORegistryCoordinator, error) { - parsed, err := ContractEORegistryCoordinatorMetaData.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(ContractEORegistryCoordinatorBin), backend, _serviceManager, _stakeRegistry, _blsApkRegistry, _indexRegistry) - if err != nil { - return common.Address{}, nil, nil, err - } - return address, tx, &ContractEORegistryCoordinator{ContractEORegistryCoordinatorCaller: ContractEORegistryCoordinatorCaller{contract: contract}, ContractEORegistryCoordinatorTransactor: ContractEORegistryCoordinatorTransactor{contract: contract}, ContractEORegistryCoordinatorFilterer: ContractEORegistryCoordinatorFilterer{contract: contract}}, nil -} - -// ContractEORegistryCoordinatorMethods is an auto generated interface around an Ethereum contract. -type ContractEORegistryCoordinatorMethods interface { - ContractEORegistryCoordinatorCalls - ContractEORegistryCoordinatorTransacts - ContractEORegistryCoordinatorFilters -} - -// ContractEORegistryCoordinatorCalls is an auto generated interface that defines the call methods available for an Ethereum contract. -type ContractEORegistryCoordinatorCalls interface { - EOChainManager(opts *bind.CallOpts) (common.Address, error) - - OPERATORCHURNAPPROVALTYPEHASH(opts *bind.CallOpts) ([32]byte, error) - - PUBKEYREGISTRATIONTYPEHASH(opts *bind.CallOpts) ([32]byte, error) - - BlsApkRegistry(opts *bind.CallOpts) (common.Address, error) - - CalculateOperatorChurnApprovalDigestHash(opts *bind.CallOpts, registeringOperator common.Address, registeringOperatorId [32]byte, operatorKickParams []IEORegistryCoordinatorOperatorKickParam, salt [32]byte, expiry *big.Int) ([32]byte, error) - - ChurnApprover(opts *bind.CallOpts) (common.Address, error) - - Ejector(opts *bind.CallOpts) (common.Address, error) - - GetCurrentQuorumBitmap(opts *bind.CallOpts, operatorId [32]byte) (*big.Int, error) - - GetOperator(opts *bind.CallOpts, operator common.Address) (IEORegistryCoordinatorOperatorInfo, error) - - GetOperatorFromId(opts *bind.CallOpts, operatorId [32]byte) (common.Address, error) - - GetOperatorId(opts *bind.CallOpts, operator common.Address) ([32]byte, error) - - GetOperatorSetParams(opts *bind.CallOpts, quorumNumber uint8) (IEORegistryCoordinatorOperatorSetParam, error) - - GetOperatorStatus(opts *bind.CallOpts, operator common.Address) (uint8, error) - - GetQuorumBitmapAtBlockNumberByIndex(opts *bind.CallOpts, operatorId [32]byte, blockNumber uint32, index *big.Int) (*big.Int, error) - - GetQuorumBitmapHistoryLength(opts *bind.CallOpts, operatorId [32]byte) (*big.Int, error) - - GetQuorumBitmapIndicesAtBlockNumber(opts *bind.CallOpts, blockNumber uint32, operatorIds [][32]byte) ([]uint32, error) - - GetQuorumBitmapUpdateByIndex(opts *bind.CallOpts, operatorId [32]byte, index *big.Int) (IEORegistryCoordinatorQuorumBitmapUpdate, error) - - IndexRegistry(opts *bind.CallOpts) (common.Address, error) - - IsChurnApproverSaltUsed(opts *bind.CallOpts, arg0 [32]byte) (bool, error) - - NumRegistries(opts *bind.CallOpts) (*big.Int, error) - - Owner(opts *bind.CallOpts) (common.Address, error) - - Paused(opts *bind.CallOpts, index uint8) (bool, error) - - Paused0(opts *bind.CallOpts) (*big.Int, error) - - PauserRegistry(opts *bind.CallOpts) (common.Address, error) - - PubkeyRegistrationMessageHash(opts *bind.CallOpts, operator common.Address) (BN254G1Point, error) - - QuorumCount(opts *bind.CallOpts) (uint8, error) - - QuorumUpdateBlockNumber(opts *bind.CallOpts, arg0 uint8) (*big.Int, error) - - Registries(opts *bind.CallOpts, arg0 *big.Int) (common.Address, error) - - ServiceManager(opts *bind.CallOpts) (common.Address, error) - - StakeRegistry(opts *bind.CallOpts) (common.Address, error) -} - -// ContractEORegistryCoordinatorTransacts is an auto generated interface that defines the transact methods available for an Ethereum contract. -type ContractEORegistryCoordinatorTransacts interface { - CreateQuorum(opts *bind.TransactOpts, operatorSetParams IEORegistryCoordinatorOperatorSetParam, minimumStake *big.Int, strategyParams []IEOStakeRegistryStrategyParams) (*types.Transaction, error) - - DeregisterOperator(opts *bind.TransactOpts, quorumNumbers []byte) (*types.Transaction, error) - - EjectOperator(opts *bind.TransactOpts, operator common.Address, quorumNumbers []byte) (*types.Transaction, error) - - Initialize(opts *bind.TransactOpts, _initialOwner common.Address, _churnApprover common.Address, _ejector common.Address, _pauserRegistry common.Address, _initialPausedStatus *big.Int, _operatorSetParams []IEORegistryCoordinatorOperatorSetParam, _minimumStakes []*big.Int, _strategyParams [][]IEOStakeRegistryStrategyParams) (*types.Transaction, error) - - Pause(opts *bind.TransactOpts, newPausedStatus *big.Int) (*types.Transaction, error) - - PauseAll(opts *bind.TransactOpts) (*types.Transaction, error) - - RegisterOperator(opts *bind.TransactOpts, quorumNumbers []byte, params IEOBLSApkRegistryPubkeyRegistrationParams, operatorSignature ISignatureUtilsSignatureWithSaltAndExpiry) (*types.Transaction, error) - - RegisterOperatorWithChurn(opts *bind.TransactOpts, quorumNumbers []byte, params IEOBLSApkRegistryPubkeyRegistrationParams, operatorKickParams []IEORegistryCoordinatorOperatorKickParam, churnApproverSignature ISignatureUtilsSignatureWithSaltAndExpiry, operatorSignature ISignatureUtilsSignatureWithSaltAndExpiry) (*types.Transaction, error) - - RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) - - SetChurnApprover(opts *bind.TransactOpts, _churnApprover common.Address) (*types.Transaction, error) - - SetEOChainManager(opts *bind.TransactOpts, _EOChainManager common.Address) (*types.Transaction, error) - - SetEjector(opts *bind.TransactOpts, _ejector common.Address) (*types.Transaction, error) - - SetOperatorSetParams(opts *bind.TransactOpts, quorumNumber uint8, operatorSetParams IEORegistryCoordinatorOperatorSetParam) (*types.Transaction, error) - - SetPauserRegistry(opts *bind.TransactOpts, newPauserRegistry common.Address) (*types.Transaction, error) - - TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) - - Unpause(opts *bind.TransactOpts, newPausedStatus *big.Int) (*types.Transaction, error) - - UpdateOperators(opts *bind.TransactOpts, operators []common.Address) (*types.Transaction, error) - - UpdateOperatorsForQuorum(opts *bind.TransactOpts, operatorsPerQuorum [][]common.Address, quorumNumbers []byte) (*types.Transaction, error) +// EORegistryCoordinatorMetaData contains all meta data concerning the EORegistryCoordinator contract. +var EORegistryCoordinatorMetaData = &bind.MetaData{ + ABI: "[{\"type\":\"constructor\",\"inputs\":[{\"name\":\"params\",\"type\":\"tuple\",\"internalType\":\"structIRegistryCoordinatorTypes.RegistryCoordinatorParams\",\"components\":[{\"name\":\"serviceManager\",\"type\":\"address\",\"internalType\":\"contractIServiceManager\"},{\"name\":\"slashingParams\",\"type\":\"tuple\",\"internalType\":\"structIRegistryCoordinatorTypes.SlashingRegistryParams\",\"components\":[{\"name\":\"stakeRegistry\",\"type\":\"address\",\"internalType\":\"contractIStakeRegistry\"},{\"name\":\"blsApkRegistry\",\"type\":\"address\",\"internalType\":\"contractIBLSApkRegistry\"},{\"name\":\"indexRegistry\",\"type\":\"address\",\"internalType\":\"contractIIndexRegistry\"},{\"name\":\"socketRegistry\",\"type\":\"address\",\"internalType\":\"contractISocketRegistry\"},{\"name\":\"allocationManager\",\"type\":\"address\",\"internalType\":\"contractIAllocationManager\"},{\"name\":\"pauserRegistry\",\"type\":\"address\",\"internalType\":\"contractIPauserRegistry\"}]}]}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"OPERATOR_CHURN_APPROVAL_TYPEHASH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"PUBKEY_REGISTRATION_TYPEHASH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"allocationManager\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIAllocationManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"avs\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"blsApkRegistry\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIBLSApkRegistry\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"calculateOperatorChurnApprovalDigestHash\",\"inputs\":[{\"name\":\"registeringOperator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"registeringOperatorId\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"operatorKickParams\",\"type\":\"tuple[]\",\"internalType\":\"structISlashingRegistryCoordinatorTypes.OperatorKickParam[]\",\"components\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"name\":\"salt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"calculatePubkeyRegistrationMessageHash\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"chainManager\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIEOChainManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"churnApprover\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"createSlashableStakeQuorum\",\"inputs\":[{\"name\":\"operatorSetParams\",\"type\":\"tuple\",\"internalType\":\"structISlashingRegistryCoordinatorTypes.OperatorSetParam\",\"components\":[{\"name\":\"maxOperatorCount\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"kickBIPsOfOperatorStake\",\"type\":\"uint16\",\"internalType\":\"uint16\"},{\"name\":\"kickBIPsOfTotalStake\",\"type\":\"uint16\",\"internalType\":\"uint16\"}]},{\"name\":\"minimumStake\",\"type\":\"uint96\",\"internalType\":\"uint96\"},{\"name\":\"strategyParams\",\"type\":\"tuple[]\",\"internalType\":\"structIStakeRegistryTypes.StrategyParams[]\",\"components\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"multiplier\",\"type\":\"uint96\",\"internalType\":\"uint96\"}]},{\"name\":\"lookAheadPeriod\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"createTotalDelegatedStakeQuorum\",\"inputs\":[{\"name\":\"operatorSetParams\",\"type\":\"tuple\",\"internalType\":\"structISlashingRegistryCoordinatorTypes.OperatorSetParam\",\"components\":[{\"name\":\"maxOperatorCount\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"kickBIPsOfOperatorStake\",\"type\":\"uint16\",\"internalType\":\"uint16\"},{\"name\":\"kickBIPsOfTotalStake\",\"type\":\"uint16\",\"internalType\":\"uint16\"}]},{\"name\":\"minimumStake\",\"type\":\"uint96\",\"internalType\":\"uint96\"},{\"name\":\"strategyParams\",\"type\":\"tuple[]\",\"internalType\":\"structIStakeRegistryTypes.StrategyParams[]\",\"components\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"multiplier\",\"type\":\"uint96\",\"internalType\":\"uint96\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"deregisterOperator\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSetIds\",\"type\":\"uint32[]\",\"internalType\":\"uint32[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"deregisterOperator\",\"inputs\":[{\"name\":\"quorumNumbers\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"disableM2QuorumRegistration\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"domainSeparator\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"eip712Domain\",\"inputs\":[],\"outputs\":[{\"name\":\"fields\",\"type\":\"bytes1\",\"internalType\":\"bytes1\"},{\"name\":\"name\",\"type\":\"string\",\"internalType\":\"string\"},{\"name\":\"version\",\"type\":\"string\",\"internalType\":\"string\"},{\"name\":\"chainId\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"verifyingContract\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"salt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"extensions\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"ejectOperator\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"quorumNumbers\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"ejectionCooldown\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"ejector\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getCurrentQuorumBitmap\",\"inputs\":[{\"name\":\"operatorId\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint192\",\"internalType\":\"uint192\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getOperator\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structISlashingRegistryCoordinatorTypes.OperatorInfo\",\"components\":[{\"name\":\"operatorId\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"status\",\"type\":\"uint8\",\"internalType\":\"enumISlashingRegistryCoordinatorTypes.OperatorStatus\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getOperatorFromId\",\"inputs\":[{\"name\":\"operatorId\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getOperatorId\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getOperatorSetParams\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structISlashingRegistryCoordinatorTypes.OperatorSetParam\",\"components\":[{\"name\":\"maxOperatorCount\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"kickBIPsOfOperatorStake\",\"type\":\"uint16\",\"internalType\":\"uint16\"},{\"name\":\"kickBIPsOfTotalStake\",\"type\":\"uint16\",\"internalType\":\"uint16\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getOperatorStatus\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint8\",\"internalType\":\"enumISlashingRegistryCoordinatorTypes.OperatorStatus\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getQuorumBitmapAtBlockNumberByIndex\",\"inputs\":[{\"name\":\"operatorId\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"blockNumber\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"index\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint192\",\"internalType\":\"uint192\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getQuorumBitmapHistoryLength\",\"inputs\":[{\"name\":\"operatorId\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getQuorumBitmapIndicesAtBlockNumber\",\"inputs\":[{\"name\":\"blockNumber\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"operatorIds\",\"type\":\"bytes32[]\",\"internalType\":\"bytes32[]\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint32[]\",\"internalType\":\"uint32[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getQuorumBitmapUpdateByIndex\",\"inputs\":[{\"name\":\"operatorId\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"index\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structISlashingRegistryCoordinatorTypes.QuorumBitmapUpdate\",\"components\":[{\"name\":\"updateBlockNumber\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"nextUpdateBlockNumber\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"quorumBitmap\",\"type\":\"uint192\",\"internalType\":\"uint192\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"indexRegistry\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIIndexRegistry\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[{\"name\":\"initialOwner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"churnApprover\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"ejector\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"initialPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"isChurnApproverSaltUsed\",\"inputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"isM2Quorum\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"isM2QuorumRegistrationDisabled\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"lastEjectionTimestamp\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"m2QuorumBitmap\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"operatorSetsEnabled\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"owner\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pause\",\"inputs\":[{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"pauseAll\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[{\"name\":\"index\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pauserRegistry\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIPauserRegistry\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pubkeyRegistrationMessageHash\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structBN254.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"quorumCount\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"quorumUpdateBlockNumber\",\"inputs\":[{\"name\":\"\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"registerOperator\",\"inputs\":[{\"name\":\"quorumNumbers\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"socket\",\"type\":\"string\",\"internalType\":\"string\"},{\"name\":\"params\",\"type\":\"tuple\",\"internalType\":\"structIBLSApkRegistryTypes.PubkeyRegistrationParams\",\"components\":[{\"name\":\"pubkeyRegistrationSignature\",\"type\":\"tuple\",\"internalType\":\"structBN254.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"pubkeyG1\",\"type\":\"tuple\",\"internalType\":\"structBN254.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"pubkeyG2\",\"type\":\"tuple\",\"internalType\":\"structBN254.G2Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256[2]\",\"internalType\":\"uint256[2]\"},{\"name\":\"Y\",\"type\":\"uint256[2]\",\"internalType\":\"uint256[2]\"}]}]},{\"name\":\"operatorSignature\",\"type\":\"tuple\",\"internalType\":\"structISignatureUtilsMixinTypes.SignatureWithSaltAndExpiry\",\"components\":[{\"name\":\"signature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"salt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"registerOperator\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSetIds\",\"type\":\"uint32[]\",\"internalType\":\"uint32[]\"},{\"name\":\"data\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"registerOperatorWithChurn\",\"inputs\":[{\"name\":\"quorumNumbers\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"socket\",\"type\":\"string\",\"internalType\":\"string\"},{\"name\":\"params\",\"type\":\"tuple\",\"internalType\":\"structIBLSApkRegistryTypes.PubkeyRegistrationParams\",\"components\":[{\"name\":\"pubkeyRegistrationSignature\",\"type\":\"tuple\",\"internalType\":\"structBN254.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"pubkeyG1\",\"type\":\"tuple\",\"internalType\":\"structBN254.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"pubkeyG2\",\"type\":\"tuple\",\"internalType\":\"structBN254.G2Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256[2]\",\"internalType\":\"uint256[2]\"},{\"name\":\"Y\",\"type\":\"uint256[2]\",\"internalType\":\"uint256[2]\"}]}]},{\"name\":\"operatorKickParams\",\"type\":\"tuple[]\",\"internalType\":\"structISlashingRegistryCoordinatorTypes.OperatorKickParam[]\",\"components\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"name\":\"churnApproverSignature\",\"type\":\"tuple\",\"internalType\":\"structISignatureUtilsMixinTypes.SignatureWithSaltAndExpiry\",\"components\":[{\"name\":\"signature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"salt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"operatorSignature\",\"type\":\"tuple\",\"internalType\":\"structISignatureUtilsMixinTypes.SignatureWithSaltAndExpiry\",\"components\":[{\"name\":\"signature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"salt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"renounceOwnership\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"serviceManager\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIServiceManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"setAVS\",\"inputs\":[{\"name\":\"_avs\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setChainManager\",\"inputs\":[{\"name\":\"newChainManager\",\"type\":\"address\",\"internalType\":\"contractIEOChainManager\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setChurnApprover\",\"inputs\":[{\"name\":\"_churnApprover\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setEjectionCooldown\",\"inputs\":[{\"name\":\"_ejectionCooldown\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setEjector\",\"inputs\":[{\"name\":\"_ejector\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setOperatorSetParams\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"operatorSetParams\",\"type\":\"tuple\",\"internalType\":\"structISlashingRegistryCoordinatorTypes.OperatorSetParam\",\"components\":[{\"name\":\"maxOperatorCount\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"kickBIPsOfOperatorStake\",\"type\":\"uint16\",\"internalType\":\"uint16\"},{\"name\":\"kickBIPsOfTotalStake\",\"type\":\"uint16\",\"internalType\":\"uint16\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"socketRegistry\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractISocketRegistry\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"stakeRegistry\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIStakeRegistry\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"supportsAVS\",\"inputs\":[{\"name\":\"_avs\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"transferOwnership\",\"inputs\":[{\"name\":\"newOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"unpause\",\"inputs\":[{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"updateOperators\",\"inputs\":[{\"name\":\"operators\",\"type\":\"address[]\",\"internalType\":\"address[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"updateOperatorsForQuorum\",\"inputs\":[{\"name\":\"operatorsPerQuorum\",\"type\":\"address[][]\",\"internalType\":\"address[][]\"},{\"name\":\"quorumNumbers\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"updateSocket\",\"inputs\":[{\"name\":\"socket\",\"type\":\"string\",\"internalType\":\"string\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"version\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"string\",\"internalType\":\"string\"}],\"stateMutability\":\"view\"},{\"type\":\"event\",\"name\":\"AVSUpdated\",\"inputs\":[{\"name\":\"prevAVS\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"newAVS\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"ChainManagerUpdated\",\"inputs\":[{\"name\":\"prevChainManager\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"newChainManager\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"ChurnApproverUpdated\",\"inputs\":[{\"name\":\"prevChurnApprover\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"newChurnApprover\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"EIP712DomainChanged\",\"inputs\":[],\"anonymous\":false},{\"type\":\"event\",\"name\":\"EjectionCooldownUpdated\",\"inputs\":[{\"name\":\"prevEjectionCooldown\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"},{\"name\":\"newEjectionCooldown\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"EjectorUpdated\",\"inputs\":[{\"name\":\"prevEjector\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"newEjector\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Initialized\",\"inputs\":[{\"name\":\"version\",\"type\":\"uint8\",\"indexed\":false,\"internalType\":\"uint8\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"M2QuorumRegistrationDisabled\",\"inputs\":[],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorDeregistered\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"operatorId\",\"type\":\"bytes32\",\"indexed\":true,\"internalType\":\"bytes32\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorRegistered\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"operatorId\",\"type\":\"bytes32\",\"indexed\":true,\"internalType\":\"bytes32\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorSetParamsUpdated\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"indexed\":true,\"internalType\":\"uint8\"},{\"name\":\"operatorSetParams\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structISlashingRegistryCoordinatorTypes.OperatorSetParam\",\"components\":[{\"name\":\"maxOperatorCount\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"kickBIPsOfOperatorStake\",\"type\":\"uint16\",\"internalType\":\"uint16\"},{\"name\":\"kickBIPsOfTotalStake\",\"type\":\"uint16\",\"internalType\":\"uint16\"}]}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorSetsEnabled\",\"inputs\":[],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorSocketUpdate\",\"inputs\":[{\"name\":\"operatorId\",\"type\":\"bytes32\",\"indexed\":true,\"internalType\":\"bytes32\"},{\"name\":\"socket\",\"type\":\"string\",\"indexed\":false,\"internalType\":\"string\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OwnershipTransferred\",\"inputs\":[{\"name\":\"previousOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Paused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"QuorumBlockNumberUpdated\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"indexed\":true,\"internalType\":\"uint8\"},{\"name\":\"blocknumber\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"QuorumCreated\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"indexed\":true,\"internalType\":\"uint8\"},{\"name\":\"operatorSetParams\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structISlashingRegistryCoordinatorTypes.OperatorSetParam\",\"components\":[{\"name\":\"maxOperatorCount\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"kickBIPsOfOperatorStake\",\"type\":\"uint16\",\"internalType\":\"uint16\"},{\"name\":\"kickBIPsOfTotalStake\",\"type\":\"uint16\",\"internalType\":\"uint16\"}]},{\"name\":\"minimumStake\",\"type\":\"uint96\",\"indexed\":false,\"internalType\":\"uint96\"},{\"name\":\"strategyParams\",\"type\":\"tuple[]\",\"indexed\":false,\"internalType\":\"structIStakeRegistryTypes.StrategyParams[]\",\"components\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"multiplier\",\"type\":\"uint96\",\"internalType\":\"uint96\"}]},{\"name\":\"stakeType\",\"type\":\"uint8\",\"indexed\":false,\"internalType\":\"enumIStakeRegistryTypes.StakeType\"},{\"name\":\"lookAheadPeriod\",\"type\":\"uint32\",\"indexed\":false,\"internalType\":\"uint32\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Unpaused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"AlreadyRegisteredForQuorums\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"BitmapCannotBeZero\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"BitmapEmpty\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"BitmapValueTooLarge\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"BytesArrayLengthTooLong\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"BytesArrayNotOrdered\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"CannotChurnSelf\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"CannotKickOperatorAboveThreshold\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"CannotReregisterYet\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ChurnApproverSaltUsed\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"CurrentlyPaused\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ExpModFailed\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InputAddressZero\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InputLengthMismatch\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InsufficientStakeForChurn\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidAVS\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidNewPausedStatus\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidRegistrationType\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidSignature\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"LookAheadPeriodTooLong\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"M2QuorumRegistrationIsDisabled\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"MaxOperatorCountReached\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"MaxQuorumsReached\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"NotRegistered\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"NotRegisteredForQuorum\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"NotSorted\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyAllocationManager\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyEjector\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyM2QuorumsAllowed\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyPauser\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyUnpauser\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OperatorNotRegistered\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OperatorNotRegisteredForQuorum\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OperatorSetQuorum\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OperatorSetsAlreadyEnabled\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OperatorSetsNotEnabled\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"QuorumDoesNotExist\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"QuorumOperatorCountMismatch\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SignatureExpired\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"StringTooLong\",\"inputs\":[{\"name\":\"str\",\"type\":\"string\",\"internalType\":\"string\"}]}]", } -// ContractEORegistryCoordinatorFilterer is an auto generated interface that defines the log filtering methods available for an Ethereum contract. -type ContractEORegistryCoordinatorFilters interface { - FilterChurnApproverUpdated(opts *bind.FilterOpts) (*ContractEORegistryCoordinatorChurnApproverUpdatedIterator, error) - WatchChurnApproverUpdated(opts *bind.WatchOpts, sink chan<- *ContractEORegistryCoordinatorChurnApproverUpdated) (event.Subscription, error) - ParseChurnApproverUpdated(log types.Log) (*ContractEORegistryCoordinatorChurnApproverUpdated, error) - - FilterEjectorUpdated(opts *bind.FilterOpts) (*ContractEORegistryCoordinatorEjectorUpdatedIterator, error) - WatchEjectorUpdated(opts *bind.WatchOpts, sink chan<- *ContractEORegistryCoordinatorEjectorUpdated) (event.Subscription, error) - ParseEjectorUpdated(log types.Log) (*ContractEORegistryCoordinatorEjectorUpdated, error) - - FilterInitialized(opts *bind.FilterOpts) (*ContractEORegistryCoordinatorInitializedIterator, error) - WatchInitialized(opts *bind.WatchOpts, sink chan<- *ContractEORegistryCoordinatorInitialized) (event.Subscription, error) - ParseInitialized(log types.Log) (*ContractEORegistryCoordinatorInitialized, error) - - FilterOperatorDeregistered(opts *bind.FilterOpts, operator []common.Address, operatorId [][32]byte) (*ContractEORegistryCoordinatorOperatorDeregisteredIterator, error) - WatchOperatorDeregistered(opts *bind.WatchOpts, sink chan<- *ContractEORegistryCoordinatorOperatorDeregistered, operator []common.Address, operatorId [][32]byte) (event.Subscription, error) - ParseOperatorDeregistered(log types.Log) (*ContractEORegistryCoordinatorOperatorDeregistered, error) +// EORegistryCoordinatorABI is the input ABI used to generate the binding from. +// Deprecated: Use EORegistryCoordinatorMetaData.ABI instead. +var EORegistryCoordinatorABI = EORegistryCoordinatorMetaData.ABI - FilterOperatorRegistered(opts *bind.FilterOpts, operator []common.Address, operatorId [][32]byte) (*ContractEORegistryCoordinatorOperatorRegisteredIterator, error) - WatchOperatorRegistered(opts *bind.WatchOpts, sink chan<- *ContractEORegistryCoordinatorOperatorRegistered, operator []common.Address, operatorId [][32]byte) (event.Subscription, error) - ParseOperatorRegistered(log types.Log) (*ContractEORegistryCoordinatorOperatorRegistered, error) - - FilterOperatorSetParamsUpdated(opts *bind.FilterOpts, quorumNumber []uint8) (*ContractEORegistryCoordinatorOperatorSetParamsUpdatedIterator, error) - WatchOperatorSetParamsUpdated(opts *bind.WatchOpts, sink chan<- *ContractEORegistryCoordinatorOperatorSetParamsUpdated, quorumNumber []uint8) (event.Subscription, error) - ParseOperatorSetParamsUpdated(log types.Log) (*ContractEORegistryCoordinatorOperatorSetParamsUpdated, error) - - FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*ContractEORegistryCoordinatorOwnershipTransferredIterator, error) - WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *ContractEORegistryCoordinatorOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) - ParseOwnershipTransferred(log types.Log) (*ContractEORegistryCoordinatorOwnershipTransferred, error) - - FilterPaused(opts *bind.FilterOpts, account []common.Address) (*ContractEORegistryCoordinatorPausedIterator, error) - WatchPaused(opts *bind.WatchOpts, sink chan<- *ContractEORegistryCoordinatorPaused, account []common.Address) (event.Subscription, error) - ParsePaused(log types.Log) (*ContractEORegistryCoordinatorPaused, error) - - FilterPauserRegistrySet(opts *bind.FilterOpts) (*ContractEORegistryCoordinatorPauserRegistrySetIterator, error) - WatchPauserRegistrySet(opts *bind.WatchOpts, sink chan<- *ContractEORegistryCoordinatorPauserRegistrySet) (event.Subscription, error) - ParsePauserRegistrySet(log types.Log) (*ContractEORegistryCoordinatorPauserRegistrySet, error) - - FilterQuorumBlockNumberUpdated(opts *bind.FilterOpts, quorumNumber []uint8) (*ContractEORegistryCoordinatorQuorumBlockNumberUpdatedIterator, error) - WatchQuorumBlockNumberUpdated(opts *bind.WatchOpts, sink chan<- *ContractEORegistryCoordinatorQuorumBlockNumberUpdated, quorumNumber []uint8) (event.Subscription, error) - ParseQuorumBlockNumberUpdated(log types.Log) (*ContractEORegistryCoordinatorQuorumBlockNumberUpdated, error) - - FilterUnpaused(opts *bind.FilterOpts, account []common.Address) (*ContractEORegistryCoordinatorUnpausedIterator, error) - WatchUnpaused(opts *bind.WatchOpts, sink chan<- *ContractEORegistryCoordinatorUnpaused, account []common.Address) (event.Subscription, error) - ParseUnpaused(log types.Log) (*ContractEORegistryCoordinatorUnpaused, error) -} - -// ContractEORegistryCoordinator is an auto generated Go binding around an Ethereum contract. -type ContractEORegistryCoordinator struct { - ContractEORegistryCoordinatorCaller // Read-only binding to the contract - ContractEORegistryCoordinatorTransactor // Write-only binding to the contract - ContractEORegistryCoordinatorFilterer // Log filterer for contract events +// EORegistryCoordinator is an auto generated Go binding around an Ethereum contract. +type EORegistryCoordinator struct { + EORegistryCoordinatorCaller // Read-only binding to the contract + EORegistryCoordinatorTransactor // Write-only binding to the contract + EORegistryCoordinatorFilterer // Log filterer for contract events } -// ContractEORegistryCoordinator implements the ContractEORegistryCoordinatorMethods interface. -var _ ContractEORegistryCoordinatorMethods = (*ContractEORegistryCoordinator)(nil) - -// ContractEORegistryCoordinatorCaller is an auto generated read-only Go binding around an Ethereum contract. -type ContractEORegistryCoordinatorCaller struct { +// EORegistryCoordinatorCaller is an auto generated read-only Go binding around an Ethereum contract. +type EORegistryCoordinatorCaller struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } -// ContractEORegistryCoordinatorCaller implements the ContractEORegistryCoordinatorCalls interface. -var _ ContractEORegistryCoordinatorCalls = (*ContractEORegistryCoordinatorCaller)(nil) - -// ContractEORegistryCoordinatorTransactor is an auto generated write-only Go binding around an Ethereum contract. -type ContractEORegistryCoordinatorTransactor struct { +// EORegistryCoordinatorTransactor is an auto generated write-only Go binding around an Ethereum contract. +type EORegistryCoordinatorTransactor struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } -// ContractEORegistryCoordinatorTransactor implements the ContractEORegistryCoordinatorTransacts interface. -var _ ContractEORegistryCoordinatorTransacts = (*ContractEORegistryCoordinatorTransactor)(nil) - -// ContractEORegistryCoordinatorFilterer is an auto generated log filtering Go binding around an Ethereum contract events. -type ContractEORegistryCoordinatorFilterer struct { +// EORegistryCoordinatorFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type EORegistryCoordinatorFilterer struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } -// ContractEORegistryCoordinatorFilterer implements the ContractEORegistryCoordinatorFilters interface. -var _ ContractEORegistryCoordinatorFilters = (*ContractEORegistryCoordinatorFilterer)(nil) - -// ContractEORegistryCoordinatorSession is an auto generated Go binding around an Ethereum contract, +// EORegistryCoordinatorSession is an auto generated Go binding around an Ethereum contract, // with pre-set call and transact options. -type ContractEORegistryCoordinatorSession struct { - Contract *ContractEORegistryCoordinator // 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 +type EORegistryCoordinatorSession struct { + Contract *EORegistryCoordinator // 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 } -// ContractEORegistryCoordinatorCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// EORegistryCoordinatorCallerSession is an auto generated read-only Go binding around an Ethereum contract, // with pre-set call options. -type ContractEORegistryCoordinatorCallerSession struct { - Contract *ContractEORegistryCoordinatorCaller // Generic contract caller binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session +type EORegistryCoordinatorCallerSession struct { + Contract *EORegistryCoordinatorCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session } -// ContractEORegistryCoordinatorTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// EORegistryCoordinatorTransactorSession is an auto generated write-only Go binding around an Ethereum contract, // with pre-set transact options. -type ContractEORegistryCoordinatorTransactorSession struct { - Contract *ContractEORegistryCoordinatorTransactor // Generic contract transactor binding to set the session for - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +type EORegistryCoordinatorTransactorSession struct { + Contract *EORegistryCoordinatorTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session } -// ContractEORegistryCoordinatorRaw is an auto generated low-level Go binding around an Ethereum contract. -type ContractEORegistryCoordinatorRaw struct { - Contract *ContractEORegistryCoordinator // Generic contract binding to access the raw methods on +// EORegistryCoordinatorRaw is an auto generated low-level Go binding around an Ethereum contract. +type EORegistryCoordinatorRaw struct { + Contract *EORegistryCoordinator // Generic contract binding to access the raw methods on } -// ContractEORegistryCoordinatorCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. -type ContractEORegistryCoordinatorCallerRaw struct { - Contract *ContractEORegistryCoordinatorCaller // Generic read-only contract binding to access the raw methods on +// EORegistryCoordinatorCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type EORegistryCoordinatorCallerRaw struct { + Contract *EORegistryCoordinatorCaller // Generic read-only contract binding to access the raw methods on } -// ContractEORegistryCoordinatorTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. -type ContractEORegistryCoordinatorTransactorRaw struct { - Contract *ContractEORegistryCoordinatorTransactor // Generic write-only contract binding to access the raw methods on +// EORegistryCoordinatorTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type EORegistryCoordinatorTransactorRaw struct { + Contract *EORegistryCoordinatorTransactor // Generic write-only contract binding to access the raw methods on } -// NewContractEORegistryCoordinator creates a new instance of ContractEORegistryCoordinator, bound to a specific deployed contract. -func NewContractEORegistryCoordinator(address common.Address, backend bind.ContractBackend) (*ContractEORegistryCoordinator, error) { - contract, err := bindContractEORegistryCoordinator(address, backend, backend, backend) +// NewEORegistryCoordinator creates a new instance of EORegistryCoordinator, bound to a specific deployed contract. +func NewEORegistryCoordinator(address common.Address, backend bind.ContractBackend) (*EORegistryCoordinator, error) { + contract, err := bindEORegistryCoordinator(address, backend, backend, backend) if err != nil { return nil, err } - return &ContractEORegistryCoordinator{ContractEORegistryCoordinatorCaller: ContractEORegistryCoordinatorCaller{contract: contract}, ContractEORegistryCoordinatorTransactor: ContractEORegistryCoordinatorTransactor{contract: contract}, ContractEORegistryCoordinatorFilterer: ContractEORegistryCoordinatorFilterer{contract: contract}}, nil + return &EORegistryCoordinator{EORegistryCoordinatorCaller: EORegistryCoordinatorCaller{contract: contract}, EORegistryCoordinatorTransactor: EORegistryCoordinatorTransactor{contract: contract}, EORegistryCoordinatorFilterer: EORegistryCoordinatorFilterer{contract: contract}}, nil } -// NewContractEORegistryCoordinatorCaller creates a new read-only instance of ContractEORegistryCoordinator, bound to a specific deployed contract. -func NewContractEORegistryCoordinatorCaller(address common.Address, caller bind.ContractCaller) (*ContractEORegistryCoordinatorCaller, error) { - contract, err := bindContractEORegistryCoordinator(address, caller, nil, nil) +// NewEORegistryCoordinatorCaller creates a new read-only instance of EORegistryCoordinator, bound to a specific deployed contract. +func NewEORegistryCoordinatorCaller(address common.Address, caller bind.ContractCaller) (*EORegistryCoordinatorCaller, error) { + contract, err := bindEORegistryCoordinator(address, caller, nil, nil) if err != nil { return nil, err } - return &ContractEORegistryCoordinatorCaller{contract: contract}, nil + return &EORegistryCoordinatorCaller{contract: contract}, nil } -// NewContractEORegistryCoordinatorTransactor creates a new write-only instance of ContractEORegistryCoordinator, bound to a specific deployed contract. -func NewContractEORegistryCoordinatorTransactor(address common.Address, transactor bind.ContractTransactor) (*ContractEORegistryCoordinatorTransactor, error) { - contract, err := bindContractEORegistryCoordinator(address, nil, transactor, nil) +// NewEORegistryCoordinatorTransactor creates a new write-only instance of EORegistryCoordinator, bound to a specific deployed contract. +func NewEORegistryCoordinatorTransactor(address common.Address, transactor bind.ContractTransactor) (*EORegistryCoordinatorTransactor, error) { + contract, err := bindEORegistryCoordinator(address, nil, transactor, nil) if err != nil { return nil, err } - return &ContractEORegistryCoordinatorTransactor{contract: contract}, nil + return &EORegistryCoordinatorTransactor{contract: contract}, nil } -// NewContractEORegistryCoordinatorFilterer creates a new log filterer instance of ContractEORegistryCoordinator, bound to a specific deployed contract. -func NewContractEORegistryCoordinatorFilterer(address common.Address, filterer bind.ContractFilterer) (*ContractEORegistryCoordinatorFilterer, error) { - contract, err := bindContractEORegistryCoordinator(address, nil, nil, filterer) +// NewEORegistryCoordinatorFilterer creates a new log filterer instance of EORegistryCoordinator, bound to a specific deployed contract. +func NewEORegistryCoordinatorFilterer(address common.Address, filterer bind.ContractFilterer) (*EORegistryCoordinatorFilterer, error) { + contract, err := bindEORegistryCoordinator(address, nil, nil, filterer) if err != nil { return nil, err } - return &ContractEORegistryCoordinatorFilterer{contract: contract}, nil + return &EORegistryCoordinatorFilterer{contract: contract}, nil } -// bindContractEORegistryCoordinator binds a generic wrapper to an already deployed contract. -func bindContractEORegistryCoordinator(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { - parsed, err := ContractEORegistryCoordinatorMetaData.GetAbi() +// bindEORegistryCoordinator binds a generic wrapper to an already deployed contract. +func bindEORegistryCoordinator(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := EORegistryCoordinatorMetaData.GetAbi() if err != nil { return nil, err } @@ -395,77 +220,77 @@ func bindContractEORegistryCoordinator(address common.Address, caller bind.Contr // 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 (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _ContractEORegistryCoordinator.Contract.ContractEORegistryCoordinatorCaller.contract.Call(opts, result, method, params...) +func (_EORegistryCoordinator *EORegistryCoordinatorRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _EORegistryCoordinator.Contract.EORegistryCoordinatorCaller.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 (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.Contract.ContractEORegistryCoordinatorTransactor.contract.Transfer(opts) +func (_EORegistryCoordinator *EORegistryCoordinatorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.EORegistryCoordinatorTransactor.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.Contract.ContractEORegistryCoordinatorTransactor.contract.Transact(opts, method, params...) +func (_EORegistryCoordinator *EORegistryCoordinatorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.EORegistryCoordinatorTransactor.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 (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _ContractEORegistryCoordinator.Contract.contract.Call(opts, result, method, params...) +func (_EORegistryCoordinator *EORegistryCoordinatorCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _EORegistryCoordinator.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 (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.Contract.contract.Transfer(opts) +func (_EORegistryCoordinator *EORegistryCoordinatorTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.Contract.contract.Transact(opts, method, params...) +func (_EORegistryCoordinator *EORegistryCoordinatorTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.contract.Transact(opts, method, params...) } -// EOChainManager is a free data retrieval call binding the contract method 0x5b658e23. +// OPERATORCHURNAPPROVALTYPEHASH is a free data retrieval call binding the contract method 0xca0de882. // -// Solidity: function EOChainManager() view returns(address) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) EOChainManager(opts *bind.CallOpts) (common.Address, error) { +// Solidity: function OPERATOR_CHURN_APPROVAL_TYPEHASH() view returns(bytes32) +func (_EORegistryCoordinator *EORegistryCoordinatorCaller) OPERATORCHURNAPPROVALTYPEHASH(opts *bind.CallOpts) ([32]byte, error) { var out []interface{} - err := _ContractEORegistryCoordinator.contract.Call(opts, &out, "EOChainManager") + err := _EORegistryCoordinator.contract.Call(opts, &out, "OPERATOR_CHURN_APPROVAL_TYPEHASH") if err != nil { - return *new(common.Address), err + return *new([32]byte), err } - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) return out0, err } -// EOChainManager is a free data retrieval call binding the contract method 0x5b658e23. +// OPERATORCHURNAPPROVALTYPEHASH is a free data retrieval call binding the contract method 0xca0de882. // -// Solidity: function EOChainManager() view returns(address) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorSession) EOChainManager() (common.Address, error) { - return _ContractEORegistryCoordinator.Contract.EOChainManager(&_ContractEORegistryCoordinator.CallOpts) +// Solidity: function OPERATOR_CHURN_APPROVAL_TYPEHASH() view returns(bytes32) +func (_EORegistryCoordinator *EORegistryCoordinatorSession) OPERATORCHURNAPPROVALTYPEHASH() ([32]byte, error) { + return _EORegistryCoordinator.Contract.OPERATORCHURNAPPROVALTYPEHASH(&_EORegistryCoordinator.CallOpts) } -// EOChainManager is a free data retrieval call binding the contract method 0x5b658e23. +// OPERATORCHURNAPPROVALTYPEHASH is a free data retrieval call binding the contract method 0xca0de882. // -// Solidity: function EOChainManager() view returns(address) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCallerSession) EOChainManager() (common.Address, error) { - return _ContractEORegistryCoordinator.Contract.EOChainManager(&_ContractEORegistryCoordinator.CallOpts) +// Solidity: function OPERATOR_CHURN_APPROVAL_TYPEHASH() view returns(bytes32) +func (_EORegistryCoordinator *EORegistryCoordinatorCallerSession) OPERATORCHURNAPPROVALTYPEHASH() ([32]byte, error) { + return _EORegistryCoordinator.Contract.OPERATORCHURNAPPROVALTYPEHASH(&_EORegistryCoordinator.CallOpts) } -// OPERATORCHURNAPPROVALTYPEHASH is a free data retrieval call binding the contract method 0xca0de882. +// PUBKEYREGISTRATIONTYPEHASH is a free data retrieval call binding the contract method 0x9feab859. // -// Solidity: function OPERATOR_CHURN_APPROVAL_TYPEHASH() view returns(bytes32) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) OPERATORCHURNAPPROVALTYPEHASH(opts *bind.CallOpts) ([32]byte, error) { +// Solidity: function PUBKEY_REGISTRATION_TYPEHASH() view returns(bytes32) +func (_EORegistryCoordinator *EORegistryCoordinatorCaller) PUBKEYREGISTRATIONTYPEHASH(opts *bind.CallOpts) ([32]byte, error) { var out []interface{} - err := _ContractEORegistryCoordinator.contract.Call(opts, &out, "OPERATOR_CHURN_APPROVAL_TYPEHASH") + err := _EORegistryCoordinator.contract.Call(opts, &out, "PUBKEY_REGISTRATION_TYPEHASH") if err != nil { return *new([32]byte), err @@ -477,57 +302,88 @@ func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) OPERA } -// OPERATORCHURNAPPROVALTYPEHASH is a free data retrieval call binding the contract method 0xca0de882. +// PUBKEYREGISTRATIONTYPEHASH is a free data retrieval call binding the contract method 0x9feab859. // -// Solidity: function OPERATOR_CHURN_APPROVAL_TYPEHASH() view returns(bytes32) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorSession) OPERATORCHURNAPPROVALTYPEHASH() ([32]byte, error) { - return _ContractEORegistryCoordinator.Contract.OPERATORCHURNAPPROVALTYPEHASH(&_ContractEORegistryCoordinator.CallOpts) +// Solidity: function PUBKEY_REGISTRATION_TYPEHASH() view returns(bytes32) +func (_EORegistryCoordinator *EORegistryCoordinatorSession) PUBKEYREGISTRATIONTYPEHASH() ([32]byte, error) { + return _EORegistryCoordinator.Contract.PUBKEYREGISTRATIONTYPEHASH(&_EORegistryCoordinator.CallOpts) } -// OPERATORCHURNAPPROVALTYPEHASH is a free data retrieval call binding the contract method 0xca0de882. +// PUBKEYREGISTRATIONTYPEHASH is a free data retrieval call binding the contract method 0x9feab859. // -// Solidity: function OPERATOR_CHURN_APPROVAL_TYPEHASH() view returns(bytes32) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCallerSession) OPERATORCHURNAPPROVALTYPEHASH() ([32]byte, error) { - return _ContractEORegistryCoordinator.Contract.OPERATORCHURNAPPROVALTYPEHASH(&_ContractEORegistryCoordinator.CallOpts) +// Solidity: function PUBKEY_REGISTRATION_TYPEHASH() view returns(bytes32) +func (_EORegistryCoordinator *EORegistryCoordinatorCallerSession) PUBKEYREGISTRATIONTYPEHASH() ([32]byte, error) { + return _EORegistryCoordinator.Contract.PUBKEYREGISTRATIONTYPEHASH(&_EORegistryCoordinator.CallOpts) } -// PUBKEYREGISTRATIONTYPEHASH is a free data retrieval call binding the contract method 0x9feab859. +// AllocationManager is a free data retrieval call binding the contract method 0xca8aa7c7. // -// Solidity: function PUBKEY_REGISTRATION_TYPEHASH() view returns(bytes32) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) PUBKEYREGISTRATIONTYPEHASH(opts *bind.CallOpts) ([32]byte, error) { +// Solidity: function allocationManager() view returns(address) +func (_EORegistryCoordinator *EORegistryCoordinatorCaller) AllocationManager(opts *bind.CallOpts) (common.Address, error) { var out []interface{} - err := _ContractEORegistryCoordinator.contract.Call(opts, &out, "PUBKEY_REGISTRATION_TYPEHASH") + err := _EORegistryCoordinator.contract.Call(opts, &out, "allocationManager") if err != nil { - return *new([32]byte), err + return *new(common.Address), err } - out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) return out0, err } -// PUBKEYREGISTRATIONTYPEHASH is a free data retrieval call binding the contract method 0x9feab859. +// AllocationManager is a free data retrieval call binding the contract method 0xca8aa7c7. // -// Solidity: function PUBKEY_REGISTRATION_TYPEHASH() view returns(bytes32) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorSession) PUBKEYREGISTRATIONTYPEHASH() ([32]byte, error) { - return _ContractEORegistryCoordinator.Contract.PUBKEYREGISTRATIONTYPEHASH(&_ContractEORegistryCoordinator.CallOpts) +// Solidity: function allocationManager() view returns(address) +func (_EORegistryCoordinator *EORegistryCoordinatorSession) AllocationManager() (common.Address, error) { + return _EORegistryCoordinator.Contract.AllocationManager(&_EORegistryCoordinator.CallOpts) } -// PUBKEYREGISTRATIONTYPEHASH is a free data retrieval call binding the contract method 0x9feab859. +// AllocationManager is a free data retrieval call binding the contract method 0xca8aa7c7. // -// Solidity: function PUBKEY_REGISTRATION_TYPEHASH() view returns(bytes32) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCallerSession) PUBKEYREGISTRATIONTYPEHASH() ([32]byte, error) { - return _ContractEORegistryCoordinator.Contract.PUBKEYREGISTRATIONTYPEHASH(&_ContractEORegistryCoordinator.CallOpts) +// Solidity: function allocationManager() view returns(address) +func (_EORegistryCoordinator *EORegistryCoordinatorCallerSession) AllocationManager() (common.Address, error) { + return _EORegistryCoordinator.Contract.AllocationManager(&_EORegistryCoordinator.CallOpts) +} + +// Avs is a free data retrieval call binding the contract method 0xde1164bb. +// +// Solidity: function avs() view returns(address) +func (_EORegistryCoordinator *EORegistryCoordinatorCaller) Avs(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _EORegistryCoordinator.contract.Call(opts, &out, "avs") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// Avs is a free data retrieval call binding the contract method 0xde1164bb. +// +// Solidity: function avs() view returns(address) +func (_EORegistryCoordinator *EORegistryCoordinatorSession) Avs() (common.Address, error) { + return _EORegistryCoordinator.Contract.Avs(&_EORegistryCoordinator.CallOpts) +} + +// Avs is a free data retrieval call binding the contract method 0xde1164bb. +// +// Solidity: function avs() view returns(address) +func (_EORegistryCoordinator *EORegistryCoordinatorCallerSession) Avs() (common.Address, error) { + return _EORegistryCoordinator.Contract.Avs(&_EORegistryCoordinator.CallOpts) } // BlsApkRegistry is a free data retrieval call binding the contract method 0x5df45946. // // Solidity: function blsApkRegistry() view returns(address) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) BlsApkRegistry(opts *bind.CallOpts) (common.Address, error) { +func (_EORegistryCoordinator *EORegistryCoordinatorCaller) BlsApkRegistry(opts *bind.CallOpts) (common.Address, error) { var out []interface{} - err := _ContractEORegistryCoordinator.contract.Call(opts, &out, "blsApkRegistry") + err := _EORegistryCoordinator.contract.Call(opts, &out, "blsApkRegistry") if err != nil { return *new(common.Address), err @@ -542,23 +398,23 @@ func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) BlsAp // BlsApkRegistry is a free data retrieval call binding the contract method 0x5df45946. // // Solidity: function blsApkRegistry() view returns(address) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorSession) BlsApkRegistry() (common.Address, error) { - return _ContractEORegistryCoordinator.Contract.BlsApkRegistry(&_ContractEORegistryCoordinator.CallOpts) +func (_EORegistryCoordinator *EORegistryCoordinatorSession) BlsApkRegistry() (common.Address, error) { + return _EORegistryCoordinator.Contract.BlsApkRegistry(&_EORegistryCoordinator.CallOpts) } // BlsApkRegistry is a free data retrieval call binding the contract method 0x5df45946. // // Solidity: function blsApkRegistry() view returns(address) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCallerSession) BlsApkRegistry() (common.Address, error) { - return _ContractEORegistryCoordinator.Contract.BlsApkRegistry(&_ContractEORegistryCoordinator.CallOpts) +func (_EORegistryCoordinator *EORegistryCoordinatorCallerSession) BlsApkRegistry() (common.Address, error) { + return _EORegistryCoordinator.Contract.BlsApkRegistry(&_EORegistryCoordinator.CallOpts) } // CalculateOperatorChurnApprovalDigestHash is a free data retrieval call binding the contract method 0x84ca5213. // // Solidity: function calculateOperatorChurnApprovalDigestHash(address registeringOperator, bytes32 registeringOperatorId, (uint8,address)[] operatorKickParams, bytes32 salt, uint256 expiry) view returns(bytes32) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) CalculateOperatorChurnApprovalDigestHash(opts *bind.CallOpts, registeringOperator common.Address, registeringOperatorId [32]byte, operatorKickParams []IEORegistryCoordinatorOperatorKickParam, salt [32]byte, expiry *big.Int) ([32]byte, error) { +func (_EORegistryCoordinator *EORegistryCoordinatorCaller) CalculateOperatorChurnApprovalDigestHash(opts *bind.CallOpts, registeringOperator common.Address, registeringOperatorId [32]byte, operatorKickParams []ISlashingRegistryCoordinatorTypesOperatorKickParam, salt [32]byte, expiry *big.Int) ([32]byte, error) { var out []interface{} - err := _ContractEORegistryCoordinator.contract.Call(opts, &out, "calculateOperatorChurnApprovalDigestHash", registeringOperator, registeringOperatorId, operatorKickParams, salt, expiry) + err := _EORegistryCoordinator.contract.Call(opts, &out, "calculateOperatorChurnApprovalDigestHash", registeringOperator, registeringOperatorId, operatorKickParams, salt, expiry) if err != nil { return *new([32]byte), err @@ -573,23 +429,85 @@ func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) Calcu // CalculateOperatorChurnApprovalDigestHash is a free data retrieval call binding the contract method 0x84ca5213. // // Solidity: function calculateOperatorChurnApprovalDigestHash(address registeringOperator, bytes32 registeringOperatorId, (uint8,address)[] operatorKickParams, bytes32 salt, uint256 expiry) view returns(bytes32) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorSession) CalculateOperatorChurnApprovalDigestHash(registeringOperator common.Address, registeringOperatorId [32]byte, operatorKickParams []IEORegistryCoordinatorOperatorKickParam, salt [32]byte, expiry *big.Int) ([32]byte, error) { - return _ContractEORegistryCoordinator.Contract.CalculateOperatorChurnApprovalDigestHash(&_ContractEORegistryCoordinator.CallOpts, registeringOperator, registeringOperatorId, operatorKickParams, salt, expiry) +func (_EORegistryCoordinator *EORegistryCoordinatorSession) CalculateOperatorChurnApprovalDigestHash(registeringOperator common.Address, registeringOperatorId [32]byte, operatorKickParams []ISlashingRegistryCoordinatorTypesOperatorKickParam, salt [32]byte, expiry *big.Int) ([32]byte, error) { + return _EORegistryCoordinator.Contract.CalculateOperatorChurnApprovalDigestHash(&_EORegistryCoordinator.CallOpts, registeringOperator, registeringOperatorId, operatorKickParams, salt, expiry) } // CalculateOperatorChurnApprovalDigestHash is a free data retrieval call binding the contract method 0x84ca5213. // // Solidity: function calculateOperatorChurnApprovalDigestHash(address registeringOperator, bytes32 registeringOperatorId, (uint8,address)[] operatorKickParams, bytes32 salt, uint256 expiry) view returns(bytes32) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCallerSession) CalculateOperatorChurnApprovalDigestHash(registeringOperator common.Address, registeringOperatorId [32]byte, operatorKickParams []IEORegistryCoordinatorOperatorKickParam, salt [32]byte, expiry *big.Int) ([32]byte, error) { - return _ContractEORegistryCoordinator.Contract.CalculateOperatorChurnApprovalDigestHash(&_ContractEORegistryCoordinator.CallOpts, registeringOperator, registeringOperatorId, operatorKickParams, salt, expiry) +func (_EORegistryCoordinator *EORegistryCoordinatorCallerSession) CalculateOperatorChurnApprovalDigestHash(registeringOperator common.Address, registeringOperatorId [32]byte, operatorKickParams []ISlashingRegistryCoordinatorTypesOperatorKickParam, salt [32]byte, expiry *big.Int) ([32]byte, error) { + return _EORegistryCoordinator.Contract.CalculateOperatorChurnApprovalDigestHash(&_EORegistryCoordinator.CallOpts, registeringOperator, registeringOperatorId, operatorKickParams, salt, expiry) +} + +// CalculatePubkeyRegistrationMessageHash is a free data retrieval call binding the contract method 0x73447992. +// +// Solidity: function calculatePubkeyRegistrationMessageHash(address operator) view returns(bytes32) +func (_EORegistryCoordinator *EORegistryCoordinatorCaller) CalculatePubkeyRegistrationMessageHash(opts *bind.CallOpts, operator common.Address) ([32]byte, error) { + var out []interface{} + err := _EORegistryCoordinator.contract.Call(opts, &out, "calculatePubkeyRegistrationMessageHash", operator) + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// CalculatePubkeyRegistrationMessageHash is a free data retrieval call binding the contract method 0x73447992. +// +// Solidity: function calculatePubkeyRegistrationMessageHash(address operator) view returns(bytes32) +func (_EORegistryCoordinator *EORegistryCoordinatorSession) CalculatePubkeyRegistrationMessageHash(operator common.Address) ([32]byte, error) { + return _EORegistryCoordinator.Contract.CalculatePubkeyRegistrationMessageHash(&_EORegistryCoordinator.CallOpts, operator) +} + +// CalculatePubkeyRegistrationMessageHash is a free data retrieval call binding the contract method 0x73447992. +// +// Solidity: function calculatePubkeyRegistrationMessageHash(address operator) view returns(bytes32) +func (_EORegistryCoordinator *EORegistryCoordinatorCallerSession) CalculatePubkeyRegistrationMessageHash(operator common.Address) ([32]byte, error) { + return _EORegistryCoordinator.Contract.CalculatePubkeyRegistrationMessageHash(&_EORegistryCoordinator.CallOpts, operator) +} + +// ChainManager is a free data retrieval call binding the contract method 0x5d824812. +// +// Solidity: function chainManager() view returns(address) +func (_EORegistryCoordinator *EORegistryCoordinatorCaller) ChainManager(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _EORegistryCoordinator.contract.Call(opts, &out, "chainManager") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// ChainManager is a free data retrieval call binding the contract method 0x5d824812. +// +// Solidity: function chainManager() view returns(address) +func (_EORegistryCoordinator *EORegistryCoordinatorSession) ChainManager() (common.Address, error) { + return _EORegistryCoordinator.Contract.ChainManager(&_EORegistryCoordinator.CallOpts) +} + +// ChainManager is a free data retrieval call binding the contract method 0x5d824812. +// +// Solidity: function chainManager() view returns(address) +func (_EORegistryCoordinator *EORegistryCoordinatorCallerSession) ChainManager() (common.Address, error) { + return _EORegistryCoordinator.Contract.ChainManager(&_EORegistryCoordinator.CallOpts) } // ChurnApprover is a free data retrieval call binding the contract method 0x054310e6. // // Solidity: function churnApprover() view returns(address) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) ChurnApprover(opts *bind.CallOpts) (common.Address, error) { +func (_EORegistryCoordinator *EORegistryCoordinatorCaller) ChurnApprover(opts *bind.CallOpts) (common.Address, error) { var out []interface{} - err := _ContractEORegistryCoordinator.contract.Call(opts, &out, "churnApprover") + err := _EORegistryCoordinator.contract.Call(opts, &out, "churnApprover") if err != nil { return *new(common.Address), err @@ -604,23 +522,155 @@ func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) Churn // ChurnApprover is a free data retrieval call binding the contract method 0x054310e6. // // Solidity: function churnApprover() view returns(address) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorSession) ChurnApprover() (common.Address, error) { - return _ContractEORegistryCoordinator.Contract.ChurnApprover(&_ContractEORegistryCoordinator.CallOpts) +func (_EORegistryCoordinator *EORegistryCoordinatorSession) ChurnApprover() (common.Address, error) { + return _EORegistryCoordinator.Contract.ChurnApprover(&_EORegistryCoordinator.CallOpts) } // ChurnApprover is a free data retrieval call binding the contract method 0x054310e6. // // Solidity: function churnApprover() view returns(address) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCallerSession) ChurnApprover() (common.Address, error) { - return _ContractEORegistryCoordinator.Contract.ChurnApprover(&_ContractEORegistryCoordinator.CallOpts) +func (_EORegistryCoordinator *EORegistryCoordinatorCallerSession) ChurnApprover() (common.Address, error) { + return _EORegistryCoordinator.Contract.ChurnApprover(&_EORegistryCoordinator.CallOpts) +} + +// DomainSeparator is a free data retrieval call binding the contract method 0xf698da25. +// +// Solidity: function domainSeparator() view returns(bytes32) +func (_EORegistryCoordinator *EORegistryCoordinatorCaller) DomainSeparator(opts *bind.CallOpts) ([32]byte, error) { + var out []interface{} + err := _EORegistryCoordinator.contract.Call(opts, &out, "domainSeparator") + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// DomainSeparator is a free data retrieval call binding the contract method 0xf698da25. +// +// Solidity: function domainSeparator() view returns(bytes32) +func (_EORegistryCoordinator *EORegistryCoordinatorSession) DomainSeparator() ([32]byte, error) { + return _EORegistryCoordinator.Contract.DomainSeparator(&_EORegistryCoordinator.CallOpts) +} + +// DomainSeparator is a free data retrieval call binding the contract method 0xf698da25. +// +// Solidity: function domainSeparator() view returns(bytes32) +func (_EORegistryCoordinator *EORegistryCoordinatorCallerSession) DomainSeparator() ([32]byte, error) { + return _EORegistryCoordinator.Contract.DomainSeparator(&_EORegistryCoordinator.CallOpts) +} + +// Eip712Domain is a free data retrieval call binding the contract method 0x84b0196e. +// +// Solidity: function eip712Domain() view returns(bytes1 fields, string name, string version, uint256 chainId, address verifyingContract, bytes32 salt, uint256[] extensions) +func (_EORegistryCoordinator *EORegistryCoordinatorCaller) Eip712Domain(opts *bind.CallOpts) (struct { + Fields [1]byte + Name string + Version string + ChainId *big.Int + VerifyingContract common.Address + Salt [32]byte + Extensions []*big.Int +}, error) { + var out []interface{} + err := _EORegistryCoordinator.contract.Call(opts, &out, "eip712Domain") + + outstruct := new(struct { + Fields [1]byte + Name string + Version string + ChainId *big.Int + VerifyingContract common.Address + Salt [32]byte + Extensions []*big.Int + }) + if err != nil { + return *outstruct, err + } + + outstruct.Fields = *abi.ConvertType(out[0], new([1]byte)).(*[1]byte) + outstruct.Name = *abi.ConvertType(out[1], new(string)).(*string) + outstruct.Version = *abi.ConvertType(out[2], new(string)).(*string) + outstruct.ChainId = *abi.ConvertType(out[3], new(*big.Int)).(**big.Int) + outstruct.VerifyingContract = *abi.ConvertType(out[4], new(common.Address)).(*common.Address) + outstruct.Salt = *abi.ConvertType(out[5], new([32]byte)).(*[32]byte) + outstruct.Extensions = *abi.ConvertType(out[6], new([]*big.Int)).(*[]*big.Int) + + return *outstruct, err + +} + +// Eip712Domain is a free data retrieval call binding the contract method 0x84b0196e. +// +// Solidity: function eip712Domain() view returns(bytes1 fields, string name, string version, uint256 chainId, address verifyingContract, bytes32 salt, uint256[] extensions) +func (_EORegistryCoordinator *EORegistryCoordinatorSession) Eip712Domain() (struct { + Fields [1]byte + Name string + Version string + ChainId *big.Int + VerifyingContract common.Address + Salt [32]byte + Extensions []*big.Int +}, error) { + return _EORegistryCoordinator.Contract.Eip712Domain(&_EORegistryCoordinator.CallOpts) +} + +// Eip712Domain is a free data retrieval call binding the contract method 0x84b0196e. +// +// Solidity: function eip712Domain() view returns(bytes1 fields, string name, string version, uint256 chainId, address verifyingContract, bytes32 salt, uint256[] extensions) +func (_EORegistryCoordinator *EORegistryCoordinatorCallerSession) Eip712Domain() (struct { + Fields [1]byte + Name string + Version string + ChainId *big.Int + VerifyingContract common.Address + Salt [32]byte + Extensions []*big.Int +}, error) { + return _EORegistryCoordinator.Contract.Eip712Domain(&_EORegistryCoordinator.CallOpts) +} + +// EjectionCooldown is a free data retrieval call binding the contract method 0xa96f783e. +// +// Solidity: function ejectionCooldown() view returns(uint256) +func (_EORegistryCoordinator *EORegistryCoordinatorCaller) EjectionCooldown(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _EORegistryCoordinator.contract.Call(opts, &out, "ejectionCooldown") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// EjectionCooldown is a free data retrieval call binding the contract method 0xa96f783e. +// +// Solidity: function ejectionCooldown() view returns(uint256) +func (_EORegistryCoordinator *EORegistryCoordinatorSession) EjectionCooldown() (*big.Int, error) { + return _EORegistryCoordinator.Contract.EjectionCooldown(&_EORegistryCoordinator.CallOpts) +} + +// EjectionCooldown is a free data retrieval call binding the contract method 0xa96f783e. +// +// Solidity: function ejectionCooldown() view returns(uint256) +func (_EORegistryCoordinator *EORegistryCoordinatorCallerSession) EjectionCooldown() (*big.Int, error) { + return _EORegistryCoordinator.Contract.EjectionCooldown(&_EORegistryCoordinator.CallOpts) } // Ejector is a free data retrieval call binding the contract method 0x28f61b31. // // Solidity: function ejector() view returns(address) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) Ejector(opts *bind.CallOpts) (common.Address, error) { +func (_EORegistryCoordinator *EORegistryCoordinatorCaller) Ejector(opts *bind.CallOpts) (common.Address, error) { var out []interface{} - err := _ContractEORegistryCoordinator.contract.Call(opts, &out, "ejector") + err := _EORegistryCoordinator.contract.Call(opts, &out, "ejector") if err != nil { return *new(common.Address), err @@ -635,23 +685,23 @@ func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) Eject // Ejector is a free data retrieval call binding the contract method 0x28f61b31. // // Solidity: function ejector() view returns(address) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorSession) Ejector() (common.Address, error) { - return _ContractEORegistryCoordinator.Contract.Ejector(&_ContractEORegistryCoordinator.CallOpts) +func (_EORegistryCoordinator *EORegistryCoordinatorSession) Ejector() (common.Address, error) { + return _EORegistryCoordinator.Contract.Ejector(&_EORegistryCoordinator.CallOpts) } // Ejector is a free data retrieval call binding the contract method 0x28f61b31. // // Solidity: function ejector() view returns(address) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCallerSession) Ejector() (common.Address, error) { - return _ContractEORegistryCoordinator.Contract.Ejector(&_ContractEORegistryCoordinator.CallOpts) +func (_EORegistryCoordinator *EORegistryCoordinatorCallerSession) Ejector() (common.Address, error) { + return _EORegistryCoordinator.Contract.Ejector(&_EORegistryCoordinator.CallOpts) } // GetCurrentQuorumBitmap is a free data retrieval call binding the contract method 0x871ef049. // // Solidity: function getCurrentQuorumBitmap(bytes32 operatorId) view returns(uint192) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) GetCurrentQuorumBitmap(opts *bind.CallOpts, operatorId [32]byte) (*big.Int, error) { +func (_EORegistryCoordinator *EORegistryCoordinatorCaller) GetCurrentQuorumBitmap(opts *bind.CallOpts, operatorId [32]byte) (*big.Int, error) { var out []interface{} - err := _ContractEORegistryCoordinator.contract.Call(opts, &out, "getCurrentQuorumBitmap", operatorId) + err := _EORegistryCoordinator.contract.Call(opts, &out, "getCurrentQuorumBitmap", operatorId) if err != nil { return *new(*big.Int), err @@ -666,29 +716,29 @@ func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) GetCu // GetCurrentQuorumBitmap is a free data retrieval call binding the contract method 0x871ef049. // // Solidity: function getCurrentQuorumBitmap(bytes32 operatorId) view returns(uint192) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorSession) GetCurrentQuorumBitmap(operatorId [32]byte) (*big.Int, error) { - return _ContractEORegistryCoordinator.Contract.GetCurrentQuorumBitmap(&_ContractEORegistryCoordinator.CallOpts, operatorId) +func (_EORegistryCoordinator *EORegistryCoordinatorSession) GetCurrentQuorumBitmap(operatorId [32]byte) (*big.Int, error) { + return _EORegistryCoordinator.Contract.GetCurrentQuorumBitmap(&_EORegistryCoordinator.CallOpts, operatorId) } // GetCurrentQuorumBitmap is a free data retrieval call binding the contract method 0x871ef049. // // Solidity: function getCurrentQuorumBitmap(bytes32 operatorId) view returns(uint192) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCallerSession) GetCurrentQuorumBitmap(operatorId [32]byte) (*big.Int, error) { - return _ContractEORegistryCoordinator.Contract.GetCurrentQuorumBitmap(&_ContractEORegistryCoordinator.CallOpts, operatorId) +func (_EORegistryCoordinator *EORegistryCoordinatorCallerSession) GetCurrentQuorumBitmap(operatorId [32]byte) (*big.Int, error) { + return _EORegistryCoordinator.Contract.GetCurrentQuorumBitmap(&_EORegistryCoordinator.CallOpts, operatorId) } // GetOperator is a free data retrieval call binding the contract method 0x5865c60c. // // Solidity: function getOperator(address operator) view returns((bytes32,uint8)) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) GetOperator(opts *bind.CallOpts, operator common.Address) (IEORegistryCoordinatorOperatorInfo, error) { +func (_EORegistryCoordinator *EORegistryCoordinatorCaller) GetOperator(opts *bind.CallOpts, operator common.Address) (ISlashingRegistryCoordinatorTypesOperatorInfo, error) { var out []interface{} - err := _ContractEORegistryCoordinator.contract.Call(opts, &out, "getOperator", operator) + err := _EORegistryCoordinator.contract.Call(opts, &out, "getOperator", operator) if err != nil { - return *new(IEORegistryCoordinatorOperatorInfo), err + return *new(ISlashingRegistryCoordinatorTypesOperatorInfo), err } - out0 := *abi.ConvertType(out[0], new(IEORegistryCoordinatorOperatorInfo)).(*IEORegistryCoordinatorOperatorInfo) + out0 := *abi.ConvertType(out[0], new(ISlashingRegistryCoordinatorTypesOperatorInfo)).(*ISlashingRegistryCoordinatorTypesOperatorInfo) return out0, err @@ -697,23 +747,23 @@ func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) GetOp // GetOperator is a free data retrieval call binding the contract method 0x5865c60c. // // Solidity: function getOperator(address operator) view returns((bytes32,uint8)) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorSession) GetOperator(operator common.Address) (IEORegistryCoordinatorOperatorInfo, error) { - return _ContractEORegistryCoordinator.Contract.GetOperator(&_ContractEORegistryCoordinator.CallOpts, operator) +func (_EORegistryCoordinator *EORegistryCoordinatorSession) GetOperator(operator common.Address) (ISlashingRegistryCoordinatorTypesOperatorInfo, error) { + return _EORegistryCoordinator.Contract.GetOperator(&_EORegistryCoordinator.CallOpts, operator) } // GetOperator is a free data retrieval call binding the contract method 0x5865c60c. // // Solidity: function getOperator(address operator) view returns((bytes32,uint8)) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCallerSession) GetOperator(operator common.Address) (IEORegistryCoordinatorOperatorInfo, error) { - return _ContractEORegistryCoordinator.Contract.GetOperator(&_ContractEORegistryCoordinator.CallOpts, operator) +func (_EORegistryCoordinator *EORegistryCoordinatorCallerSession) GetOperator(operator common.Address) (ISlashingRegistryCoordinatorTypesOperatorInfo, error) { + return _EORegistryCoordinator.Contract.GetOperator(&_EORegistryCoordinator.CallOpts, operator) } // GetOperatorFromId is a free data retrieval call binding the contract method 0x296bb064. // // Solidity: function getOperatorFromId(bytes32 operatorId) view returns(address) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) GetOperatorFromId(opts *bind.CallOpts, operatorId [32]byte) (common.Address, error) { +func (_EORegistryCoordinator *EORegistryCoordinatorCaller) GetOperatorFromId(opts *bind.CallOpts, operatorId [32]byte) (common.Address, error) { var out []interface{} - err := _ContractEORegistryCoordinator.contract.Call(opts, &out, "getOperatorFromId", operatorId) + err := _EORegistryCoordinator.contract.Call(opts, &out, "getOperatorFromId", operatorId) if err != nil { return *new(common.Address), err @@ -728,23 +778,23 @@ func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) GetOp // GetOperatorFromId is a free data retrieval call binding the contract method 0x296bb064. // // Solidity: function getOperatorFromId(bytes32 operatorId) view returns(address) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorSession) GetOperatorFromId(operatorId [32]byte) (common.Address, error) { - return _ContractEORegistryCoordinator.Contract.GetOperatorFromId(&_ContractEORegistryCoordinator.CallOpts, operatorId) +func (_EORegistryCoordinator *EORegistryCoordinatorSession) GetOperatorFromId(operatorId [32]byte) (common.Address, error) { + return _EORegistryCoordinator.Contract.GetOperatorFromId(&_EORegistryCoordinator.CallOpts, operatorId) } // GetOperatorFromId is a free data retrieval call binding the contract method 0x296bb064. // // Solidity: function getOperatorFromId(bytes32 operatorId) view returns(address) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCallerSession) GetOperatorFromId(operatorId [32]byte) (common.Address, error) { - return _ContractEORegistryCoordinator.Contract.GetOperatorFromId(&_ContractEORegistryCoordinator.CallOpts, operatorId) +func (_EORegistryCoordinator *EORegistryCoordinatorCallerSession) GetOperatorFromId(operatorId [32]byte) (common.Address, error) { + return _EORegistryCoordinator.Contract.GetOperatorFromId(&_EORegistryCoordinator.CallOpts, operatorId) } // GetOperatorId is a free data retrieval call binding the contract method 0x13542a4e. // // Solidity: function getOperatorId(address operator) view returns(bytes32) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) GetOperatorId(opts *bind.CallOpts, operator common.Address) ([32]byte, error) { +func (_EORegistryCoordinator *EORegistryCoordinatorCaller) GetOperatorId(opts *bind.CallOpts, operator common.Address) ([32]byte, error) { var out []interface{} - err := _ContractEORegistryCoordinator.contract.Call(opts, &out, "getOperatorId", operator) + err := _EORegistryCoordinator.contract.Call(opts, &out, "getOperatorId", operator) if err != nil { return *new([32]byte), err @@ -759,29 +809,29 @@ func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) GetOp // GetOperatorId is a free data retrieval call binding the contract method 0x13542a4e. // // Solidity: function getOperatorId(address operator) view returns(bytes32) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorSession) GetOperatorId(operator common.Address) ([32]byte, error) { - return _ContractEORegistryCoordinator.Contract.GetOperatorId(&_ContractEORegistryCoordinator.CallOpts, operator) +func (_EORegistryCoordinator *EORegistryCoordinatorSession) GetOperatorId(operator common.Address) ([32]byte, error) { + return _EORegistryCoordinator.Contract.GetOperatorId(&_EORegistryCoordinator.CallOpts, operator) } // GetOperatorId is a free data retrieval call binding the contract method 0x13542a4e. // // Solidity: function getOperatorId(address operator) view returns(bytes32) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCallerSession) GetOperatorId(operator common.Address) ([32]byte, error) { - return _ContractEORegistryCoordinator.Contract.GetOperatorId(&_ContractEORegistryCoordinator.CallOpts, operator) +func (_EORegistryCoordinator *EORegistryCoordinatorCallerSession) GetOperatorId(operator common.Address) ([32]byte, error) { + return _EORegistryCoordinator.Contract.GetOperatorId(&_EORegistryCoordinator.CallOpts, operator) } // GetOperatorSetParams is a free data retrieval call binding the contract method 0xe65797ad. // // Solidity: function getOperatorSetParams(uint8 quorumNumber) view returns((uint32,uint16,uint16)) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) GetOperatorSetParams(opts *bind.CallOpts, quorumNumber uint8) (IEORegistryCoordinatorOperatorSetParam, error) { +func (_EORegistryCoordinator *EORegistryCoordinatorCaller) GetOperatorSetParams(opts *bind.CallOpts, quorumNumber uint8) (ISlashingRegistryCoordinatorTypesOperatorSetParam, error) { var out []interface{} - err := _ContractEORegistryCoordinator.contract.Call(opts, &out, "getOperatorSetParams", quorumNumber) + err := _EORegistryCoordinator.contract.Call(opts, &out, "getOperatorSetParams", quorumNumber) if err != nil { - return *new(IEORegistryCoordinatorOperatorSetParam), err + return *new(ISlashingRegistryCoordinatorTypesOperatorSetParam), err } - out0 := *abi.ConvertType(out[0], new(IEORegistryCoordinatorOperatorSetParam)).(*IEORegistryCoordinatorOperatorSetParam) + out0 := *abi.ConvertType(out[0], new(ISlashingRegistryCoordinatorTypesOperatorSetParam)).(*ISlashingRegistryCoordinatorTypesOperatorSetParam) return out0, err @@ -790,23 +840,23 @@ func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) GetOp // GetOperatorSetParams is a free data retrieval call binding the contract method 0xe65797ad. // // Solidity: function getOperatorSetParams(uint8 quorumNumber) view returns((uint32,uint16,uint16)) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorSession) GetOperatorSetParams(quorumNumber uint8) (IEORegistryCoordinatorOperatorSetParam, error) { - return _ContractEORegistryCoordinator.Contract.GetOperatorSetParams(&_ContractEORegistryCoordinator.CallOpts, quorumNumber) +func (_EORegistryCoordinator *EORegistryCoordinatorSession) GetOperatorSetParams(quorumNumber uint8) (ISlashingRegistryCoordinatorTypesOperatorSetParam, error) { + return _EORegistryCoordinator.Contract.GetOperatorSetParams(&_EORegistryCoordinator.CallOpts, quorumNumber) } // GetOperatorSetParams is a free data retrieval call binding the contract method 0xe65797ad. // // Solidity: function getOperatorSetParams(uint8 quorumNumber) view returns((uint32,uint16,uint16)) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCallerSession) GetOperatorSetParams(quorumNumber uint8) (IEORegistryCoordinatorOperatorSetParam, error) { - return _ContractEORegistryCoordinator.Contract.GetOperatorSetParams(&_ContractEORegistryCoordinator.CallOpts, quorumNumber) +func (_EORegistryCoordinator *EORegistryCoordinatorCallerSession) GetOperatorSetParams(quorumNumber uint8) (ISlashingRegistryCoordinatorTypesOperatorSetParam, error) { + return _EORegistryCoordinator.Contract.GetOperatorSetParams(&_EORegistryCoordinator.CallOpts, quorumNumber) } // GetOperatorStatus is a free data retrieval call binding the contract method 0xfd39105a. // // Solidity: function getOperatorStatus(address operator) view returns(uint8) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) GetOperatorStatus(opts *bind.CallOpts, operator common.Address) (uint8, error) { +func (_EORegistryCoordinator *EORegistryCoordinatorCaller) GetOperatorStatus(opts *bind.CallOpts, operator common.Address) (uint8, error) { var out []interface{} - err := _ContractEORegistryCoordinator.contract.Call(opts, &out, "getOperatorStatus", operator) + err := _EORegistryCoordinator.contract.Call(opts, &out, "getOperatorStatus", operator) if err != nil { return *new(uint8), err @@ -821,23 +871,23 @@ func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) GetOp // GetOperatorStatus is a free data retrieval call binding the contract method 0xfd39105a. // // Solidity: function getOperatorStatus(address operator) view returns(uint8) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorSession) GetOperatorStatus(operator common.Address) (uint8, error) { - return _ContractEORegistryCoordinator.Contract.GetOperatorStatus(&_ContractEORegistryCoordinator.CallOpts, operator) +func (_EORegistryCoordinator *EORegistryCoordinatorSession) GetOperatorStatus(operator common.Address) (uint8, error) { + return _EORegistryCoordinator.Contract.GetOperatorStatus(&_EORegistryCoordinator.CallOpts, operator) } // GetOperatorStatus is a free data retrieval call binding the contract method 0xfd39105a. // // Solidity: function getOperatorStatus(address operator) view returns(uint8) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCallerSession) GetOperatorStatus(operator common.Address) (uint8, error) { - return _ContractEORegistryCoordinator.Contract.GetOperatorStatus(&_ContractEORegistryCoordinator.CallOpts, operator) +func (_EORegistryCoordinator *EORegistryCoordinatorCallerSession) GetOperatorStatus(operator common.Address) (uint8, error) { + return _EORegistryCoordinator.Contract.GetOperatorStatus(&_EORegistryCoordinator.CallOpts, operator) } // GetQuorumBitmapAtBlockNumberByIndex is a free data retrieval call binding the contract method 0x04ec6351. // // Solidity: function getQuorumBitmapAtBlockNumberByIndex(bytes32 operatorId, uint32 blockNumber, uint256 index) view returns(uint192) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) GetQuorumBitmapAtBlockNumberByIndex(opts *bind.CallOpts, operatorId [32]byte, blockNumber uint32, index *big.Int) (*big.Int, error) { +func (_EORegistryCoordinator *EORegistryCoordinatorCaller) GetQuorumBitmapAtBlockNumberByIndex(opts *bind.CallOpts, operatorId [32]byte, blockNumber uint32, index *big.Int) (*big.Int, error) { var out []interface{} - err := _ContractEORegistryCoordinator.contract.Call(opts, &out, "getQuorumBitmapAtBlockNumberByIndex", operatorId, blockNumber, index) + err := _EORegistryCoordinator.contract.Call(opts, &out, "getQuorumBitmapAtBlockNumberByIndex", operatorId, blockNumber, index) if err != nil { return *new(*big.Int), err @@ -852,23 +902,23 @@ func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) GetQu // GetQuorumBitmapAtBlockNumberByIndex is a free data retrieval call binding the contract method 0x04ec6351. // // Solidity: function getQuorumBitmapAtBlockNumberByIndex(bytes32 operatorId, uint32 blockNumber, uint256 index) view returns(uint192) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorSession) GetQuorumBitmapAtBlockNumberByIndex(operatorId [32]byte, blockNumber uint32, index *big.Int) (*big.Int, error) { - return _ContractEORegistryCoordinator.Contract.GetQuorumBitmapAtBlockNumberByIndex(&_ContractEORegistryCoordinator.CallOpts, operatorId, blockNumber, index) +func (_EORegistryCoordinator *EORegistryCoordinatorSession) GetQuorumBitmapAtBlockNumberByIndex(operatorId [32]byte, blockNumber uint32, index *big.Int) (*big.Int, error) { + return _EORegistryCoordinator.Contract.GetQuorumBitmapAtBlockNumberByIndex(&_EORegistryCoordinator.CallOpts, operatorId, blockNumber, index) } // GetQuorumBitmapAtBlockNumberByIndex is a free data retrieval call binding the contract method 0x04ec6351. // // Solidity: function getQuorumBitmapAtBlockNumberByIndex(bytes32 operatorId, uint32 blockNumber, uint256 index) view returns(uint192) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCallerSession) GetQuorumBitmapAtBlockNumberByIndex(operatorId [32]byte, blockNumber uint32, index *big.Int) (*big.Int, error) { - return _ContractEORegistryCoordinator.Contract.GetQuorumBitmapAtBlockNumberByIndex(&_ContractEORegistryCoordinator.CallOpts, operatorId, blockNumber, index) +func (_EORegistryCoordinator *EORegistryCoordinatorCallerSession) GetQuorumBitmapAtBlockNumberByIndex(operatorId [32]byte, blockNumber uint32, index *big.Int) (*big.Int, error) { + return _EORegistryCoordinator.Contract.GetQuorumBitmapAtBlockNumberByIndex(&_EORegistryCoordinator.CallOpts, operatorId, blockNumber, index) } // GetQuorumBitmapHistoryLength is a free data retrieval call binding the contract method 0x03fd3492. // // Solidity: function getQuorumBitmapHistoryLength(bytes32 operatorId) view returns(uint256) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) GetQuorumBitmapHistoryLength(opts *bind.CallOpts, operatorId [32]byte) (*big.Int, error) { +func (_EORegistryCoordinator *EORegistryCoordinatorCaller) GetQuorumBitmapHistoryLength(opts *bind.CallOpts, operatorId [32]byte) (*big.Int, error) { var out []interface{} - err := _ContractEORegistryCoordinator.contract.Call(opts, &out, "getQuorumBitmapHistoryLength", operatorId) + err := _EORegistryCoordinator.contract.Call(opts, &out, "getQuorumBitmapHistoryLength", operatorId) if err != nil { return *new(*big.Int), err @@ -883,23 +933,23 @@ func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) GetQu // GetQuorumBitmapHistoryLength is a free data retrieval call binding the contract method 0x03fd3492. // // Solidity: function getQuorumBitmapHistoryLength(bytes32 operatorId) view returns(uint256) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorSession) GetQuorumBitmapHistoryLength(operatorId [32]byte) (*big.Int, error) { - return _ContractEORegistryCoordinator.Contract.GetQuorumBitmapHistoryLength(&_ContractEORegistryCoordinator.CallOpts, operatorId) +func (_EORegistryCoordinator *EORegistryCoordinatorSession) GetQuorumBitmapHistoryLength(operatorId [32]byte) (*big.Int, error) { + return _EORegistryCoordinator.Contract.GetQuorumBitmapHistoryLength(&_EORegistryCoordinator.CallOpts, operatorId) } // GetQuorumBitmapHistoryLength is a free data retrieval call binding the contract method 0x03fd3492. // // Solidity: function getQuorumBitmapHistoryLength(bytes32 operatorId) view returns(uint256) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCallerSession) GetQuorumBitmapHistoryLength(operatorId [32]byte) (*big.Int, error) { - return _ContractEORegistryCoordinator.Contract.GetQuorumBitmapHistoryLength(&_ContractEORegistryCoordinator.CallOpts, operatorId) +func (_EORegistryCoordinator *EORegistryCoordinatorCallerSession) GetQuorumBitmapHistoryLength(operatorId [32]byte) (*big.Int, error) { + return _EORegistryCoordinator.Contract.GetQuorumBitmapHistoryLength(&_EORegistryCoordinator.CallOpts, operatorId) } // GetQuorumBitmapIndicesAtBlockNumber is a free data retrieval call binding the contract method 0xc391425e. // // Solidity: function getQuorumBitmapIndicesAtBlockNumber(uint32 blockNumber, bytes32[] operatorIds) view returns(uint32[]) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) GetQuorumBitmapIndicesAtBlockNumber(opts *bind.CallOpts, blockNumber uint32, operatorIds [][32]byte) ([]uint32, error) { +func (_EORegistryCoordinator *EORegistryCoordinatorCaller) GetQuorumBitmapIndicesAtBlockNumber(opts *bind.CallOpts, blockNumber uint32, operatorIds [][32]byte) ([]uint32, error) { var out []interface{} - err := _ContractEORegistryCoordinator.contract.Call(opts, &out, "getQuorumBitmapIndicesAtBlockNumber", blockNumber, operatorIds) + err := _EORegistryCoordinator.contract.Call(opts, &out, "getQuorumBitmapIndicesAtBlockNumber", blockNumber, operatorIds) if err != nil { return *new([]uint32), err @@ -914,29 +964,29 @@ func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) GetQu // GetQuorumBitmapIndicesAtBlockNumber is a free data retrieval call binding the contract method 0xc391425e. // // Solidity: function getQuorumBitmapIndicesAtBlockNumber(uint32 blockNumber, bytes32[] operatorIds) view returns(uint32[]) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorSession) GetQuorumBitmapIndicesAtBlockNumber(blockNumber uint32, operatorIds [][32]byte) ([]uint32, error) { - return _ContractEORegistryCoordinator.Contract.GetQuorumBitmapIndicesAtBlockNumber(&_ContractEORegistryCoordinator.CallOpts, blockNumber, operatorIds) +func (_EORegistryCoordinator *EORegistryCoordinatorSession) GetQuorumBitmapIndicesAtBlockNumber(blockNumber uint32, operatorIds [][32]byte) ([]uint32, error) { + return _EORegistryCoordinator.Contract.GetQuorumBitmapIndicesAtBlockNumber(&_EORegistryCoordinator.CallOpts, blockNumber, operatorIds) } // GetQuorumBitmapIndicesAtBlockNumber is a free data retrieval call binding the contract method 0xc391425e. // // Solidity: function getQuorumBitmapIndicesAtBlockNumber(uint32 blockNumber, bytes32[] operatorIds) view returns(uint32[]) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCallerSession) GetQuorumBitmapIndicesAtBlockNumber(blockNumber uint32, operatorIds [][32]byte) ([]uint32, error) { - return _ContractEORegistryCoordinator.Contract.GetQuorumBitmapIndicesAtBlockNumber(&_ContractEORegistryCoordinator.CallOpts, blockNumber, operatorIds) +func (_EORegistryCoordinator *EORegistryCoordinatorCallerSession) GetQuorumBitmapIndicesAtBlockNumber(blockNumber uint32, operatorIds [][32]byte) ([]uint32, error) { + return _EORegistryCoordinator.Contract.GetQuorumBitmapIndicesAtBlockNumber(&_EORegistryCoordinator.CallOpts, blockNumber, operatorIds) } // GetQuorumBitmapUpdateByIndex is a free data retrieval call binding the contract method 0x1eb812da. // // Solidity: function getQuorumBitmapUpdateByIndex(bytes32 operatorId, uint256 index) view returns((uint32,uint32,uint192)) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) GetQuorumBitmapUpdateByIndex(opts *bind.CallOpts, operatorId [32]byte, index *big.Int) (IEORegistryCoordinatorQuorumBitmapUpdate, error) { +func (_EORegistryCoordinator *EORegistryCoordinatorCaller) GetQuorumBitmapUpdateByIndex(opts *bind.CallOpts, operatorId [32]byte, index *big.Int) (ISlashingRegistryCoordinatorTypesQuorumBitmapUpdate, error) { var out []interface{} - err := _ContractEORegistryCoordinator.contract.Call(opts, &out, "getQuorumBitmapUpdateByIndex", operatorId, index) + err := _EORegistryCoordinator.contract.Call(opts, &out, "getQuorumBitmapUpdateByIndex", operatorId, index) if err != nil { - return *new(IEORegistryCoordinatorQuorumBitmapUpdate), err + return *new(ISlashingRegistryCoordinatorTypesQuorumBitmapUpdate), err } - out0 := *abi.ConvertType(out[0], new(IEORegistryCoordinatorQuorumBitmapUpdate)).(*IEORegistryCoordinatorQuorumBitmapUpdate) + out0 := *abi.ConvertType(out[0], new(ISlashingRegistryCoordinatorTypesQuorumBitmapUpdate)).(*ISlashingRegistryCoordinatorTypesQuorumBitmapUpdate) return out0, err @@ -945,23 +995,23 @@ func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) GetQu // GetQuorumBitmapUpdateByIndex is a free data retrieval call binding the contract method 0x1eb812da. // // Solidity: function getQuorumBitmapUpdateByIndex(bytes32 operatorId, uint256 index) view returns((uint32,uint32,uint192)) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorSession) GetQuorumBitmapUpdateByIndex(operatorId [32]byte, index *big.Int) (IEORegistryCoordinatorQuorumBitmapUpdate, error) { - return _ContractEORegistryCoordinator.Contract.GetQuorumBitmapUpdateByIndex(&_ContractEORegistryCoordinator.CallOpts, operatorId, index) +func (_EORegistryCoordinator *EORegistryCoordinatorSession) GetQuorumBitmapUpdateByIndex(operatorId [32]byte, index *big.Int) (ISlashingRegistryCoordinatorTypesQuorumBitmapUpdate, error) { + return _EORegistryCoordinator.Contract.GetQuorumBitmapUpdateByIndex(&_EORegistryCoordinator.CallOpts, operatorId, index) } // GetQuorumBitmapUpdateByIndex is a free data retrieval call binding the contract method 0x1eb812da. // // Solidity: function getQuorumBitmapUpdateByIndex(bytes32 operatorId, uint256 index) view returns((uint32,uint32,uint192)) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCallerSession) GetQuorumBitmapUpdateByIndex(operatorId [32]byte, index *big.Int) (IEORegistryCoordinatorQuorumBitmapUpdate, error) { - return _ContractEORegistryCoordinator.Contract.GetQuorumBitmapUpdateByIndex(&_ContractEORegistryCoordinator.CallOpts, operatorId, index) +func (_EORegistryCoordinator *EORegistryCoordinatorCallerSession) GetQuorumBitmapUpdateByIndex(operatorId [32]byte, index *big.Int) (ISlashingRegistryCoordinatorTypesQuorumBitmapUpdate, error) { + return _EORegistryCoordinator.Contract.GetQuorumBitmapUpdateByIndex(&_EORegistryCoordinator.CallOpts, operatorId, index) } // IndexRegistry is a free data retrieval call binding the contract method 0x9e9923c2. // // Solidity: function indexRegistry() view returns(address) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) IndexRegistry(opts *bind.CallOpts) (common.Address, error) { +func (_EORegistryCoordinator *EORegistryCoordinatorCaller) IndexRegistry(opts *bind.CallOpts) (common.Address, error) { var out []interface{} - err := _ContractEORegistryCoordinator.contract.Call(opts, &out, "indexRegistry") + err := _EORegistryCoordinator.contract.Call(opts, &out, "indexRegistry") if err != nil { return *new(common.Address), err @@ -976,23 +1026,23 @@ func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) Index // IndexRegistry is a free data retrieval call binding the contract method 0x9e9923c2. // // Solidity: function indexRegistry() view returns(address) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorSession) IndexRegistry() (common.Address, error) { - return _ContractEORegistryCoordinator.Contract.IndexRegistry(&_ContractEORegistryCoordinator.CallOpts) +func (_EORegistryCoordinator *EORegistryCoordinatorSession) IndexRegistry() (common.Address, error) { + return _EORegistryCoordinator.Contract.IndexRegistry(&_EORegistryCoordinator.CallOpts) } // IndexRegistry is a free data retrieval call binding the contract method 0x9e9923c2. // // Solidity: function indexRegistry() view returns(address) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCallerSession) IndexRegistry() (common.Address, error) { - return _ContractEORegistryCoordinator.Contract.IndexRegistry(&_ContractEORegistryCoordinator.CallOpts) +func (_EORegistryCoordinator *EORegistryCoordinatorCallerSession) IndexRegistry() (common.Address, error) { + return _EORegistryCoordinator.Contract.IndexRegistry(&_EORegistryCoordinator.CallOpts) } // IsChurnApproverSaltUsed is a free data retrieval call binding the contract method 0x1478851f. // // Solidity: function isChurnApproverSaltUsed(bytes32 ) view returns(bool) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) IsChurnApproverSaltUsed(opts *bind.CallOpts, arg0 [32]byte) (bool, error) { +func (_EORegistryCoordinator *EORegistryCoordinatorCaller) IsChurnApproverSaltUsed(opts *bind.CallOpts, arg0 [32]byte) (bool, error) { var out []interface{} - err := _ContractEORegistryCoordinator.contract.Call(opts, &out, "isChurnApproverSaltUsed", arg0) + err := _EORegistryCoordinator.contract.Call(opts, &out, "isChurnApproverSaltUsed", arg0) if err != nil { return *new(bool), err @@ -1007,116 +1057,240 @@ func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) IsChu // IsChurnApproverSaltUsed is a free data retrieval call binding the contract method 0x1478851f. // // Solidity: function isChurnApproverSaltUsed(bytes32 ) view returns(bool) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorSession) IsChurnApproverSaltUsed(arg0 [32]byte) (bool, error) { - return _ContractEORegistryCoordinator.Contract.IsChurnApproverSaltUsed(&_ContractEORegistryCoordinator.CallOpts, arg0) +func (_EORegistryCoordinator *EORegistryCoordinatorSession) IsChurnApproverSaltUsed(arg0 [32]byte) (bool, error) { + return _EORegistryCoordinator.Contract.IsChurnApproverSaltUsed(&_EORegistryCoordinator.CallOpts, arg0) } // IsChurnApproverSaltUsed is a free data retrieval call binding the contract method 0x1478851f. // // Solidity: function isChurnApproverSaltUsed(bytes32 ) view returns(bool) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCallerSession) IsChurnApproverSaltUsed(arg0 [32]byte) (bool, error) { - return _ContractEORegistryCoordinator.Contract.IsChurnApproverSaltUsed(&_ContractEORegistryCoordinator.CallOpts, arg0) +func (_EORegistryCoordinator *EORegistryCoordinatorCallerSession) IsChurnApproverSaltUsed(arg0 [32]byte) (bool, error) { + return _EORegistryCoordinator.Contract.IsChurnApproverSaltUsed(&_EORegistryCoordinator.CallOpts, arg0) } -// NumRegistries is a free data retrieval call binding the contract method 0xd72d8dd6. +// IsM2Quorum is a free data retrieval call binding the contract method 0xa4d7871f. // -// Solidity: function numRegistries() view returns(uint256) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) NumRegistries(opts *bind.CallOpts) (*big.Int, error) { +// Solidity: function isM2Quorum(uint8 quorumNumber) view returns(bool) +func (_EORegistryCoordinator *EORegistryCoordinatorCaller) IsM2Quorum(opts *bind.CallOpts, quorumNumber uint8) (bool, error) { var out []interface{} - err := _ContractEORegistryCoordinator.contract.Call(opts, &out, "numRegistries") + err := _EORegistryCoordinator.contract.Call(opts, &out, "isM2Quorum", quorumNumber) if err != nil { - return *new(*big.Int), err + return *new(bool), err } - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) return out0, err } -// NumRegistries is a free data retrieval call binding the contract method 0xd72d8dd6. +// IsM2Quorum is a free data retrieval call binding the contract method 0xa4d7871f. // -// Solidity: function numRegistries() view returns(uint256) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorSession) NumRegistries() (*big.Int, error) { - return _ContractEORegistryCoordinator.Contract.NumRegistries(&_ContractEORegistryCoordinator.CallOpts) +// Solidity: function isM2Quorum(uint8 quorumNumber) view returns(bool) +func (_EORegistryCoordinator *EORegistryCoordinatorSession) IsM2Quorum(quorumNumber uint8) (bool, error) { + return _EORegistryCoordinator.Contract.IsM2Quorum(&_EORegistryCoordinator.CallOpts, quorumNumber) } -// NumRegistries is a free data retrieval call binding the contract method 0xd72d8dd6. +// IsM2Quorum is a free data retrieval call binding the contract method 0xa4d7871f. // -// Solidity: function numRegistries() view returns(uint256) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCallerSession) NumRegistries() (*big.Int, error) { - return _ContractEORegistryCoordinator.Contract.NumRegistries(&_ContractEORegistryCoordinator.CallOpts) +// Solidity: function isM2Quorum(uint8 quorumNumber) view returns(bool) +func (_EORegistryCoordinator *EORegistryCoordinatorCallerSession) IsM2Quorum(quorumNumber uint8) (bool, error) { + return _EORegistryCoordinator.Contract.IsM2Quorum(&_EORegistryCoordinator.CallOpts, quorumNumber) } -// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// IsM2QuorumRegistrationDisabled is a free data retrieval call binding the contract method 0xe814ca9d. // -// Solidity: function owner() view returns(address) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) Owner(opts *bind.CallOpts) (common.Address, error) { +// Solidity: function isM2QuorumRegistrationDisabled() view returns(bool) +func (_EORegistryCoordinator *EORegistryCoordinatorCaller) IsM2QuorumRegistrationDisabled(opts *bind.CallOpts) (bool, error) { var out []interface{} - err := _ContractEORegistryCoordinator.contract.Call(opts, &out, "owner") + err := _EORegistryCoordinator.contract.Call(opts, &out, "isM2QuorumRegistrationDisabled") if err != nil { - return *new(common.Address), err + return *new(bool), err } - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) return out0, err } -// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// IsM2QuorumRegistrationDisabled is a free data retrieval call binding the contract method 0xe814ca9d. // -// Solidity: function owner() view returns(address) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorSession) Owner() (common.Address, error) { - return _ContractEORegistryCoordinator.Contract.Owner(&_ContractEORegistryCoordinator.CallOpts) +// Solidity: function isM2QuorumRegistrationDisabled() view returns(bool) +func (_EORegistryCoordinator *EORegistryCoordinatorSession) IsM2QuorumRegistrationDisabled() (bool, error) { + return _EORegistryCoordinator.Contract.IsM2QuorumRegistrationDisabled(&_EORegistryCoordinator.CallOpts) } -// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// IsM2QuorumRegistrationDisabled is a free data retrieval call binding the contract method 0xe814ca9d. // -// Solidity: function owner() view returns(address) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCallerSession) Owner() (common.Address, error) { - return _ContractEORegistryCoordinator.Contract.Owner(&_ContractEORegistryCoordinator.CallOpts) +// Solidity: function isM2QuorumRegistrationDisabled() view returns(bool) +func (_EORegistryCoordinator *EORegistryCoordinatorCallerSession) IsM2QuorumRegistrationDisabled() (bool, error) { + return _EORegistryCoordinator.Contract.IsM2QuorumRegistrationDisabled(&_EORegistryCoordinator.CallOpts) } -// Paused is a free data retrieval call binding the contract method 0x5ac86ab7. +// LastEjectionTimestamp is a free data retrieval call binding the contract method 0x125e0584. // -// Solidity: function paused(uint8 index) view returns(bool) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) Paused(opts *bind.CallOpts, index uint8) (bool, error) { +// Solidity: function lastEjectionTimestamp(address ) view returns(uint256) +func (_EORegistryCoordinator *EORegistryCoordinatorCaller) LastEjectionTimestamp(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) { var out []interface{} - err := _ContractEORegistryCoordinator.contract.Call(opts, &out, "paused", index) + err := _EORegistryCoordinator.contract.Call(opts, &out, "lastEjectionTimestamp", arg0) if err != nil { - return *new(bool), err + return *new(*big.Int), err } - out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) return out0, err } -// Paused is a free data retrieval call binding the contract method 0x5ac86ab7. +// LastEjectionTimestamp is a free data retrieval call binding the contract method 0x125e0584. // -// Solidity: function paused(uint8 index) view returns(bool) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorSession) Paused(index uint8) (bool, error) { - return _ContractEORegistryCoordinator.Contract.Paused(&_ContractEORegistryCoordinator.CallOpts, index) +// Solidity: function lastEjectionTimestamp(address ) view returns(uint256) +func (_EORegistryCoordinator *EORegistryCoordinatorSession) LastEjectionTimestamp(arg0 common.Address) (*big.Int, error) { + return _EORegistryCoordinator.Contract.LastEjectionTimestamp(&_EORegistryCoordinator.CallOpts, arg0) +} + +// LastEjectionTimestamp is a free data retrieval call binding the contract method 0x125e0584. +// +// Solidity: function lastEjectionTimestamp(address ) view returns(uint256) +func (_EORegistryCoordinator *EORegistryCoordinatorCallerSession) LastEjectionTimestamp(arg0 common.Address) (*big.Int, error) { + return _EORegistryCoordinator.Contract.LastEjectionTimestamp(&_EORegistryCoordinator.CallOpts, arg0) +} + +// M2QuorumBitmap is a free data retrieval call binding the contract method 0xec8c3a1e. +// +// Solidity: function m2QuorumBitmap() view returns(uint256) +func (_EORegistryCoordinator *EORegistryCoordinatorCaller) M2QuorumBitmap(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _EORegistryCoordinator.contract.Call(opts, &out, "m2QuorumBitmap") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// M2QuorumBitmap is a free data retrieval call binding the contract method 0xec8c3a1e. +// +// Solidity: function m2QuorumBitmap() view returns(uint256) +func (_EORegistryCoordinator *EORegistryCoordinatorSession) M2QuorumBitmap() (*big.Int, error) { + return _EORegistryCoordinator.Contract.M2QuorumBitmap(&_EORegistryCoordinator.CallOpts) +} + +// M2QuorumBitmap is a free data retrieval call binding the contract method 0xec8c3a1e. +// +// Solidity: function m2QuorumBitmap() view returns(uint256) +func (_EORegistryCoordinator *EORegistryCoordinatorCallerSession) M2QuorumBitmap() (*big.Int, error) { + return _EORegistryCoordinator.Contract.M2QuorumBitmap(&_EORegistryCoordinator.CallOpts) +} + +// OperatorSetsEnabled is a free data retrieval call binding the contract method 0x81f936d2. +// +// Solidity: function operatorSetsEnabled() view returns(bool) +func (_EORegistryCoordinator *EORegistryCoordinatorCaller) OperatorSetsEnabled(opts *bind.CallOpts) (bool, error) { + var out []interface{} + err := _EORegistryCoordinator.contract.Call(opts, &out, "operatorSetsEnabled") + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// OperatorSetsEnabled is a free data retrieval call binding the contract method 0x81f936d2. +// +// Solidity: function operatorSetsEnabled() view returns(bool) +func (_EORegistryCoordinator *EORegistryCoordinatorSession) OperatorSetsEnabled() (bool, error) { + return _EORegistryCoordinator.Contract.OperatorSetsEnabled(&_EORegistryCoordinator.CallOpts) +} + +// OperatorSetsEnabled is a free data retrieval call binding the contract method 0x81f936d2. +// +// Solidity: function operatorSetsEnabled() view returns(bool) +func (_EORegistryCoordinator *EORegistryCoordinatorCallerSession) OperatorSetsEnabled() (bool, error) { + return _EORegistryCoordinator.Contract.OperatorSetsEnabled(&_EORegistryCoordinator.CallOpts) +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_EORegistryCoordinator *EORegistryCoordinatorCaller) Owner(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _EORegistryCoordinator.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 (_EORegistryCoordinator *EORegistryCoordinatorSession) Owner() (common.Address, error) { + return _EORegistryCoordinator.Contract.Owner(&_EORegistryCoordinator.CallOpts) +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_EORegistryCoordinator *EORegistryCoordinatorCallerSession) Owner() (common.Address, error) { + return _EORegistryCoordinator.Contract.Owner(&_EORegistryCoordinator.CallOpts) +} + +// Paused is a free data retrieval call binding the contract method 0x5ac86ab7. +// +// Solidity: function paused(uint8 index) view returns(bool) +func (_EORegistryCoordinator *EORegistryCoordinatorCaller) Paused(opts *bind.CallOpts, index uint8) (bool, error) { + var out []interface{} + err := _EORegistryCoordinator.contract.Call(opts, &out, "paused", index) + + 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 0x5ac86ab7. +// +// Solidity: function paused(uint8 index) view returns(bool) +func (_EORegistryCoordinator *EORegistryCoordinatorSession) Paused(index uint8) (bool, error) { + return _EORegistryCoordinator.Contract.Paused(&_EORegistryCoordinator.CallOpts, index) } // Paused is a free data retrieval call binding the contract method 0x5ac86ab7. // // Solidity: function paused(uint8 index) view returns(bool) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCallerSession) Paused(index uint8) (bool, error) { - return _ContractEORegistryCoordinator.Contract.Paused(&_ContractEORegistryCoordinator.CallOpts, index) +func (_EORegistryCoordinator *EORegistryCoordinatorCallerSession) Paused(index uint8) (bool, error) { + return _EORegistryCoordinator.Contract.Paused(&_EORegistryCoordinator.CallOpts, index) } // Paused0 is a free data retrieval call binding the contract method 0x5c975abb. // // Solidity: function paused() view returns(uint256) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) Paused0(opts *bind.CallOpts) (*big.Int, error) { +func (_EORegistryCoordinator *EORegistryCoordinatorCaller) Paused0(opts *bind.CallOpts) (*big.Int, error) { var out []interface{} - err := _ContractEORegistryCoordinator.contract.Call(opts, &out, "paused0") + err := _EORegistryCoordinator.contract.Call(opts, &out, "paused0") if err != nil { return *new(*big.Int), err @@ -1131,23 +1305,23 @@ func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) Pause // Paused0 is a free data retrieval call binding the contract method 0x5c975abb. // // Solidity: function paused() view returns(uint256) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorSession) Paused0() (*big.Int, error) { - return _ContractEORegistryCoordinator.Contract.Paused0(&_ContractEORegistryCoordinator.CallOpts) +func (_EORegistryCoordinator *EORegistryCoordinatorSession) Paused0() (*big.Int, error) { + return _EORegistryCoordinator.Contract.Paused0(&_EORegistryCoordinator.CallOpts) } // Paused0 is a free data retrieval call binding the contract method 0x5c975abb. // // Solidity: function paused() view returns(uint256) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCallerSession) Paused0() (*big.Int, error) { - return _ContractEORegistryCoordinator.Contract.Paused0(&_ContractEORegistryCoordinator.CallOpts) +func (_EORegistryCoordinator *EORegistryCoordinatorCallerSession) Paused0() (*big.Int, error) { + return _EORegistryCoordinator.Contract.Paused0(&_EORegistryCoordinator.CallOpts) } // PauserRegistry is a free data retrieval call binding the contract method 0x886f1195. // // Solidity: function pauserRegistry() view returns(address) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) PauserRegistry(opts *bind.CallOpts) (common.Address, error) { +func (_EORegistryCoordinator *EORegistryCoordinatorCaller) PauserRegistry(opts *bind.CallOpts) (common.Address, error) { var out []interface{} - err := _ContractEORegistryCoordinator.contract.Call(opts, &out, "pauserRegistry") + err := _EORegistryCoordinator.contract.Call(opts, &out, "pauserRegistry") if err != nil { return *new(common.Address), err @@ -1162,23 +1336,23 @@ func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) Pause // PauserRegistry is a free data retrieval call binding the contract method 0x886f1195. // // Solidity: function pauserRegistry() view returns(address) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorSession) PauserRegistry() (common.Address, error) { - return _ContractEORegistryCoordinator.Contract.PauserRegistry(&_ContractEORegistryCoordinator.CallOpts) +func (_EORegistryCoordinator *EORegistryCoordinatorSession) PauserRegistry() (common.Address, error) { + return _EORegistryCoordinator.Contract.PauserRegistry(&_EORegistryCoordinator.CallOpts) } // PauserRegistry is a free data retrieval call binding the contract method 0x886f1195. // // Solidity: function pauserRegistry() view returns(address) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCallerSession) PauserRegistry() (common.Address, error) { - return _ContractEORegistryCoordinator.Contract.PauserRegistry(&_ContractEORegistryCoordinator.CallOpts) +func (_EORegistryCoordinator *EORegistryCoordinatorCallerSession) PauserRegistry() (common.Address, error) { + return _EORegistryCoordinator.Contract.PauserRegistry(&_EORegistryCoordinator.CallOpts) } // PubkeyRegistrationMessageHash is a free data retrieval call binding the contract method 0x3c2a7f4c. // // Solidity: function pubkeyRegistrationMessageHash(address operator) view returns((uint256,uint256)) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) PubkeyRegistrationMessageHash(opts *bind.CallOpts, operator common.Address) (BN254G1Point, error) { +func (_EORegistryCoordinator *EORegistryCoordinatorCaller) PubkeyRegistrationMessageHash(opts *bind.CallOpts, operator common.Address) (BN254G1Point, error) { var out []interface{} - err := _ContractEORegistryCoordinator.contract.Call(opts, &out, "pubkeyRegistrationMessageHash", operator) + err := _EORegistryCoordinator.contract.Call(opts, &out, "pubkeyRegistrationMessageHash", operator) if err != nil { return *new(BN254G1Point), err @@ -1193,23 +1367,23 @@ func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) Pubke // PubkeyRegistrationMessageHash is a free data retrieval call binding the contract method 0x3c2a7f4c. // // Solidity: function pubkeyRegistrationMessageHash(address operator) view returns((uint256,uint256)) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorSession) PubkeyRegistrationMessageHash(operator common.Address) (BN254G1Point, error) { - return _ContractEORegistryCoordinator.Contract.PubkeyRegistrationMessageHash(&_ContractEORegistryCoordinator.CallOpts, operator) +func (_EORegistryCoordinator *EORegistryCoordinatorSession) PubkeyRegistrationMessageHash(operator common.Address) (BN254G1Point, error) { + return _EORegistryCoordinator.Contract.PubkeyRegistrationMessageHash(&_EORegistryCoordinator.CallOpts, operator) } // PubkeyRegistrationMessageHash is a free data retrieval call binding the contract method 0x3c2a7f4c. // // Solidity: function pubkeyRegistrationMessageHash(address operator) view returns((uint256,uint256)) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCallerSession) PubkeyRegistrationMessageHash(operator common.Address) (BN254G1Point, error) { - return _ContractEORegistryCoordinator.Contract.PubkeyRegistrationMessageHash(&_ContractEORegistryCoordinator.CallOpts, operator) +func (_EORegistryCoordinator *EORegistryCoordinatorCallerSession) PubkeyRegistrationMessageHash(operator common.Address) (BN254G1Point, error) { + return _EORegistryCoordinator.Contract.PubkeyRegistrationMessageHash(&_EORegistryCoordinator.CallOpts, operator) } // QuorumCount is a free data retrieval call binding the contract method 0x9aa1653d. // // Solidity: function quorumCount() view returns(uint8) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) QuorumCount(opts *bind.CallOpts) (uint8, error) { +func (_EORegistryCoordinator *EORegistryCoordinatorCaller) QuorumCount(opts *bind.CallOpts) (uint8, error) { var out []interface{} - err := _ContractEORegistryCoordinator.contract.Call(opts, &out, "quorumCount") + err := _EORegistryCoordinator.contract.Call(opts, &out, "quorumCount") if err != nil { return *new(uint8), err @@ -1224,23 +1398,23 @@ func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) Quoru // QuorumCount is a free data retrieval call binding the contract method 0x9aa1653d. // // Solidity: function quorumCount() view returns(uint8) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorSession) QuorumCount() (uint8, error) { - return _ContractEORegistryCoordinator.Contract.QuorumCount(&_ContractEORegistryCoordinator.CallOpts) +func (_EORegistryCoordinator *EORegistryCoordinatorSession) QuorumCount() (uint8, error) { + return _EORegistryCoordinator.Contract.QuorumCount(&_EORegistryCoordinator.CallOpts) } // QuorumCount is a free data retrieval call binding the contract method 0x9aa1653d. // // Solidity: function quorumCount() view returns(uint8) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCallerSession) QuorumCount() (uint8, error) { - return _ContractEORegistryCoordinator.Contract.QuorumCount(&_ContractEORegistryCoordinator.CallOpts) +func (_EORegistryCoordinator *EORegistryCoordinatorCallerSession) QuorumCount() (uint8, error) { + return _EORegistryCoordinator.Contract.QuorumCount(&_EORegistryCoordinator.CallOpts) } // QuorumUpdateBlockNumber is a free data retrieval call binding the contract method 0x249a0c42. // // Solidity: function quorumUpdateBlockNumber(uint8 ) view returns(uint256) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) QuorumUpdateBlockNumber(opts *bind.CallOpts, arg0 uint8) (*big.Int, error) { +func (_EORegistryCoordinator *EORegistryCoordinatorCaller) QuorumUpdateBlockNumber(opts *bind.CallOpts, arg0 uint8) (*big.Int, error) { var out []interface{} - err := _ContractEORegistryCoordinator.contract.Call(opts, &out, "quorumUpdateBlockNumber", arg0) + err := _EORegistryCoordinator.contract.Call(opts, &out, "quorumUpdateBlockNumber", arg0) if err != nil { return *new(*big.Int), err @@ -1255,23 +1429,23 @@ func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) Quoru // QuorumUpdateBlockNumber is a free data retrieval call binding the contract method 0x249a0c42. // // Solidity: function quorumUpdateBlockNumber(uint8 ) view returns(uint256) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorSession) QuorumUpdateBlockNumber(arg0 uint8) (*big.Int, error) { - return _ContractEORegistryCoordinator.Contract.QuorumUpdateBlockNumber(&_ContractEORegistryCoordinator.CallOpts, arg0) +func (_EORegistryCoordinator *EORegistryCoordinatorSession) QuorumUpdateBlockNumber(arg0 uint8) (*big.Int, error) { + return _EORegistryCoordinator.Contract.QuorumUpdateBlockNumber(&_EORegistryCoordinator.CallOpts, arg0) } // QuorumUpdateBlockNumber is a free data retrieval call binding the contract method 0x249a0c42. // // Solidity: function quorumUpdateBlockNumber(uint8 ) view returns(uint256) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCallerSession) QuorumUpdateBlockNumber(arg0 uint8) (*big.Int, error) { - return _ContractEORegistryCoordinator.Contract.QuorumUpdateBlockNumber(&_ContractEORegistryCoordinator.CallOpts, arg0) +func (_EORegistryCoordinator *EORegistryCoordinatorCallerSession) QuorumUpdateBlockNumber(arg0 uint8) (*big.Int, error) { + return _EORegistryCoordinator.Contract.QuorumUpdateBlockNumber(&_EORegistryCoordinator.CallOpts, arg0) } -// Registries is a free data retrieval call binding the contract method 0x6347c900. +// ServiceManager is a free data retrieval call binding the contract method 0x3998fdd3. // -// Solidity: function registries(uint256 ) view returns(address) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) Registries(opts *bind.CallOpts, arg0 *big.Int) (common.Address, error) { +// Solidity: function serviceManager() view returns(address) +func (_EORegistryCoordinator *EORegistryCoordinatorCaller) ServiceManager(opts *bind.CallOpts) (common.Address, error) { var out []interface{} - err := _ContractEORegistryCoordinator.contract.Call(opts, &out, "registries", arg0) + err := _EORegistryCoordinator.contract.Call(opts, &out, "serviceManager") if err != nil { return *new(common.Address), err @@ -1283,26 +1457,26 @@ func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) Regis } -// Registries is a free data retrieval call binding the contract method 0x6347c900. +// ServiceManager is a free data retrieval call binding the contract method 0x3998fdd3. // -// Solidity: function registries(uint256 ) view returns(address) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorSession) Registries(arg0 *big.Int) (common.Address, error) { - return _ContractEORegistryCoordinator.Contract.Registries(&_ContractEORegistryCoordinator.CallOpts, arg0) +// Solidity: function serviceManager() view returns(address) +func (_EORegistryCoordinator *EORegistryCoordinatorSession) ServiceManager() (common.Address, error) { + return _EORegistryCoordinator.Contract.ServiceManager(&_EORegistryCoordinator.CallOpts) } -// Registries is a free data retrieval call binding the contract method 0x6347c900. +// ServiceManager is a free data retrieval call binding the contract method 0x3998fdd3. // -// Solidity: function registries(uint256 ) view returns(address) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCallerSession) Registries(arg0 *big.Int) (common.Address, error) { - return _ContractEORegistryCoordinator.Contract.Registries(&_ContractEORegistryCoordinator.CallOpts, arg0) +// Solidity: function serviceManager() view returns(address) +func (_EORegistryCoordinator *EORegistryCoordinatorCallerSession) ServiceManager() (common.Address, error) { + return _EORegistryCoordinator.Contract.ServiceManager(&_EORegistryCoordinator.CallOpts) } -// ServiceManager is a free data retrieval call binding the contract method 0x3998fdd3. +// SocketRegistry is a free data retrieval call binding the contract method 0xea32afae. // -// Solidity: function serviceManager() view returns(address) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) ServiceManager(opts *bind.CallOpts) (common.Address, error) { +// Solidity: function socketRegistry() view returns(address) +func (_EORegistryCoordinator *EORegistryCoordinatorCaller) SocketRegistry(opts *bind.CallOpts) (common.Address, error) { var out []interface{} - err := _ContractEORegistryCoordinator.contract.Call(opts, &out, "serviceManager") + err := _EORegistryCoordinator.contract.Call(opts, &out, "socketRegistry") if err != nil { return *new(common.Address), err @@ -1314,26 +1488,26 @@ func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) Servi } -// ServiceManager is a free data retrieval call binding the contract method 0x3998fdd3. +// SocketRegistry is a free data retrieval call binding the contract method 0xea32afae. // -// Solidity: function serviceManager() view returns(address) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorSession) ServiceManager() (common.Address, error) { - return _ContractEORegistryCoordinator.Contract.ServiceManager(&_ContractEORegistryCoordinator.CallOpts) +// Solidity: function socketRegistry() view returns(address) +func (_EORegistryCoordinator *EORegistryCoordinatorSession) SocketRegistry() (common.Address, error) { + return _EORegistryCoordinator.Contract.SocketRegistry(&_EORegistryCoordinator.CallOpts) } -// ServiceManager is a free data retrieval call binding the contract method 0x3998fdd3. +// SocketRegistry is a free data retrieval call binding the contract method 0xea32afae. // -// Solidity: function serviceManager() view returns(address) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCallerSession) ServiceManager() (common.Address, error) { - return _ContractEORegistryCoordinator.Contract.ServiceManager(&_ContractEORegistryCoordinator.CallOpts) +// Solidity: function socketRegistry() view returns(address) +func (_EORegistryCoordinator *EORegistryCoordinatorCallerSession) SocketRegistry() (common.Address, error) { + return _EORegistryCoordinator.Contract.SocketRegistry(&_EORegistryCoordinator.CallOpts) } // StakeRegistry is a free data retrieval call binding the contract method 0x68304835. // // Solidity: function stakeRegistry() view returns(address) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) StakeRegistry(opts *bind.CallOpts) (common.Address, error) { +func (_EORegistryCoordinator *EORegistryCoordinatorCaller) StakeRegistry(opts *bind.CallOpts) (common.Address, error) { var out []interface{} - err := _ContractEORegistryCoordinator.contract.Call(opts, &out, "stakeRegistry") + err := _EORegistryCoordinator.contract.Call(opts, &out, "stakeRegistry") if err != nil { return *new(common.Address), err @@ -1348,398 +1522,1528 @@ func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCaller) Stake // StakeRegistry is a free data retrieval call binding the contract method 0x68304835. // // Solidity: function stakeRegistry() view returns(address) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorSession) StakeRegistry() (common.Address, error) { - return _ContractEORegistryCoordinator.Contract.StakeRegistry(&_ContractEORegistryCoordinator.CallOpts) +func (_EORegistryCoordinator *EORegistryCoordinatorSession) StakeRegistry() (common.Address, error) { + return _EORegistryCoordinator.Contract.StakeRegistry(&_EORegistryCoordinator.CallOpts) } // StakeRegistry is a free data retrieval call binding the contract method 0x68304835. // // Solidity: function stakeRegistry() view returns(address) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorCallerSession) StakeRegistry() (common.Address, error) { - return _ContractEORegistryCoordinator.Contract.StakeRegistry(&_ContractEORegistryCoordinator.CallOpts) +func (_EORegistryCoordinator *EORegistryCoordinatorCallerSession) StakeRegistry() (common.Address, error) { + return _EORegistryCoordinator.Contract.StakeRegistry(&_EORegistryCoordinator.CallOpts) +} + +// SupportsAVS is a free data retrieval call binding the contract method 0xb5265787. +// +// Solidity: function supportsAVS(address _avs) view returns(bool) +func (_EORegistryCoordinator *EORegistryCoordinatorCaller) SupportsAVS(opts *bind.CallOpts, _avs common.Address) (bool, error) { + var out []interface{} + err := _EORegistryCoordinator.contract.Call(opts, &out, "supportsAVS", _avs) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// SupportsAVS is a free data retrieval call binding the contract method 0xb5265787. +// +// Solidity: function supportsAVS(address _avs) view returns(bool) +func (_EORegistryCoordinator *EORegistryCoordinatorSession) SupportsAVS(_avs common.Address) (bool, error) { + return _EORegistryCoordinator.Contract.SupportsAVS(&_EORegistryCoordinator.CallOpts, _avs) +} + +// SupportsAVS is a free data retrieval call binding the contract method 0xb5265787. +// +// Solidity: function supportsAVS(address _avs) view returns(bool) +func (_EORegistryCoordinator *EORegistryCoordinatorCallerSession) SupportsAVS(_avs common.Address) (bool, error) { + return _EORegistryCoordinator.Contract.SupportsAVS(&_EORegistryCoordinator.CallOpts, _avs) +} + +// Version is a free data retrieval call binding the contract method 0x54fd4d50. +// +// Solidity: function version() view returns(string) +func (_EORegistryCoordinator *EORegistryCoordinatorCaller) Version(opts *bind.CallOpts) (string, error) { + var out []interface{} + err := _EORegistryCoordinator.contract.Call(opts, &out, "version") + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + } -// CreateQuorum is a paid mutator transaction binding the contract method 0xd75b4c88. +// Version is a free data retrieval call binding the contract method 0x54fd4d50. // -// Solidity: function createQuorum((uint32,uint16,uint16) operatorSetParams, uint96 minimumStake, (address,uint96)[] strategyParams) returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorTransactor) CreateQuorum(opts *bind.TransactOpts, operatorSetParams IEORegistryCoordinatorOperatorSetParam, minimumStake *big.Int, strategyParams []IEOStakeRegistryStrategyParams) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.contract.Transact(opts, "createQuorum", operatorSetParams, minimumStake, strategyParams) +// Solidity: function version() view returns(string) +func (_EORegistryCoordinator *EORegistryCoordinatorSession) Version() (string, error) { + return _EORegistryCoordinator.Contract.Version(&_EORegistryCoordinator.CallOpts) } -// CreateQuorum is a paid mutator transaction binding the contract method 0xd75b4c88. +// Version is a free data retrieval call binding the contract method 0x54fd4d50. // -// Solidity: function createQuorum((uint32,uint16,uint16) operatorSetParams, uint96 minimumStake, (address,uint96)[] strategyParams) returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorSession) CreateQuorum(operatorSetParams IEORegistryCoordinatorOperatorSetParam, minimumStake *big.Int, strategyParams []IEOStakeRegistryStrategyParams) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.Contract.CreateQuorum(&_ContractEORegistryCoordinator.TransactOpts, operatorSetParams, minimumStake, strategyParams) +// Solidity: function version() view returns(string) +func (_EORegistryCoordinator *EORegistryCoordinatorCallerSession) Version() (string, error) { + return _EORegistryCoordinator.Contract.Version(&_EORegistryCoordinator.CallOpts) } -// CreateQuorum is a paid mutator transaction binding the contract method 0xd75b4c88. +// CreateSlashableStakeQuorum is a paid mutator transaction binding the contract method 0x3eef3a51. // -// Solidity: function createQuorum((uint32,uint16,uint16) operatorSetParams, uint96 minimumStake, (address,uint96)[] strategyParams) returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorTransactorSession) CreateQuorum(operatorSetParams IEORegistryCoordinatorOperatorSetParam, minimumStake *big.Int, strategyParams []IEOStakeRegistryStrategyParams) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.Contract.CreateQuorum(&_ContractEORegistryCoordinator.TransactOpts, operatorSetParams, minimumStake, strategyParams) +// Solidity: function createSlashableStakeQuorum((uint32,uint16,uint16) operatorSetParams, uint96 minimumStake, (address,uint96)[] strategyParams, uint32 lookAheadPeriod) returns() +func (_EORegistryCoordinator *EORegistryCoordinatorTransactor) CreateSlashableStakeQuorum(opts *bind.TransactOpts, operatorSetParams ISlashingRegistryCoordinatorTypesOperatorSetParam, minimumStake *big.Int, strategyParams []IStakeRegistryTypesStrategyParams, lookAheadPeriod uint32) (*types.Transaction, error) { + return _EORegistryCoordinator.contract.Transact(opts, "createSlashableStakeQuorum", operatorSetParams, minimumStake, strategyParams, lookAheadPeriod) } -// DeregisterOperator is a paid mutator transaction binding the contract method 0xca4f2d97. +// CreateSlashableStakeQuorum is a paid mutator transaction binding the contract method 0x3eef3a51. +// +// Solidity: function createSlashableStakeQuorum((uint32,uint16,uint16) operatorSetParams, uint96 minimumStake, (address,uint96)[] strategyParams, uint32 lookAheadPeriod) returns() +func (_EORegistryCoordinator *EORegistryCoordinatorSession) CreateSlashableStakeQuorum(operatorSetParams ISlashingRegistryCoordinatorTypesOperatorSetParam, minimumStake *big.Int, strategyParams []IStakeRegistryTypesStrategyParams, lookAheadPeriod uint32) (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.CreateSlashableStakeQuorum(&_EORegistryCoordinator.TransactOpts, operatorSetParams, minimumStake, strategyParams, lookAheadPeriod) +} + +// CreateSlashableStakeQuorum is a paid mutator transaction binding the contract method 0x3eef3a51. +// +// Solidity: function createSlashableStakeQuorum((uint32,uint16,uint16) operatorSetParams, uint96 minimumStake, (address,uint96)[] strategyParams, uint32 lookAheadPeriod) returns() +func (_EORegistryCoordinator *EORegistryCoordinatorTransactorSession) CreateSlashableStakeQuorum(operatorSetParams ISlashingRegistryCoordinatorTypesOperatorSetParam, minimumStake *big.Int, strategyParams []IStakeRegistryTypesStrategyParams, lookAheadPeriod uint32) (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.CreateSlashableStakeQuorum(&_EORegistryCoordinator.TransactOpts, operatorSetParams, minimumStake, strategyParams, lookAheadPeriod) +} + +// CreateTotalDelegatedStakeQuorum is a paid mutator transaction binding the contract method 0x8281ab75. +// +// Solidity: function createTotalDelegatedStakeQuorum((uint32,uint16,uint16) operatorSetParams, uint96 minimumStake, (address,uint96)[] strategyParams) returns() +func (_EORegistryCoordinator *EORegistryCoordinatorTransactor) CreateTotalDelegatedStakeQuorum(opts *bind.TransactOpts, operatorSetParams ISlashingRegistryCoordinatorTypesOperatorSetParam, minimumStake *big.Int, strategyParams []IStakeRegistryTypesStrategyParams) (*types.Transaction, error) { + return _EORegistryCoordinator.contract.Transact(opts, "createTotalDelegatedStakeQuorum", operatorSetParams, minimumStake, strategyParams) +} + +// CreateTotalDelegatedStakeQuorum is a paid mutator transaction binding the contract method 0x8281ab75. +// +// Solidity: function createTotalDelegatedStakeQuorum((uint32,uint16,uint16) operatorSetParams, uint96 minimumStake, (address,uint96)[] strategyParams) returns() +func (_EORegistryCoordinator *EORegistryCoordinatorSession) CreateTotalDelegatedStakeQuorum(operatorSetParams ISlashingRegistryCoordinatorTypesOperatorSetParam, minimumStake *big.Int, strategyParams []IStakeRegistryTypesStrategyParams) (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.CreateTotalDelegatedStakeQuorum(&_EORegistryCoordinator.TransactOpts, operatorSetParams, minimumStake, strategyParams) +} + +// CreateTotalDelegatedStakeQuorum is a paid mutator transaction binding the contract method 0x8281ab75. +// +// Solidity: function createTotalDelegatedStakeQuorum((uint32,uint16,uint16) operatorSetParams, uint96 minimumStake, (address,uint96)[] strategyParams) returns() +func (_EORegistryCoordinator *EORegistryCoordinatorTransactorSession) CreateTotalDelegatedStakeQuorum(operatorSetParams ISlashingRegistryCoordinatorTypesOperatorSetParam, minimumStake *big.Int, strategyParams []IStakeRegistryTypesStrategyParams) (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.CreateTotalDelegatedStakeQuorum(&_EORegistryCoordinator.TransactOpts, operatorSetParams, minimumStake, strategyParams) +} + +// DeregisterOperator is a paid mutator transaction binding the contract method 0x303ca956. +// +// Solidity: function deregisterOperator(address operator, address avs, uint32[] operatorSetIds) returns() +func (_EORegistryCoordinator *EORegistryCoordinatorTransactor) DeregisterOperator(opts *bind.TransactOpts, operator common.Address, avs common.Address, operatorSetIds []uint32) (*types.Transaction, error) { + return _EORegistryCoordinator.contract.Transact(opts, "deregisterOperator", operator, avs, operatorSetIds) +} + +// DeregisterOperator is a paid mutator transaction binding the contract method 0x303ca956. +// +// Solidity: function deregisterOperator(address operator, address avs, uint32[] operatorSetIds) returns() +func (_EORegistryCoordinator *EORegistryCoordinatorSession) DeregisterOperator(operator common.Address, avs common.Address, operatorSetIds []uint32) (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.DeregisterOperator(&_EORegistryCoordinator.TransactOpts, operator, avs, operatorSetIds) +} + +// DeregisterOperator is a paid mutator transaction binding the contract method 0x303ca956. +// +// Solidity: function deregisterOperator(address operator, address avs, uint32[] operatorSetIds) returns() +func (_EORegistryCoordinator *EORegistryCoordinatorTransactorSession) DeregisterOperator(operator common.Address, avs common.Address, operatorSetIds []uint32) (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.DeregisterOperator(&_EORegistryCoordinator.TransactOpts, operator, avs, operatorSetIds) +} + +// DeregisterOperator0 is a paid mutator transaction binding the contract method 0xca4f2d97. // // Solidity: function deregisterOperator(bytes quorumNumbers) returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorTransactor) DeregisterOperator(opts *bind.TransactOpts, quorumNumbers []byte) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.contract.Transact(opts, "deregisterOperator", quorumNumbers) +func (_EORegistryCoordinator *EORegistryCoordinatorTransactor) DeregisterOperator0(opts *bind.TransactOpts, quorumNumbers []byte) (*types.Transaction, error) { + return _EORegistryCoordinator.contract.Transact(opts, "deregisterOperator0", quorumNumbers) } -// DeregisterOperator is a paid mutator transaction binding the contract method 0xca4f2d97. +// DeregisterOperator0 is a paid mutator transaction binding the contract method 0xca4f2d97. // // Solidity: function deregisterOperator(bytes quorumNumbers) returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorSession) DeregisterOperator(quorumNumbers []byte) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.Contract.DeregisterOperator(&_ContractEORegistryCoordinator.TransactOpts, quorumNumbers) +func (_EORegistryCoordinator *EORegistryCoordinatorSession) DeregisterOperator0(quorumNumbers []byte) (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.DeregisterOperator0(&_EORegistryCoordinator.TransactOpts, quorumNumbers) } -// DeregisterOperator is a paid mutator transaction binding the contract method 0xca4f2d97. +// DeregisterOperator0 is a paid mutator transaction binding the contract method 0xca4f2d97. // // Solidity: function deregisterOperator(bytes quorumNumbers) returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorTransactorSession) DeregisterOperator(quorumNumbers []byte) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.Contract.DeregisterOperator(&_ContractEORegistryCoordinator.TransactOpts, quorumNumbers) +func (_EORegistryCoordinator *EORegistryCoordinatorTransactorSession) DeregisterOperator0(quorumNumbers []byte) (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.DeregisterOperator0(&_EORegistryCoordinator.TransactOpts, quorumNumbers) +} + +// DisableM2QuorumRegistration is a paid mutator transaction binding the contract method 0x733b7507. +// +// Solidity: function disableM2QuorumRegistration() returns() +func (_EORegistryCoordinator *EORegistryCoordinatorTransactor) DisableM2QuorumRegistration(opts *bind.TransactOpts) (*types.Transaction, error) { + return _EORegistryCoordinator.contract.Transact(opts, "disableM2QuorumRegistration") +} + +// DisableM2QuorumRegistration is a paid mutator transaction binding the contract method 0x733b7507. +// +// Solidity: function disableM2QuorumRegistration() returns() +func (_EORegistryCoordinator *EORegistryCoordinatorSession) DisableM2QuorumRegistration() (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.DisableM2QuorumRegistration(&_EORegistryCoordinator.TransactOpts) +} + +// DisableM2QuorumRegistration is a paid mutator transaction binding the contract method 0x733b7507. +// +// Solidity: function disableM2QuorumRegistration() returns() +func (_EORegistryCoordinator *EORegistryCoordinatorTransactorSession) DisableM2QuorumRegistration() (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.DisableM2QuorumRegistration(&_EORegistryCoordinator.TransactOpts) } // EjectOperator is a paid mutator transaction binding the contract method 0x6e3b17db. // // Solidity: function ejectOperator(address operator, bytes quorumNumbers) returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorTransactor) EjectOperator(opts *bind.TransactOpts, operator common.Address, quorumNumbers []byte) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.contract.Transact(opts, "ejectOperator", operator, quorumNumbers) +func (_EORegistryCoordinator *EORegistryCoordinatorTransactor) EjectOperator(opts *bind.TransactOpts, operator common.Address, quorumNumbers []byte) (*types.Transaction, error) { + return _EORegistryCoordinator.contract.Transact(opts, "ejectOperator", operator, quorumNumbers) } // EjectOperator is a paid mutator transaction binding the contract method 0x6e3b17db. // // Solidity: function ejectOperator(address operator, bytes quorumNumbers) returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorSession) EjectOperator(operator common.Address, quorumNumbers []byte) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.Contract.EjectOperator(&_ContractEORegistryCoordinator.TransactOpts, operator, quorumNumbers) +func (_EORegistryCoordinator *EORegistryCoordinatorSession) EjectOperator(operator common.Address, quorumNumbers []byte) (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.EjectOperator(&_EORegistryCoordinator.TransactOpts, operator, quorumNumbers) } // EjectOperator is a paid mutator transaction binding the contract method 0x6e3b17db. // // Solidity: function ejectOperator(address operator, bytes quorumNumbers) returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorTransactorSession) EjectOperator(operator common.Address, quorumNumbers []byte) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.Contract.EjectOperator(&_ContractEORegistryCoordinator.TransactOpts, operator, quorumNumbers) +func (_EORegistryCoordinator *EORegistryCoordinatorTransactorSession) EjectOperator(operator common.Address, quorumNumbers []byte) (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.EjectOperator(&_EORegistryCoordinator.TransactOpts, operator, quorumNumbers) } -// Initialize is a paid mutator transaction binding the contract method 0xdd8283f3. +// Initialize is a paid mutator transaction binding the contract method 0x530b97a4. // -// Solidity: function initialize(address _initialOwner, address _churnApprover, address _ejector, address _pauserRegistry, uint256 _initialPausedStatus, (uint32,uint16,uint16)[] _operatorSetParams, uint96[] _minimumStakes, (address,uint96)[][] _strategyParams) returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorTransactor) Initialize(opts *bind.TransactOpts, _initialOwner common.Address, _churnApprover common.Address, _ejector common.Address, _pauserRegistry common.Address, _initialPausedStatus *big.Int, _operatorSetParams []IEORegistryCoordinatorOperatorSetParam, _minimumStakes []*big.Int, _strategyParams [][]IEOStakeRegistryStrategyParams) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.contract.Transact(opts, "initialize", _initialOwner, _churnApprover, _ejector, _pauserRegistry, _initialPausedStatus, _operatorSetParams, _minimumStakes, _strategyParams) +// Solidity: function initialize(address initialOwner, address churnApprover, address ejector, uint256 initialPausedStatus, address avs) returns() +func (_EORegistryCoordinator *EORegistryCoordinatorTransactor) Initialize(opts *bind.TransactOpts, initialOwner common.Address, churnApprover common.Address, ejector common.Address, initialPausedStatus *big.Int, avs common.Address) (*types.Transaction, error) { + return _EORegistryCoordinator.contract.Transact(opts, "initialize", initialOwner, churnApprover, ejector, initialPausedStatus, avs) } -// Initialize is a paid mutator transaction binding the contract method 0xdd8283f3. +// Initialize is a paid mutator transaction binding the contract method 0x530b97a4. // -// Solidity: function initialize(address _initialOwner, address _churnApprover, address _ejector, address _pauserRegistry, uint256 _initialPausedStatus, (uint32,uint16,uint16)[] _operatorSetParams, uint96[] _minimumStakes, (address,uint96)[][] _strategyParams) returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorSession) Initialize(_initialOwner common.Address, _churnApprover common.Address, _ejector common.Address, _pauserRegistry common.Address, _initialPausedStatus *big.Int, _operatorSetParams []IEORegistryCoordinatorOperatorSetParam, _minimumStakes []*big.Int, _strategyParams [][]IEOStakeRegistryStrategyParams) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.Contract.Initialize(&_ContractEORegistryCoordinator.TransactOpts, _initialOwner, _churnApprover, _ejector, _pauserRegistry, _initialPausedStatus, _operatorSetParams, _minimumStakes, _strategyParams) +// Solidity: function initialize(address initialOwner, address churnApprover, address ejector, uint256 initialPausedStatus, address avs) returns() +func (_EORegistryCoordinator *EORegistryCoordinatorSession) Initialize(initialOwner common.Address, churnApprover common.Address, ejector common.Address, initialPausedStatus *big.Int, avs common.Address) (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.Initialize(&_EORegistryCoordinator.TransactOpts, initialOwner, churnApprover, ejector, initialPausedStatus, avs) } -// Initialize is a paid mutator transaction binding the contract method 0xdd8283f3. +// Initialize is a paid mutator transaction binding the contract method 0x530b97a4. // -// Solidity: function initialize(address _initialOwner, address _churnApprover, address _ejector, address _pauserRegistry, uint256 _initialPausedStatus, (uint32,uint16,uint16)[] _operatorSetParams, uint96[] _minimumStakes, (address,uint96)[][] _strategyParams) returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorTransactorSession) Initialize(_initialOwner common.Address, _churnApprover common.Address, _ejector common.Address, _pauserRegistry common.Address, _initialPausedStatus *big.Int, _operatorSetParams []IEORegistryCoordinatorOperatorSetParam, _minimumStakes []*big.Int, _strategyParams [][]IEOStakeRegistryStrategyParams) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.Contract.Initialize(&_ContractEORegistryCoordinator.TransactOpts, _initialOwner, _churnApprover, _ejector, _pauserRegistry, _initialPausedStatus, _operatorSetParams, _minimumStakes, _strategyParams) +// Solidity: function initialize(address initialOwner, address churnApprover, address ejector, uint256 initialPausedStatus, address avs) returns() +func (_EORegistryCoordinator *EORegistryCoordinatorTransactorSession) Initialize(initialOwner common.Address, churnApprover common.Address, ejector common.Address, initialPausedStatus *big.Int, avs common.Address) (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.Initialize(&_EORegistryCoordinator.TransactOpts, initialOwner, churnApprover, ejector, initialPausedStatus, avs) } // Pause is a paid mutator transaction binding the contract method 0x136439dd. // // Solidity: function pause(uint256 newPausedStatus) returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorTransactor) Pause(opts *bind.TransactOpts, newPausedStatus *big.Int) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.contract.Transact(opts, "pause", newPausedStatus) +func (_EORegistryCoordinator *EORegistryCoordinatorTransactor) Pause(opts *bind.TransactOpts, newPausedStatus *big.Int) (*types.Transaction, error) { + return _EORegistryCoordinator.contract.Transact(opts, "pause", newPausedStatus) } // Pause is a paid mutator transaction binding the contract method 0x136439dd. // // Solidity: function pause(uint256 newPausedStatus) returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorSession) Pause(newPausedStatus *big.Int) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.Contract.Pause(&_ContractEORegistryCoordinator.TransactOpts, newPausedStatus) +func (_EORegistryCoordinator *EORegistryCoordinatorSession) Pause(newPausedStatus *big.Int) (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.Pause(&_EORegistryCoordinator.TransactOpts, newPausedStatus) } // Pause is a paid mutator transaction binding the contract method 0x136439dd. // // Solidity: function pause(uint256 newPausedStatus) returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorTransactorSession) Pause(newPausedStatus *big.Int) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.Contract.Pause(&_ContractEORegistryCoordinator.TransactOpts, newPausedStatus) +func (_EORegistryCoordinator *EORegistryCoordinatorTransactorSession) Pause(newPausedStatus *big.Int) (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.Pause(&_EORegistryCoordinator.TransactOpts, newPausedStatus) } // PauseAll is a paid mutator transaction binding the contract method 0x595c6a67. // // Solidity: function pauseAll() returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorTransactor) PauseAll(opts *bind.TransactOpts) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.contract.Transact(opts, "pauseAll") +func (_EORegistryCoordinator *EORegistryCoordinatorTransactor) PauseAll(opts *bind.TransactOpts) (*types.Transaction, error) { + return _EORegistryCoordinator.contract.Transact(opts, "pauseAll") } // PauseAll is a paid mutator transaction binding the contract method 0x595c6a67. // // Solidity: function pauseAll() returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorSession) PauseAll() (*types.Transaction, error) { - return _ContractEORegistryCoordinator.Contract.PauseAll(&_ContractEORegistryCoordinator.TransactOpts) +func (_EORegistryCoordinator *EORegistryCoordinatorSession) PauseAll() (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.PauseAll(&_EORegistryCoordinator.TransactOpts) } // PauseAll is a paid mutator transaction binding the contract method 0x595c6a67. // // Solidity: function pauseAll() returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorTransactorSession) PauseAll() (*types.Transaction, error) { - return _ContractEORegistryCoordinator.Contract.PauseAll(&_ContractEORegistryCoordinator.TransactOpts) +func (_EORegistryCoordinator *EORegistryCoordinatorTransactorSession) PauseAll() (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.PauseAll(&_EORegistryCoordinator.TransactOpts) +} + +// RegisterOperator is a paid mutator transaction binding the contract method 0xa50857bf. +// +// Solidity: function registerOperator(bytes quorumNumbers, string socket, ((uint256,uint256),(uint256,uint256),(uint256[2],uint256[2])) params, (bytes,bytes32,uint256) operatorSignature) returns() +func (_EORegistryCoordinator *EORegistryCoordinatorTransactor) RegisterOperator(opts *bind.TransactOpts, quorumNumbers []byte, socket string, params IBLSApkRegistryTypesPubkeyRegistrationParams, operatorSignature ISignatureUtilsMixinTypesSignatureWithSaltAndExpiry) (*types.Transaction, error) { + return _EORegistryCoordinator.contract.Transact(opts, "registerOperator", quorumNumbers, socket, params, operatorSignature) +} + +// RegisterOperator is a paid mutator transaction binding the contract method 0xa50857bf. +// +// Solidity: function registerOperator(bytes quorumNumbers, string socket, ((uint256,uint256),(uint256,uint256),(uint256[2],uint256[2])) params, (bytes,bytes32,uint256) operatorSignature) returns() +func (_EORegistryCoordinator *EORegistryCoordinatorSession) RegisterOperator(quorumNumbers []byte, socket string, params IBLSApkRegistryTypesPubkeyRegistrationParams, operatorSignature ISignatureUtilsMixinTypesSignatureWithSaltAndExpiry) (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.RegisterOperator(&_EORegistryCoordinator.TransactOpts, quorumNumbers, socket, params, operatorSignature) +} + +// RegisterOperator is a paid mutator transaction binding the contract method 0xa50857bf. +// +// Solidity: function registerOperator(bytes quorumNumbers, string socket, ((uint256,uint256),(uint256,uint256),(uint256[2],uint256[2])) params, (bytes,bytes32,uint256) operatorSignature) returns() +func (_EORegistryCoordinator *EORegistryCoordinatorTransactorSession) RegisterOperator(quorumNumbers []byte, socket string, params IBLSApkRegistryTypesPubkeyRegistrationParams, operatorSignature ISignatureUtilsMixinTypesSignatureWithSaltAndExpiry) (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.RegisterOperator(&_EORegistryCoordinator.TransactOpts, quorumNumbers, socket, params, operatorSignature) } -// RegisterOperator is a paid mutator transaction binding the contract method 0x1615700a. +// RegisterOperator0 is a paid mutator transaction binding the contract method 0xc63fd502. // -// Solidity: function registerOperator(bytes quorumNumbers, ((uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256[2],uint256[2])) params, (bytes,bytes32,uint256) operatorSignature) returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorTransactor) RegisterOperator(opts *bind.TransactOpts, quorumNumbers []byte, params IEOBLSApkRegistryPubkeyRegistrationParams, operatorSignature ISignatureUtilsSignatureWithSaltAndExpiry) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.contract.Transact(opts, "registerOperator", quorumNumbers, params, operatorSignature) +// Solidity: function registerOperator(address operator, address avs, uint32[] operatorSetIds, bytes data) returns() +func (_EORegistryCoordinator *EORegistryCoordinatorTransactor) RegisterOperator0(opts *bind.TransactOpts, operator common.Address, avs common.Address, operatorSetIds []uint32, data []byte) (*types.Transaction, error) { + return _EORegistryCoordinator.contract.Transact(opts, "registerOperator0", operator, avs, operatorSetIds, data) } -// RegisterOperator is a paid mutator transaction binding the contract method 0x1615700a. +// RegisterOperator0 is a paid mutator transaction binding the contract method 0xc63fd502. // -// Solidity: function registerOperator(bytes quorumNumbers, ((uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256[2],uint256[2])) params, (bytes,bytes32,uint256) operatorSignature) returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorSession) RegisterOperator(quorumNumbers []byte, params IEOBLSApkRegistryPubkeyRegistrationParams, operatorSignature ISignatureUtilsSignatureWithSaltAndExpiry) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.Contract.RegisterOperator(&_ContractEORegistryCoordinator.TransactOpts, quorumNumbers, params, operatorSignature) +// Solidity: function registerOperator(address operator, address avs, uint32[] operatorSetIds, bytes data) returns() +func (_EORegistryCoordinator *EORegistryCoordinatorSession) RegisterOperator0(operator common.Address, avs common.Address, operatorSetIds []uint32, data []byte) (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.RegisterOperator0(&_EORegistryCoordinator.TransactOpts, operator, avs, operatorSetIds, data) } -// RegisterOperator is a paid mutator transaction binding the contract method 0x1615700a. +// RegisterOperator0 is a paid mutator transaction binding the contract method 0xc63fd502. // -// Solidity: function registerOperator(bytes quorumNumbers, ((uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256[2],uint256[2])) params, (bytes,bytes32,uint256) operatorSignature) returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorTransactorSession) RegisterOperator(quorumNumbers []byte, params IEOBLSApkRegistryPubkeyRegistrationParams, operatorSignature ISignatureUtilsSignatureWithSaltAndExpiry) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.Contract.RegisterOperator(&_ContractEORegistryCoordinator.TransactOpts, quorumNumbers, params, operatorSignature) +// Solidity: function registerOperator(address operator, address avs, uint32[] operatorSetIds, bytes data) returns() +func (_EORegistryCoordinator *EORegistryCoordinatorTransactorSession) RegisterOperator0(operator common.Address, avs common.Address, operatorSetIds []uint32, data []byte) (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.RegisterOperator0(&_EORegistryCoordinator.TransactOpts, operator, avs, operatorSetIds, data) } -// RegisterOperatorWithChurn is a paid mutator transaction binding the contract method 0x993252b4. +// RegisterOperatorWithChurn is a paid mutator transaction binding the contract method 0x9b5d177b. // -// Solidity: function registerOperatorWithChurn(bytes quorumNumbers, ((uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256[2],uint256[2])) params, (uint8,address)[] operatorKickParams, (bytes,bytes32,uint256) churnApproverSignature, (bytes,bytes32,uint256) operatorSignature) returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorTransactor) RegisterOperatorWithChurn(opts *bind.TransactOpts, quorumNumbers []byte, params IEOBLSApkRegistryPubkeyRegistrationParams, operatorKickParams []IEORegistryCoordinatorOperatorKickParam, churnApproverSignature ISignatureUtilsSignatureWithSaltAndExpiry, operatorSignature ISignatureUtilsSignatureWithSaltAndExpiry) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.contract.Transact(opts, "registerOperatorWithChurn", quorumNumbers, params, operatorKickParams, churnApproverSignature, operatorSignature) +// Solidity: function registerOperatorWithChurn(bytes quorumNumbers, string socket, ((uint256,uint256),(uint256,uint256),(uint256[2],uint256[2])) params, (uint8,address)[] operatorKickParams, (bytes,bytes32,uint256) churnApproverSignature, (bytes,bytes32,uint256) operatorSignature) returns() +func (_EORegistryCoordinator *EORegistryCoordinatorTransactor) RegisterOperatorWithChurn(opts *bind.TransactOpts, quorumNumbers []byte, socket string, params IBLSApkRegistryTypesPubkeyRegistrationParams, operatorKickParams []ISlashingRegistryCoordinatorTypesOperatorKickParam, churnApproverSignature ISignatureUtilsMixinTypesSignatureWithSaltAndExpiry, operatorSignature ISignatureUtilsMixinTypesSignatureWithSaltAndExpiry) (*types.Transaction, error) { + return _EORegistryCoordinator.contract.Transact(opts, "registerOperatorWithChurn", quorumNumbers, socket, params, operatorKickParams, churnApproverSignature, operatorSignature) } -// RegisterOperatorWithChurn is a paid mutator transaction binding the contract method 0x993252b4. +// RegisterOperatorWithChurn is a paid mutator transaction binding the contract method 0x9b5d177b. // -// Solidity: function registerOperatorWithChurn(bytes quorumNumbers, ((uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256[2],uint256[2])) params, (uint8,address)[] operatorKickParams, (bytes,bytes32,uint256) churnApproverSignature, (bytes,bytes32,uint256) operatorSignature) returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorSession) RegisterOperatorWithChurn(quorumNumbers []byte, params IEOBLSApkRegistryPubkeyRegistrationParams, operatorKickParams []IEORegistryCoordinatorOperatorKickParam, churnApproverSignature ISignatureUtilsSignatureWithSaltAndExpiry, operatorSignature ISignatureUtilsSignatureWithSaltAndExpiry) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.Contract.RegisterOperatorWithChurn(&_ContractEORegistryCoordinator.TransactOpts, quorumNumbers, params, operatorKickParams, churnApproverSignature, operatorSignature) +// Solidity: function registerOperatorWithChurn(bytes quorumNumbers, string socket, ((uint256,uint256),(uint256,uint256),(uint256[2],uint256[2])) params, (uint8,address)[] operatorKickParams, (bytes,bytes32,uint256) churnApproverSignature, (bytes,bytes32,uint256) operatorSignature) returns() +func (_EORegistryCoordinator *EORegistryCoordinatorSession) RegisterOperatorWithChurn(quorumNumbers []byte, socket string, params IBLSApkRegistryTypesPubkeyRegistrationParams, operatorKickParams []ISlashingRegistryCoordinatorTypesOperatorKickParam, churnApproverSignature ISignatureUtilsMixinTypesSignatureWithSaltAndExpiry, operatorSignature ISignatureUtilsMixinTypesSignatureWithSaltAndExpiry) (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.RegisterOperatorWithChurn(&_EORegistryCoordinator.TransactOpts, quorumNumbers, socket, params, operatorKickParams, churnApproverSignature, operatorSignature) } -// RegisterOperatorWithChurn is a paid mutator transaction binding the contract method 0x993252b4. +// RegisterOperatorWithChurn is a paid mutator transaction binding the contract method 0x9b5d177b. // -// Solidity: function registerOperatorWithChurn(bytes quorumNumbers, ((uint256,uint256),(uint256,uint256),(uint256,uint256),(uint256[2],uint256[2])) params, (uint8,address)[] operatorKickParams, (bytes,bytes32,uint256) churnApproverSignature, (bytes,bytes32,uint256) operatorSignature) returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorTransactorSession) RegisterOperatorWithChurn(quorumNumbers []byte, params IEOBLSApkRegistryPubkeyRegistrationParams, operatorKickParams []IEORegistryCoordinatorOperatorKickParam, churnApproverSignature ISignatureUtilsSignatureWithSaltAndExpiry, operatorSignature ISignatureUtilsSignatureWithSaltAndExpiry) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.Contract.RegisterOperatorWithChurn(&_ContractEORegistryCoordinator.TransactOpts, quorumNumbers, params, operatorKickParams, churnApproverSignature, operatorSignature) +// Solidity: function registerOperatorWithChurn(bytes quorumNumbers, string socket, ((uint256,uint256),(uint256,uint256),(uint256[2],uint256[2])) params, (uint8,address)[] operatorKickParams, (bytes,bytes32,uint256) churnApproverSignature, (bytes,bytes32,uint256) operatorSignature) returns() +func (_EORegistryCoordinator *EORegistryCoordinatorTransactorSession) RegisterOperatorWithChurn(quorumNumbers []byte, socket string, params IBLSApkRegistryTypesPubkeyRegistrationParams, operatorKickParams []ISlashingRegistryCoordinatorTypesOperatorKickParam, churnApproverSignature ISignatureUtilsMixinTypesSignatureWithSaltAndExpiry, operatorSignature ISignatureUtilsMixinTypesSignatureWithSaltAndExpiry) (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.RegisterOperatorWithChurn(&_EORegistryCoordinator.TransactOpts, quorumNumbers, socket, params, operatorKickParams, churnApproverSignature, operatorSignature) } // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. // // Solidity: function renounceOwnership() returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.contract.Transact(opts, "renounceOwnership") +func (_EORegistryCoordinator *EORegistryCoordinatorTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) { + return _EORegistryCoordinator.contract.Transact(opts, "renounceOwnership") } // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. // // Solidity: function renounceOwnership() returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorSession) RenounceOwnership() (*types.Transaction, error) { - return _ContractEORegistryCoordinator.Contract.RenounceOwnership(&_ContractEORegistryCoordinator.TransactOpts) +func (_EORegistryCoordinator *EORegistryCoordinatorSession) RenounceOwnership() (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.RenounceOwnership(&_EORegistryCoordinator.TransactOpts) } // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. // // Solidity: function renounceOwnership() returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorTransactorSession) RenounceOwnership() (*types.Transaction, error) { - return _ContractEORegistryCoordinator.Contract.RenounceOwnership(&_ContractEORegistryCoordinator.TransactOpts) +func (_EORegistryCoordinator *EORegistryCoordinatorTransactorSession) RenounceOwnership() (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.RenounceOwnership(&_EORegistryCoordinator.TransactOpts) +} + +// SetAVS is a paid mutator transaction binding the contract method 0xa65497c6. +// +// Solidity: function setAVS(address _avs) returns() +func (_EORegistryCoordinator *EORegistryCoordinatorTransactor) SetAVS(opts *bind.TransactOpts, _avs common.Address) (*types.Transaction, error) { + return _EORegistryCoordinator.contract.Transact(opts, "setAVS", _avs) +} + +// SetAVS is a paid mutator transaction binding the contract method 0xa65497c6. +// +// Solidity: function setAVS(address _avs) returns() +func (_EORegistryCoordinator *EORegistryCoordinatorSession) SetAVS(_avs common.Address) (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.SetAVS(&_EORegistryCoordinator.TransactOpts, _avs) +} + +// SetAVS is a paid mutator transaction binding the contract method 0xa65497c6. +// +// Solidity: function setAVS(address _avs) returns() +func (_EORegistryCoordinator *EORegistryCoordinatorTransactorSession) SetAVS(_avs common.Address) (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.SetAVS(&_EORegistryCoordinator.TransactOpts, _avs) +} + +// SetChainManager is a paid mutator transaction binding the contract method 0xd70cf0ed. +// +// Solidity: function setChainManager(address newChainManager) returns() +func (_EORegistryCoordinator *EORegistryCoordinatorTransactor) SetChainManager(opts *bind.TransactOpts, newChainManager common.Address) (*types.Transaction, error) { + return _EORegistryCoordinator.contract.Transact(opts, "setChainManager", newChainManager) +} + +// SetChainManager is a paid mutator transaction binding the contract method 0xd70cf0ed. +// +// Solidity: function setChainManager(address newChainManager) returns() +func (_EORegistryCoordinator *EORegistryCoordinatorSession) SetChainManager(newChainManager common.Address) (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.SetChainManager(&_EORegistryCoordinator.TransactOpts, newChainManager) +} + +// SetChainManager is a paid mutator transaction binding the contract method 0xd70cf0ed. +// +// Solidity: function setChainManager(address newChainManager) returns() +func (_EORegistryCoordinator *EORegistryCoordinatorTransactorSession) SetChainManager(newChainManager common.Address) (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.SetChainManager(&_EORegistryCoordinator.TransactOpts, newChainManager) } // SetChurnApprover is a paid mutator transaction binding the contract method 0x29d1e0c3. // // Solidity: function setChurnApprover(address _churnApprover) returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorTransactor) SetChurnApprover(opts *bind.TransactOpts, _churnApprover common.Address) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.contract.Transact(opts, "setChurnApprover", _churnApprover) +func (_EORegistryCoordinator *EORegistryCoordinatorTransactor) SetChurnApprover(opts *bind.TransactOpts, _churnApprover common.Address) (*types.Transaction, error) { + return _EORegistryCoordinator.contract.Transact(opts, "setChurnApprover", _churnApprover) } // SetChurnApprover is a paid mutator transaction binding the contract method 0x29d1e0c3. // // Solidity: function setChurnApprover(address _churnApprover) returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorSession) SetChurnApprover(_churnApprover common.Address) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.Contract.SetChurnApprover(&_ContractEORegistryCoordinator.TransactOpts, _churnApprover) +func (_EORegistryCoordinator *EORegistryCoordinatorSession) SetChurnApprover(_churnApprover common.Address) (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.SetChurnApprover(&_EORegistryCoordinator.TransactOpts, _churnApprover) } // SetChurnApprover is a paid mutator transaction binding the contract method 0x29d1e0c3. // // Solidity: function setChurnApprover(address _churnApprover) returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorTransactorSession) SetChurnApprover(_churnApprover common.Address) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.Contract.SetChurnApprover(&_ContractEORegistryCoordinator.TransactOpts, _churnApprover) +func (_EORegistryCoordinator *EORegistryCoordinatorTransactorSession) SetChurnApprover(_churnApprover common.Address) (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.SetChurnApprover(&_EORegistryCoordinator.TransactOpts, _churnApprover) } -// SetEOChainManager is a paid mutator transaction binding the contract method 0xa65f39e1. +// SetEjectionCooldown is a paid mutator transaction binding the contract method 0x0d3f2134. // -// Solidity: function setEOChainManager(address _EOChainManager) returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorTransactor) SetEOChainManager(opts *bind.TransactOpts, _EOChainManager common.Address) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.contract.Transact(opts, "setEOChainManager", _EOChainManager) +// Solidity: function setEjectionCooldown(uint256 _ejectionCooldown) returns() +func (_EORegistryCoordinator *EORegistryCoordinatorTransactor) SetEjectionCooldown(opts *bind.TransactOpts, _ejectionCooldown *big.Int) (*types.Transaction, error) { + return _EORegistryCoordinator.contract.Transact(opts, "setEjectionCooldown", _ejectionCooldown) } -// SetEOChainManager is a paid mutator transaction binding the contract method 0xa65f39e1. +// SetEjectionCooldown is a paid mutator transaction binding the contract method 0x0d3f2134. // -// Solidity: function setEOChainManager(address _EOChainManager) returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorSession) SetEOChainManager(_EOChainManager common.Address) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.Contract.SetEOChainManager(&_ContractEORegistryCoordinator.TransactOpts, _EOChainManager) +// Solidity: function setEjectionCooldown(uint256 _ejectionCooldown) returns() +func (_EORegistryCoordinator *EORegistryCoordinatorSession) SetEjectionCooldown(_ejectionCooldown *big.Int) (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.SetEjectionCooldown(&_EORegistryCoordinator.TransactOpts, _ejectionCooldown) } -// SetEOChainManager is a paid mutator transaction binding the contract method 0xa65f39e1. +// SetEjectionCooldown is a paid mutator transaction binding the contract method 0x0d3f2134. // -// Solidity: function setEOChainManager(address _EOChainManager) returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorTransactorSession) SetEOChainManager(_EOChainManager common.Address) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.Contract.SetEOChainManager(&_ContractEORegistryCoordinator.TransactOpts, _EOChainManager) +// Solidity: function setEjectionCooldown(uint256 _ejectionCooldown) returns() +func (_EORegistryCoordinator *EORegistryCoordinatorTransactorSession) SetEjectionCooldown(_ejectionCooldown *big.Int) (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.SetEjectionCooldown(&_EORegistryCoordinator.TransactOpts, _ejectionCooldown) } // SetEjector is a paid mutator transaction binding the contract method 0x2cdd1e86. // // Solidity: function setEjector(address _ejector) returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorTransactor) SetEjector(opts *bind.TransactOpts, _ejector common.Address) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.contract.Transact(opts, "setEjector", _ejector) +func (_EORegistryCoordinator *EORegistryCoordinatorTransactor) SetEjector(opts *bind.TransactOpts, _ejector common.Address) (*types.Transaction, error) { + return _EORegistryCoordinator.contract.Transact(opts, "setEjector", _ejector) } // SetEjector is a paid mutator transaction binding the contract method 0x2cdd1e86. // // Solidity: function setEjector(address _ejector) returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorSession) SetEjector(_ejector common.Address) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.Contract.SetEjector(&_ContractEORegistryCoordinator.TransactOpts, _ejector) +func (_EORegistryCoordinator *EORegistryCoordinatorSession) SetEjector(_ejector common.Address) (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.SetEjector(&_EORegistryCoordinator.TransactOpts, _ejector) } // SetEjector is a paid mutator transaction binding the contract method 0x2cdd1e86. // // Solidity: function setEjector(address _ejector) returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorTransactorSession) SetEjector(_ejector common.Address) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.Contract.SetEjector(&_ContractEORegistryCoordinator.TransactOpts, _ejector) +func (_EORegistryCoordinator *EORegistryCoordinatorTransactorSession) SetEjector(_ejector common.Address) (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.SetEjector(&_EORegistryCoordinator.TransactOpts, _ejector) } // SetOperatorSetParams is a paid mutator transaction binding the contract method 0x5b0b829f. // // Solidity: function setOperatorSetParams(uint8 quorumNumber, (uint32,uint16,uint16) operatorSetParams) returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorTransactor) SetOperatorSetParams(opts *bind.TransactOpts, quorumNumber uint8, operatorSetParams IEORegistryCoordinatorOperatorSetParam) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.contract.Transact(opts, "setOperatorSetParams", quorumNumber, operatorSetParams) +func (_EORegistryCoordinator *EORegistryCoordinatorTransactor) SetOperatorSetParams(opts *bind.TransactOpts, quorumNumber uint8, operatorSetParams ISlashingRegistryCoordinatorTypesOperatorSetParam) (*types.Transaction, error) { + return _EORegistryCoordinator.contract.Transact(opts, "setOperatorSetParams", quorumNumber, operatorSetParams) } // SetOperatorSetParams is a paid mutator transaction binding the contract method 0x5b0b829f. // // Solidity: function setOperatorSetParams(uint8 quorumNumber, (uint32,uint16,uint16) operatorSetParams) returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorSession) SetOperatorSetParams(quorumNumber uint8, operatorSetParams IEORegistryCoordinatorOperatorSetParam) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.Contract.SetOperatorSetParams(&_ContractEORegistryCoordinator.TransactOpts, quorumNumber, operatorSetParams) +func (_EORegistryCoordinator *EORegistryCoordinatorSession) SetOperatorSetParams(quorumNumber uint8, operatorSetParams ISlashingRegistryCoordinatorTypesOperatorSetParam) (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.SetOperatorSetParams(&_EORegistryCoordinator.TransactOpts, quorumNumber, operatorSetParams) } // SetOperatorSetParams is a paid mutator transaction binding the contract method 0x5b0b829f. // // Solidity: function setOperatorSetParams(uint8 quorumNumber, (uint32,uint16,uint16) operatorSetParams) returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorTransactorSession) SetOperatorSetParams(quorumNumber uint8, operatorSetParams IEORegistryCoordinatorOperatorSetParam) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.Contract.SetOperatorSetParams(&_ContractEORegistryCoordinator.TransactOpts, quorumNumber, operatorSetParams) -} - -// SetPauserRegistry is a paid mutator transaction binding the contract method 0x10d67a2f. -// -// Solidity: function setPauserRegistry(address newPauserRegistry) returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorTransactor) SetPauserRegistry(opts *bind.TransactOpts, newPauserRegistry common.Address) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.contract.Transact(opts, "setPauserRegistry", newPauserRegistry) -} - -// SetPauserRegistry is a paid mutator transaction binding the contract method 0x10d67a2f. -// -// Solidity: function setPauserRegistry(address newPauserRegistry) returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorSession) SetPauserRegistry(newPauserRegistry common.Address) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.Contract.SetPauserRegistry(&_ContractEORegistryCoordinator.TransactOpts, newPauserRegistry) -} - -// SetPauserRegistry is a paid mutator transaction binding the contract method 0x10d67a2f. -// -// Solidity: function setPauserRegistry(address newPauserRegistry) returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorTransactorSession) SetPauserRegistry(newPauserRegistry common.Address) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.Contract.SetPauserRegistry(&_ContractEORegistryCoordinator.TransactOpts, newPauserRegistry) +func (_EORegistryCoordinator *EORegistryCoordinatorTransactorSession) SetOperatorSetParams(quorumNumber uint8, operatorSetParams ISlashingRegistryCoordinatorTypesOperatorSetParam) (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.SetOperatorSetParams(&_EORegistryCoordinator.TransactOpts, quorumNumber, operatorSetParams) } // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. // // Solidity: function transferOwnership(address newOwner) returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.contract.Transact(opts, "transferOwnership", newOwner) +func (_EORegistryCoordinator *EORegistryCoordinatorTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { + return _EORegistryCoordinator.contract.Transact(opts, "transferOwnership", newOwner) } // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. // // Solidity: function transferOwnership(address newOwner) returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.Contract.TransferOwnership(&_ContractEORegistryCoordinator.TransactOpts, newOwner) +func (_EORegistryCoordinator *EORegistryCoordinatorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.TransferOwnership(&_EORegistryCoordinator.TransactOpts, newOwner) } // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. // // Solidity: function transferOwnership(address newOwner) returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.Contract.TransferOwnership(&_ContractEORegistryCoordinator.TransactOpts, newOwner) +func (_EORegistryCoordinator *EORegistryCoordinatorTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.TransferOwnership(&_EORegistryCoordinator.TransactOpts, newOwner) } // Unpause is a paid mutator transaction binding the contract method 0xfabc1cbc. // // Solidity: function unpause(uint256 newPausedStatus) returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorTransactor) Unpause(opts *bind.TransactOpts, newPausedStatus *big.Int) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.contract.Transact(opts, "unpause", newPausedStatus) +func (_EORegistryCoordinator *EORegistryCoordinatorTransactor) Unpause(opts *bind.TransactOpts, newPausedStatus *big.Int) (*types.Transaction, error) { + return _EORegistryCoordinator.contract.Transact(opts, "unpause", newPausedStatus) } // Unpause is a paid mutator transaction binding the contract method 0xfabc1cbc. // // Solidity: function unpause(uint256 newPausedStatus) returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorSession) Unpause(newPausedStatus *big.Int) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.Contract.Unpause(&_ContractEORegistryCoordinator.TransactOpts, newPausedStatus) +func (_EORegistryCoordinator *EORegistryCoordinatorSession) Unpause(newPausedStatus *big.Int) (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.Unpause(&_EORegistryCoordinator.TransactOpts, newPausedStatus) } // Unpause is a paid mutator transaction binding the contract method 0xfabc1cbc. // // Solidity: function unpause(uint256 newPausedStatus) returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorTransactorSession) Unpause(newPausedStatus *big.Int) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.Contract.Unpause(&_ContractEORegistryCoordinator.TransactOpts, newPausedStatus) +func (_EORegistryCoordinator *EORegistryCoordinatorTransactorSession) Unpause(newPausedStatus *big.Int) (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.Unpause(&_EORegistryCoordinator.TransactOpts, newPausedStatus) +} + +// UpdateOperators is a paid mutator transaction binding the contract method 0x00cf2ab5. +// +// Solidity: function updateOperators(address[] operators) returns() +func (_EORegistryCoordinator *EORegistryCoordinatorTransactor) UpdateOperators(opts *bind.TransactOpts, operators []common.Address) (*types.Transaction, error) { + return _EORegistryCoordinator.contract.Transact(opts, "updateOperators", operators) +} + +// UpdateOperators is a paid mutator transaction binding the contract method 0x00cf2ab5. +// +// Solidity: function updateOperators(address[] operators) returns() +func (_EORegistryCoordinator *EORegistryCoordinatorSession) UpdateOperators(operators []common.Address) (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.UpdateOperators(&_EORegistryCoordinator.TransactOpts, operators) } // UpdateOperators is a paid mutator transaction binding the contract method 0x00cf2ab5. // // Solidity: function updateOperators(address[] operators) returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorTransactor) UpdateOperators(opts *bind.TransactOpts, operators []common.Address) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.contract.Transact(opts, "updateOperators", operators) +func (_EORegistryCoordinator *EORegistryCoordinatorTransactorSession) UpdateOperators(operators []common.Address) (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.UpdateOperators(&_EORegistryCoordinator.TransactOpts, operators) +} + +// UpdateOperatorsForQuorum is a paid mutator transaction binding the contract method 0x5140a548. +// +// Solidity: function updateOperatorsForQuorum(address[][] operatorsPerQuorum, bytes quorumNumbers) returns() +func (_EORegistryCoordinator *EORegistryCoordinatorTransactor) UpdateOperatorsForQuorum(opts *bind.TransactOpts, operatorsPerQuorum [][]common.Address, quorumNumbers []byte) (*types.Transaction, error) { + return _EORegistryCoordinator.contract.Transact(opts, "updateOperatorsForQuorum", operatorsPerQuorum, quorumNumbers) +} + +// UpdateOperatorsForQuorum is a paid mutator transaction binding the contract method 0x5140a548. +// +// Solidity: function updateOperatorsForQuorum(address[][] operatorsPerQuorum, bytes quorumNumbers) returns() +func (_EORegistryCoordinator *EORegistryCoordinatorSession) UpdateOperatorsForQuorum(operatorsPerQuorum [][]common.Address, quorumNumbers []byte) (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.UpdateOperatorsForQuorum(&_EORegistryCoordinator.TransactOpts, operatorsPerQuorum, quorumNumbers) +} + +// UpdateOperatorsForQuorum is a paid mutator transaction binding the contract method 0x5140a548. +// +// Solidity: function updateOperatorsForQuorum(address[][] operatorsPerQuorum, bytes quorumNumbers) returns() +func (_EORegistryCoordinator *EORegistryCoordinatorTransactorSession) UpdateOperatorsForQuorum(operatorsPerQuorum [][]common.Address, quorumNumbers []byte) (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.UpdateOperatorsForQuorum(&_EORegistryCoordinator.TransactOpts, operatorsPerQuorum, quorumNumbers) +} + +// UpdateSocket is a paid mutator transaction binding the contract method 0x0cf4b767. +// +// Solidity: function updateSocket(string socket) returns() +func (_EORegistryCoordinator *EORegistryCoordinatorTransactor) UpdateSocket(opts *bind.TransactOpts, socket string) (*types.Transaction, error) { + return _EORegistryCoordinator.contract.Transact(opts, "updateSocket", socket) +} + +// UpdateSocket is a paid mutator transaction binding the contract method 0x0cf4b767. +// +// Solidity: function updateSocket(string socket) returns() +func (_EORegistryCoordinator *EORegistryCoordinatorSession) UpdateSocket(socket string) (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.UpdateSocket(&_EORegistryCoordinator.TransactOpts, socket) +} + +// UpdateSocket is a paid mutator transaction binding the contract method 0x0cf4b767. +// +// Solidity: function updateSocket(string socket) returns() +func (_EORegistryCoordinator *EORegistryCoordinatorTransactorSession) UpdateSocket(socket string) (*types.Transaction, error) { + return _EORegistryCoordinator.Contract.UpdateSocket(&_EORegistryCoordinator.TransactOpts, socket) +} + +// EORegistryCoordinatorAVSUpdatedIterator is returned from FilterAVSUpdated and is used to iterate over the raw logs and unpacked data for AVSUpdated events raised by the EORegistryCoordinator contract. +type EORegistryCoordinatorAVSUpdatedIterator struct { + Event *EORegistryCoordinatorAVSUpdated // 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 *EORegistryCoordinatorAVSUpdatedIterator) 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(EORegistryCoordinatorAVSUpdated) + 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(EORegistryCoordinatorAVSUpdated) + 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 *EORegistryCoordinatorAVSUpdatedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *EORegistryCoordinatorAVSUpdatedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// EORegistryCoordinatorAVSUpdated represents a AVSUpdated event raised by the EORegistryCoordinator contract. +type EORegistryCoordinatorAVSUpdated struct { + PrevAVS common.Address + NewAVS common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterAVSUpdated is a free log retrieval operation binding the contract event 0x9770f3cadfdcbb6f93af935e86047111590c3768271d237e4a2bc0b874bed693. +// +// Solidity: event AVSUpdated(address prevAVS, address newAVS) +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) FilterAVSUpdated(opts *bind.FilterOpts) (*EORegistryCoordinatorAVSUpdatedIterator, error) { + + logs, sub, err := _EORegistryCoordinator.contract.FilterLogs(opts, "AVSUpdated") + if err != nil { + return nil, err + } + return &EORegistryCoordinatorAVSUpdatedIterator{contract: _EORegistryCoordinator.contract, event: "AVSUpdated", logs: logs, sub: sub}, nil +} + +// WatchAVSUpdated is a free log subscription operation binding the contract event 0x9770f3cadfdcbb6f93af935e86047111590c3768271d237e4a2bc0b874bed693. +// +// Solidity: event AVSUpdated(address prevAVS, address newAVS) +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) WatchAVSUpdated(opts *bind.WatchOpts, sink chan<- *EORegistryCoordinatorAVSUpdated) (event.Subscription, error) { + + logs, sub, err := _EORegistryCoordinator.contract.WatchLogs(opts, "AVSUpdated") + 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(EORegistryCoordinatorAVSUpdated) + if err := _EORegistryCoordinator.contract.UnpackLog(event, "AVSUpdated", 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 +} + +// ParseAVSUpdated is a log parse operation binding the contract event 0x9770f3cadfdcbb6f93af935e86047111590c3768271d237e4a2bc0b874bed693. +// +// Solidity: event AVSUpdated(address prevAVS, address newAVS) +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) ParseAVSUpdated(log types.Log) (*EORegistryCoordinatorAVSUpdated, error) { + event := new(EORegistryCoordinatorAVSUpdated) + if err := _EORegistryCoordinator.contract.UnpackLog(event, "AVSUpdated", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// EORegistryCoordinatorChainManagerUpdatedIterator is returned from FilterChainManagerUpdated and is used to iterate over the raw logs and unpacked data for ChainManagerUpdated events raised by the EORegistryCoordinator contract. +type EORegistryCoordinatorChainManagerUpdatedIterator struct { + Event *EORegistryCoordinatorChainManagerUpdated // 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 *EORegistryCoordinatorChainManagerUpdatedIterator) 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(EORegistryCoordinatorChainManagerUpdated) + 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(EORegistryCoordinatorChainManagerUpdated) + 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 *EORegistryCoordinatorChainManagerUpdatedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *EORegistryCoordinatorChainManagerUpdatedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// EORegistryCoordinatorChainManagerUpdated represents a ChainManagerUpdated event raised by the EORegistryCoordinator contract. +type EORegistryCoordinatorChainManagerUpdated struct { + PrevChainManager common.Address + NewChainManager common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterChainManagerUpdated is a free log retrieval operation binding the contract event 0x82dba664578316cd747b8d55d907a9a79c86cc87e5f679cab0e94f1463e8979a. +// +// Solidity: event ChainManagerUpdated(address prevChainManager, address newChainManager) +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) FilterChainManagerUpdated(opts *bind.FilterOpts) (*EORegistryCoordinatorChainManagerUpdatedIterator, error) { + + logs, sub, err := _EORegistryCoordinator.contract.FilterLogs(opts, "ChainManagerUpdated") + if err != nil { + return nil, err + } + return &EORegistryCoordinatorChainManagerUpdatedIterator{contract: _EORegistryCoordinator.contract, event: "ChainManagerUpdated", logs: logs, sub: sub}, nil +} + +// WatchChainManagerUpdated is a free log subscription operation binding the contract event 0x82dba664578316cd747b8d55d907a9a79c86cc87e5f679cab0e94f1463e8979a. +// +// Solidity: event ChainManagerUpdated(address prevChainManager, address newChainManager) +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) WatchChainManagerUpdated(opts *bind.WatchOpts, sink chan<- *EORegistryCoordinatorChainManagerUpdated) (event.Subscription, error) { + + logs, sub, err := _EORegistryCoordinator.contract.WatchLogs(opts, "ChainManagerUpdated") + 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(EORegistryCoordinatorChainManagerUpdated) + if err := _EORegistryCoordinator.contract.UnpackLog(event, "ChainManagerUpdated", 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 +} + +// ParseChainManagerUpdated is a log parse operation binding the contract event 0x82dba664578316cd747b8d55d907a9a79c86cc87e5f679cab0e94f1463e8979a. +// +// Solidity: event ChainManagerUpdated(address prevChainManager, address newChainManager) +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) ParseChainManagerUpdated(log types.Log) (*EORegistryCoordinatorChainManagerUpdated, error) { + event := new(EORegistryCoordinatorChainManagerUpdated) + if err := _EORegistryCoordinator.contract.UnpackLog(event, "ChainManagerUpdated", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// EORegistryCoordinatorChurnApproverUpdatedIterator is returned from FilterChurnApproverUpdated and is used to iterate over the raw logs and unpacked data for ChurnApproverUpdated events raised by the EORegistryCoordinator contract. +type EORegistryCoordinatorChurnApproverUpdatedIterator struct { + Event *EORegistryCoordinatorChurnApproverUpdated // 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 *EORegistryCoordinatorChurnApproverUpdatedIterator) 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(EORegistryCoordinatorChurnApproverUpdated) + 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(EORegistryCoordinatorChurnApproverUpdated) + 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 *EORegistryCoordinatorChurnApproverUpdatedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *EORegistryCoordinatorChurnApproverUpdatedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// EORegistryCoordinatorChurnApproverUpdated represents a ChurnApproverUpdated event raised by the EORegistryCoordinator contract. +type EORegistryCoordinatorChurnApproverUpdated struct { + PrevChurnApprover common.Address + NewChurnApprover common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterChurnApproverUpdated is a free log retrieval operation binding the contract event 0x315457d8a8fe60f04af17c16e2f5a5e1db612b31648e58030360759ef8f3528c. +// +// Solidity: event ChurnApproverUpdated(address prevChurnApprover, address newChurnApprover) +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) FilterChurnApproverUpdated(opts *bind.FilterOpts) (*EORegistryCoordinatorChurnApproverUpdatedIterator, error) { + + logs, sub, err := _EORegistryCoordinator.contract.FilterLogs(opts, "ChurnApproverUpdated") + if err != nil { + return nil, err + } + return &EORegistryCoordinatorChurnApproverUpdatedIterator{contract: _EORegistryCoordinator.contract, event: "ChurnApproverUpdated", logs: logs, sub: sub}, nil +} + +// WatchChurnApproverUpdated is a free log subscription operation binding the contract event 0x315457d8a8fe60f04af17c16e2f5a5e1db612b31648e58030360759ef8f3528c. +// +// Solidity: event ChurnApproverUpdated(address prevChurnApprover, address newChurnApprover) +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) WatchChurnApproverUpdated(opts *bind.WatchOpts, sink chan<- *EORegistryCoordinatorChurnApproverUpdated) (event.Subscription, error) { + + logs, sub, err := _EORegistryCoordinator.contract.WatchLogs(opts, "ChurnApproverUpdated") + 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(EORegistryCoordinatorChurnApproverUpdated) + if err := _EORegistryCoordinator.contract.UnpackLog(event, "ChurnApproverUpdated", 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 +} + +// ParseChurnApproverUpdated is a log parse operation binding the contract event 0x315457d8a8fe60f04af17c16e2f5a5e1db612b31648e58030360759ef8f3528c. +// +// Solidity: event ChurnApproverUpdated(address prevChurnApprover, address newChurnApprover) +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) ParseChurnApproverUpdated(log types.Log) (*EORegistryCoordinatorChurnApproverUpdated, error) { + event := new(EORegistryCoordinatorChurnApproverUpdated) + if err := _EORegistryCoordinator.contract.UnpackLog(event, "ChurnApproverUpdated", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// EORegistryCoordinatorEIP712DomainChangedIterator is returned from FilterEIP712DomainChanged and is used to iterate over the raw logs and unpacked data for EIP712DomainChanged events raised by the EORegistryCoordinator contract. +type EORegistryCoordinatorEIP712DomainChangedIterator struct { + Event *EORegistryCoordinatorEIP712DomainChanged // 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 *EORegistryCoordinatorEIP712DomainChangedIterator) 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(EORegistryCoordinatorEIP712DomainChanged) + 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(EORegistryCoordinatorEIP712DomainChanged) + 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 *EORegistryCoordinatorEIP712DomainChangedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *EORegistryCoordinatorEIP712DomainChangedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// EORegistryCoordinatorEIP712DomainChanged represents a EIP712DomainChanged event raised by the EORegistryCoordinator contract. +type EORegistryCoordinatorEIP712DomainChanged struct { + Raw types.Log // Blockchain specific contextual infos +} + +// FilterEIP712DomainChanged is a free log retrieval operation binding the contract event 0x0a6387c9ea3628b88a633bb4f3b151770f70085117a15f9bf3787cda53f13d31. +// +// Solidity: event EIP712DomainChanged() +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) FilterEIP712DomainChanged(opts *bind.FilterOpts) (*EORegistryCoordinatorEIP712DomainChangedIterator, error) { + + logs, sub, err := _EORegistryCoordinator.contract.FilterLogs(opts, "EIP712DomainChanged") + if err != nil { + return nil, err + } + return &EORegistryCoordinatorEIP712DomainChangedIterator{contract: _EORegistryCoordinator.contract, event: "EIP712DomainChanged", logs: logs, sub: sub}, nil +} + +// WatchEIP712DomainChanged is a free log subscription operation binding the contract event 0x0a6387c9ea3628b88a633bb4f3b151770f70085117a15f9bf3787cda53f13d31. +// +// Solidity: event EIP712DomainChanged() +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) WatchEIP712DomainChanged(opts *bind.WatchOpts, sink chan<- *EORegistryCoordinatorEIP712DomainChanged) (event.Subscription, error) { + + logs, sub, err := _EORegistryCoordinator.contract.WatchLogs(opts, "EIP712DomainChanged") + 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(EORegistryCoordinatorEIP712DomainChanged) + if err := _EORegistryCoordinator.contract.UnpackLog(event, "EIP712DomainChanged", 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 +} + +// ParseEIP712DomainChanged is a log parse operation binding the contract event 0x0a6387c9ea3628b88a633bb4f3b151770f70085117a15f9bf3787cda53f13d31. +// +// Solidity: event EIP712DomainChanged() +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) ParseEIP712DomainChanged(log types.Log) (*EORegistryCoordinatorEIP712DomainChanged, error) { + event := new(EORegistryCoordinatorEIP712DomainChanged) + if err := _EORegistryCoordinator.contract.UnpackLog(event, "EIP712DomainChanged", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// EORegistryCoordinatorEjectionCooldownUpdatedIterator is returned from FilterEjectionCooldownUpdated and is used to iterate over the raw logs and unpacked data for EjectionCooldownUpdated events raised by the EORegistryCoordinator contract. +type EORegistryCoordinatorEjectionCooldownUpdatedIterator struct { + Event *EORegistryCoordinatorEjectionCooldownUpdated // 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 *EORegistryCoordinatorEjectionCooldownUpdatedIterator) 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(EORegistryCoordinatorEjectionCooldownUpdated) + 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(EORegistryCoordinatorEjectionCooldownUpdated) + 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 *EORegistryCoordinatorEjectionCooldownUpdatedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *EORegistryCoordinatorEjectionCooldownUpdatedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// EORegistryCoordinatorEjectionCooldownUpdated represents a EjectionCooldownUpdated event raised by the EORegistryCoordinator contract. +type EORegistryCoordinatorEjectionCooldownUpdated struct { + PrevEjectionCooldown *big.Int + NewEjectionCooldown *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterEjectionCooldownUpdated is a free log retrieval operation binding the contract event 0xa77a91bea7b6d95a8eb5a54878a1d9e3c875e26c86a9b70e3420c5c5db193b62. +// +// Solidity: event EjectionCooldownUpdated(uint256 prevEjectionCooldown, uint256 newEjectionCooldown) +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) FilterEjectionCooldownUpdated(opts *bind.FilterOpts) (*EORegistryCoordinatorEjectionCooldownUpdatedIterator, error) { + + logs, sub, err := _EORegistryCoordinator.contract.FilterLogs(opts, "EjectionCooldownUpdated") + if err != nil { + return nil, err + } + return &EORegistryCoordinatorEjectionCooldownUpdatedIterator{contract: _EORegistryCoordinator.contract, event: "EjectionCooldownUpdated", logs: logs, sub: sub}, nil +} + +// WatchEjectionCooldownUpdated is a free log subscription operation binding the contract event 0xa77a91bea7b6d95a8eb5a54878a1d9e3c875e26c86a9b70e3420c5c5db193b62. +// +// Solidity: event EjectionCooldownUpdated(uint256 prevEjectionCooldown, uint256 newEjectionCooldown) +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) WatchEjectionCooldownUpdated(opts *bind.WatchOpts, sink chan<- *EORegistryCoordinatorEjectionCooldownUpdated) (event.Subscription, error) { + + logs, sub, err := _EORegistryCoordinator.contract.WatchLogs(opts, "EjectionCooldownUpdated") + 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(EORegistryCoordinatorEjectionCooldownUpdated) + if err := _EORegistryCoordinator.contract.UnpackLog(event, "EjectionCooldownUpdated", 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 +} + +// ParseEjectionCooldownUpdated is a log parse operation binding the contract event 0xa77a91bea7b6d95a8eb5a54878a1d9e3c875e26c86a9b70e3420c5c5db193b62. +// +// Solidity: event EjectionCooldownUpdated(uint256 prevEjectionCooldown, uint256 newEjectionCooldown) +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) ParseEjectionCooldownUpdated(log types.Log) (*EORegistryCoordinatorEjectionCooldownUpdated, error) { + event := new(EORegistryCoordinatorEjectionCooldownUpdated) + if err := _EORegistryCoordinator.contract.UnpackLog(event, "EjectionCooldownUpdated", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// EORegistryCoordinatorEjectorUpdatedIterator is returned from FilterEjectorUpdated and is used to iterate over the raw logs and unpacked data for EjectorUpdated events raised by the EORegistryCoordinator contract. +type EORegistryCoordinatorEjectorUpdatedIterator struct { + Event *EORegistryCoordinatorEjectorUpdated // 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 *EORegistryCoordinatorEjectorUpdatedIterator) 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(EORegistryCoordinatorEjectorUpdated) + 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(EORegistryCoordinatorEjectorUpdated) + 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 *EORegistryCoordinatorEjectorUpdatedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *EORegistryCoordinatorEjectorUpdatedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// EORegistryCoordinatorEjectorUpdated represents a EjectorUpdated event raised by the EORegistryCoordinator contract. +type EORegistryCoordinatorEjectorUpdated struct { + PrevEjector common.Address + NewEjector common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterEjectorUpdated is a free log retrieval operation binding the contract event 0x8f30ab09f43a6c157d7fce7e0a13c003042c1c95e8a72e7a146a21c0caa24dc9. +// +// Solidity: event EjectorUpdated(address prevEjector, address newEjector) +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) FilterEjectorUpdated(opts *bind.FilterOpts) (*EORegistryCoordinatorEjectorUpdatedIterator, error) { + + logs, sub, err := _EORegistryCoordinator.contract.FilterLogs(opts, "EjectorUpdated") + if err != nil { + return nil, err + } + return &EORegistryCoordinatorEjectorUpdatedIterator{contract: _EORegistryCoordinator.contract, event: "EjectorUpdated", logs: logs, sub: sub}, nil +} + +// WatchEjectorUpdated is a free log subscription operation binding the contract event 0x8f30ab09f43a6c157d7fce7e0a13c003042c1c95e8a72e7a146a21c0caa24dc9. +// +// Solidity: event EjectorUpdated(address prevEjector, address newEjector) +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) WatchEjectorUpdated(opts *bind.WatchOpts, sink chan<- *EORegistryCoordinatorEjectorUpdated) (event.Subscription, error) { + + logs, sub, err := _EORegistryCoordinator.contract.WatchLogs(opts, "EjectorUpdated") + 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(EORegistryCoordinatorEjectorUpdated) + if err := _EORegistryCoordinator.contract.UnpackLog(event, "EjectorUpdated", 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 +} + +// ParseEjectorUpdated is a log parse operation binding the contract event 0x8f30ab09f43a6c157d7fce7e0a13c003042c1c95e8a72e7a146a21c0caa24dc9. +// +// Solidity: event EjectorUpdated(address prevEjector, address newEjector) +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) ParseEjectorUpdated(log types.Log) (*EORegistryCoordinatorEjectorUpdated, error) { + event := new(EORegistryCoordinatorEjectorUpdated) + if err := _EORegistryCoordinator.contract.UnpackLog(event, "EjectorUpdated", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// EORegistryCoordinatorInitializedIterator is returned from FilterInitialized and is used to iterate over the raw logs and unpacked data for Initialized events raised by the EORegistryCoordinator contract. +type EORegistryCoordinatorInitializedIterator struct { + Event *EORegistryCoordinatorInitialized // 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 *EORegistryCoordinatorInitializedIterator) 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(EORegistryCoordinatorInitialized) + 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(EORegistryCoordinatorInitialized) + 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 *EORegistryCoordinatorInitializedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *EORegistryCoordinatorInitializedIterator) Close() error { + it.sub.Unsubscribe() + return nil } -// UpdateOperators is a paid mutator transaction binding the contract method 0x00cf2ab5. -// -// Solidity: function updateOperators(address[] operators) returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorSession) UpdateOperators(operators []common.Address) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.Contract.UpdateOperators(&_ContractEORegistryCoordinator.TransactOpts, operators) +// EORegistryCoordinatorInitialized represents a Initialized event raised by the EORegistryCoordinator contract. +type EORegistryCoordinatorInitialized struct { + Version uint8 + Raw types.Log // Blockchain specific contextual infos } -// UpdateOperators is a paid mutator transaction binding the contract method 0x00cf2ab5. +// FilterInitialized is a free log retrieval operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. // -// Solidity: function updateOperators(address[] operators) returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorTransactorSession) UpdateOperators(operators []common.Address) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.Contract.UpdateOperators(&_ContractEORegistryCoordinator.TransactOpts, operators) -} +// Solidity: event Initialized(uint8 version) +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) FilterInitialized(opts *bind.FilterOpts) (*EORegistryCoordinatorInitializedIterator, error) { -// UpdateOperatorsForQuorum is a paid mutator transaction binding the contract method 0x5140a548. -// -// Solidity: function updateOperatorsForQuorum(address[][] operatorsPerQuorum, bytes quorumNumbers) returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorTransactor) UpdateOperatorsForQuorum(opts *bind.TransactOpts, operatorsPerQuorum [][]common.Address, quorumNumbers []byte) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.contract.Transact(opts, "updateOperatorsForQuorum", operatorsPerQuorum, quorumNumbers) + logs, sub, err := _EORegistryCoordinator.contract.FilterLogs(opts, "Initialized") + if err != nil { + return nil, err + } + return &EORegistryCoordinatorInitializedIterator{contract: _EORegistryCoordinator.contract, event: "Initialized", logs: logs, sub: sub}, nil } -// UpdateOperatorsForQuorum is a paid mutator transaction binding the contract method 0x5140a548. +// WatchInitialized is a free log subscription operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. // -// Solidity: function updateOperatorsForQuorum(address[][] operatorsPerQuorum, bytes quorumNumbers) returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorSession) UpdateOperatorsForQuorum(operatorsPerQuorum [][]common.Address, quorumNumbers []byte) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.Contract.UpdateOperatorsForQuorum(&_ContractEORegistryCoordinator.TransactOpts, operatorsPerQuorum, quorumNumbers) +// Solidity: event Initialized(uint8 version) +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *EORegistryCoordinatorInitialized) (event.Subscription, error) { + + logs, sub, err := _EORegistryCoordinator.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(EORegistryCoordinatorInitialized) + if err := _EORegistryCoordinator.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 } -// UpdateOperatorsForQuorum is a paid mutator transaction binding the contract method 0x5140a548. +// ParseInitialized is a log parse operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. // -// Solidity: function updateOperatorsForQuorum(address[][] operatorsPerQuorum, bytes quorumNumbers) returns() -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorTransactorSession) UpdateOperatorsForQuorum(operatorsPerQuorum [][]common.Address, quorumNumbers []byte) (*types.Transaction, error) { - return _ContractEORegistryCoordinator.Contract.UpdateOperatorsForQuorum(&_ContractEORegistryCoordinator.TransactOpts, operatorsPerQuorum, quorumNumbers) +// Solidity: event Initialized(uint8 version) +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) ParseInitialized(log types.Log) (*EORegistryCoordinatorInitialized, error) { + event := new(EORegistryCoordinatorInitialized) + if err := _EORegistryCoordinator.contract.UnpackLog(event, "Initialized", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil } -// ContractEORegistryCoordinatorChurnApproverUpdatedIterator is returned from FilterChurnApproverUpdated and is used to iterate over the raw logs and unpacked data for ChurnApproverUpdated events raised by the ContractEORegistryCoordinator contract. -type ContractEORegistryCoordinatorChurnApproverUpdatedIterator struct { - Event *ContractEORegistryCoordinatorChurnApproverUpdated // Event containing the contract specifics and raw log +// EORegistryCoordinatorM2QuorumRegistrationDisabledIterator is returned from FilterM2QuorumRegistrationDisabled and is used to iterate over the raw logs and unpacked data for M2QuorumRegistrationDisabled events raised by the EORegistryCoordinator contract. +type EORegistryCoordinatorM2QuorumRegistrationDisabledIterator struct { + Event *EORegistryCoordinatorM2QuorumRegistrationDisabled // 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 @@ -1753,7 +3057,7 @@ type ContractEORegistryCoordinatorChurnApproverUpdatedIterator struct { // 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 *ContractEORegistryCoordinatorChurnApproverUpdatedIterator) Next() bool { +func (it *EORegistryCoordinatorM2QuorumRegistrationDisabledIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -1762,7 +3066,7 @@ func (it *ContractEORegistryCoordinatorChurnApproverUpdatedIterator) Next() bool if it.done { select { case log := <-it.logs: - it.Event = new(ContractEORegistryCoordinatorChurnApproverUpdated) + it.Event = new(EORegistryCoordinatorM2QuorumRegistrationDisabled) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1777,7 +3081,7 @@ func (it *ContractEORegistryCoordinatorChurnApproverUpdatedIterator) Next() bool // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(ContractEORegistryCoordinatorChurnApproverUpdated) + it.Event = new(EORegistryCoordinatorM2QuorumRegistrationDisabled) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1793,42 +3097,40 @@ func (it *ContractEORegistryCoordinatorChurnApproverUpdatedIterator) Next() bool } // Error returns any retrieval or parsing error occurred during filtering. -func (it *ContractEORegistryCoordinatorChurnApproverUpdatedIterator) Error() error { +func (it *EORegistryCoordinatorM2QuorumRegistrationDisabledIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *ContractEORegistryCoordinatorChurnApproverUpdatedIterator) Close() error { +func (it *EORegistryCoordinatorM2QuorumRegistrationDisabledIterator) Close() error { it.sub.Unsubscribe() return nil } -// ContractEORegistryCoordinatorChurnApproverUpdated represents a ChurnApproverUpdated event raised by the ContractEORegistryCoordinator contract. -type ContractEORegistryCoordinatorChurnApproverUpdated struct { - PrevChurnApprover common.Address - NewChurnApprover common.Address - Raw types.Log // Blockchain specific contextual infos +// EORegistryCoordinatorM2QuorumRegistrationDisabled represents a M2QuorumRegistrationDisabled event raised by the EORegistryCoordinator contract. +type EORegistryCoordinatorM2QuorumRegistrationDisabled struct { + Raw types.Log // Blockchain specific contextual infos } -// FilterChurnApproverUpdated is a free log retrieval operation binding the contract event 0x315457d8a8fe60f04af17c16e2f5a5e1db612b31648e58030360759ef8f3528c. +// FilterM2QuorumRegistrationDisabled is a free log retrieval operation binding the contract event 0x0fc3c0e6f8b4795f371e19de7f4c5733dd9e549fa8c39e5842eb66c31572d99e. // -// Solidity: event ChurnApproverUpdated(address prevChurnApprover, address newChurnApprover) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) FilterChurnApproverUpdated(opts *bind.FilterOpts) (*ContractEORegistryCoordinatorChurnApproverUpdatedIterator, error) { +// Solidity: event M2QuorumRegistrationDisabled() +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) FilterM2QuorumRegistrationDisabled(opts *bind.FilterOpts) (*EORegistryCoordinatorM2QuorumRegistrationDisabledIterator, error) { - logs, sub, err := _ContractEORegistryCoordinator.contract.FilterLogs(opts, "ChurnApproverUpdated") + logs, sub, err := _EORegistryCoordinator.contract.FilterLogs(opts, "M2QuorumRegistrationDisabled") if err != nil { return nil, err } - return &ContractEORegistryCoordinatorChurnApproverUpdatedIterator{contract: _ContractEORegistryCoordinator.contract, event: "ChurnApproverUpdated", logs: logs, sub: sub}, nil + return &EORegistryCoordinatorM2QuorumRegistrationDisabledIterator{contract: _EORegistryCoordinator.contract, event: "M2QuorumRegistrationDisabled", logs: logs, sub: sub}, nil } -// WatchChurnApproverUpdated is a free log subscription operation binding the contract event 0x315457d8a8fe60f04af17c16e2f5a5e1db612b31648e58030360759ef8f3528c. +// WatchM2QuorumRegistrationDisabled is a free log subscription operation binding the contract event 0x0fc3c0e6f8b4795f371e19de7f4c5733dd9e549fa8c39e5842eb66c31572d99e. // -// Solidity: event ChurnApproverUpdated(address prevChurnApprover, address newChurnApprover) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) WatchChurnApproverUpdated(opts *bind.WatchOpts, sink chan<- *ContractEORegistryCoordinatorChurnApproverUpdated) (event.Subscription, error) { +// Solidity: event M2QuorumRegistrationDisabled() +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) WatchM2QuorumRegistrationDisabled(opts *bind.WatchOpts, sink chan<- *EORegistryCoordinatorM2QuorumRegistrationDisabled) (event.Subscription, error) { - logs, sub, err := _ContractEORegistryCoordinator.contract.WatchLogs(opts, "ChurnApproverUpdated") + logs, sub, err := _EORegistryCoordinator.contract.WatchLogs(opts, "M2QuorumRegistrationDisabled") if err != nil { return nil, err } @@ -1838,8 +3140,8 @@ func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) Wat select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(ContractEORegistryCoordinatorChurnApproverUpdated) - if err := _ContractEORegistryCoordinator.contract.UnpackLog(event, "ChurnApproverUpdated", log); err != nil { + event := new(EORegistryCoordinatorM2QuorumRegistrationDisabled) + if err := _EORegistryCoordinator.contract.UnpackLog(event, "M2QuorumRegistrationDisabled", log); err != nil { return err } event.Raw = log @@ -1860,21 +3162,21 @@ func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) Wat }), nil } -// ParseChurnApproverUpdated is a log parse operation binding the contract event 0x315457d8a8fe60f04af17c16e2f5a5e1db612b31648e58030360759ef8f3528c. +// ParseM2QuorumRegistrationDisabled is a log parse operation binding the contract event 0x0fc3c0e6f8b4795f371e19de7f4c5733dd9e549fa8c39e5842eb66c31572d99e. // -// Solidity: event ChurnApproverUpdated(address prevChurnApprover, address newChurnApprover) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) ParseChurnApproverUpdated(log types.Log) (*ContractEORegistryCoordinatorChurnApproverUpdated, error) { - event := new(ContractEORegistryCoordinatorChurnApproverUpdated) - if err := _ContractEORegistryCoordinator.contract.UnpackLog(event, "ChurnApproverUpdated", log); err != nil { +// Solidity: event M2QuorumRegistrationDisabled() +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) ParseM2QuorumRegistrationDisabled(log types.Log) (*EORegistryCoordinatorM2QuorumRegistrationDisabled, error) { + event := new(EORegistryCoordinatorM2QuorumRegistrationDisabled) + if err := _EORegistryCoordinator.contract.UnpackLog(event, "M2QuorumRegistrationDisabled", log); err != nil { return nil, err } event.Raw = log return event, nil } -// ContractEORegistryCoordinatorEjectorUpdatedIterator is returned from FilterEjectorUpdated and is used to iterate over the raw logs and unpacked data for EjectorUpdated events raised by the ContractEORegistryCoordinator contract. -type ContractEORegistryCoordinatorEjectorUpdatedIterator struct { - Event *ContractEORegistryCoordinatorEjectorUpdated // Event containing the contract specifics and raw log +// EORegistryCoordinatorOperatorDeregisteredIterator is returned from FilterOperatorDeregistered and is used to iterate over the raw logs and unpacked data for OperatorDeregistered events raised by the EORegistryCoordinator contract. +type EORegistryCoordinatorOperatorDeregisteredIterator struct { + Event *EORegistryCoordinatorOperatorDeregistered // 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 @@ -1888,7 +3190,7 @@ type ContractEORegistryCoordinatorEjectorUpdatedIterator struct { // 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 *ContractEORegistryCoordinatorEjectorUpdatedIterator) Next() bool { +func (it *EORegistryCoordinatorOperatorDeregisteredIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -1897,7 +3199,7 @@ func (it *ContractEORegistryCoordinatorEjectorUpdatedIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(ContractEORegistryCoordinatorEjectorUpdated) + it.Event = new(EORegistryCoordinatorOperatorDeregistered) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1912,7 +3214,7 @@ func (it *ContractEORegistryCoordinatorEjectorUpdatedIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(ContractEORegistryCoordinatorEjectorUpdated) + it.Event = new(EORegistryCoordinatorOperatorDeregistered) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1928,42 +3230,60 @@ func (it *ContractEORegistryCoordinatorEjectorUpdatedIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *ContractEORegistryCoordinatorEjectorUpdatedIterator) Error() error { +func (it *EORegistryCoordinatorOperatorDeregisteredIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *ContractEORegistryCoordinatorEjectorUpdatedIterator) Close() error { +func (it *EORegistryCoordinatorOperatorDeregisteredIterator) Close() error { it.sub.Unsubscribe() return nil } -// ContractEORegistryCoordinatorEjectorUpdated represents a EjectorUpdated event raised by the ContractEORegistryCoordinator contract. -type ContractEORegistryCoordinatorEjectorUpdated struct { - PrevEjector common.Address - NewEjector common.Address - Raw types.Log // Blockchain specific contextual infos +// EORegistryCoordinatorOperatorDeregistered represents a OperatorDeregistered event raised by the EORegistryCoordinator contract. +type EORegistryCoordinatorOperatorDeregistered struct { + Operator common.Address + OperatorId [32]byte + Raw types.Log // Blockchain specific contextual infos } -// FilterEjectorUpdated is a free log retrieval operation binding the contract event 0x8f30ab09f43a6c157d7fce7e0a13c003042c1c95e8a72e7a146a21c0caa24dc9. +// FilterOperatorDeregistered is a free log retrieval operation binding the contract event 0x396fdcb180cb0fea26928113fb0fd1c3549863f9cd563e6a184f1d578116c8e4. // -// Solidity: event EjectorUpdated(address prevEjector, address newEjector) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) FilterEjectorUpdated(opts *bind.FilterOpts) (*ContractEORegistryCoordinatorEjectorUpdatedIterator, error) { +// Solidity: event OperatorDeregistered(address indexed operator, bytes32 indexed operatorId) +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) FilterOperatorDeregistered(opts *bind.FilterOpts, operator []common.Address, operatorId [][32]byte) (*EORegistryCoordinatorOperatorDeregisteredIterator, error) { + + var operatorRule []interface{} + for _, operatorItem := range operator { + operatorRule = append(operatorRule, operatorItem) + } + var operatorIdRule []interface{} + for _, operatorIdItem := range operatorId { + operatorIdRule = append(operatorIdRule, operatorIdItem) + } - logs, sub, err := _ContractEORegistryCoordinator.contract.FilterLogs(opts, "EjectorUpdated") + logs, sub, err := _EORegistryCoordinator.contract.FilterLogs(opts, "OperatorDeregistered", operatorRule, operatorIdRule) if err != nil { return nil, err } - return &ContractEORegistryCoordinatorEjectorUpdatedIterator{contract: _ContractEORegistryCoordinator.contract, event: "EjectorUpdated", logs: logs, sub: sub}, nil + return &EORegistryCoordinatorOperatorDeregisteredIterator{contract: _EORegistryCoordinator.contract, event: "OperatorDeregistered", logs: logs, sub: sub}, nil } -// WatchEjectorUpdated is a free log subscription operation binding the contract event 0x8f30ab09f43a6c157d7fce7e0a13c003042c1c95e8a72e7a146a21c0caa24dc9. +// WatchOperatorDeregistered is a free log subscription operation binding the contract event 0x396fdcb180cb0fea26928113fb0fd1c3549863f9cd563e6a184f1d578116c8e4. // -// Solidity: event EjectorUpdated(address prevEjector, address newEjector) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) WatchEjectorUpdated(opts *bind.WatchOpts, sink chan<- *ContractEORegistryCoordinatorEjectorUpdated) (event.Subscription, error) { +// Solidity: event OperatorDeregistered(address indexed operator, bytes32 indexed operatorId) +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) WatchOperatorDeregistered(opts *bind.WatchOpts, sink chan<- *EORegistryCoordinatorOperatorDeregistered, operator []common.Address, operatorId [][32]byte) (event.Subscription, error) { + + var operatorRule []interface{} + for _, operatorItem := range operator { + operatorRule = append(operatorRule, operatorItem) + } + var operatorIdRule []interface{} + for _, operatorIdItem := range operatorId { + operatorIdRule = append(operatorIdRule, operatorIdItem) + } - logs, sub, err := _ContractEORegistryCoordinator.contract.WatchLogs(opts, "EjectorUpdated") + logs, sub, err := _EORegistryCoordinator.contract.WatchLogs(opts, "OperatorDeregistered", operatorRule, operatorIdRule) if err != nil { return nil, err } @@ -1973,8 +3293,8 @@ func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) Wat select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(ContractEORegistryCoordinatorEjectorUpdated) - if err := _ContractEORegistryCoordinator.contract.UnpackLog(event, "EjectorUpdated", log); err != nil { + event := new(EORegistryCoordinatorOperatorDeregistered) + if err := _EORegistryCoordinator.contract.UnpackLog(event, "OperatorDeregistered", log); err != nil { return err } event.Raw = log @@ -1995,21 +3315,21 @@ func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) Wat }), nil } -// ParseEjectorUpdated is a log parse operation binding the contract event 0x8f30ab09f43a6c157d7fce7e0a13c003042c1c95e8a72e7a146a21c0caa24dc9. +// ParseOperatorDeregistered is a log parse operation binding the contract event 0x396fdcb180cb0fea26928113fb0fd1c3549863f9cd563e6a184f1d578116c8e4. // -// Solidity: event EjectorUpdated(address prevEjector, address newEjector) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) ParseEjectorUpdated(log types.Log) (*ContractEORegistryCoordinatorEjectorUpdated, error) { - event := new(ContractEORegistryCoordinatorEjectorUpdated) - if err := _ContractEORegistryCoordinator.contract.UnpackLog(event, "EjectorUpdated", log); err != nil { +// Solidity: event OperatorDeregistered(address indexed operator, bytes32 indexed operatorId) +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) ParseOperatorDeregistered(log types.Log) (*EORegistryCoordinatorOperatorDeregistered, error) { + event := new(EORegistryCoordinatorOperatorDeregistered) + if err := _EORegistryCoordinator.contract.UnpackLog(event, "OperatorDeregistered", log); err != nil { return nil, err } event.Raw = log return event, nil } -// ContractEORegistryCoordinatorInitializedIterator is returned from FilterInitialized and is used to iterate over the raw logs and unpacked data for Initialized events raised by the ContractEORegistryCoordinator contract. -type ContractEORegistryCoordinatorInitializedIterator struct { - Event *ContractEORegistryCoordinatorInitialized // Event containing the contract specifics and raw log +// EORegistryCoordinatorOperatorRegisteredIterator is returned from FilterOperatorRegistered and is used to iterate over the raw logs and unpacked data for OperatorRegistered events raised by the EORegistryCoordinator contract. +type EORegistryCoordinatorOperatorRegisteredIterator struct { + Event *EORegistryCoordinatorOperatorRegistered // 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 @@ -2023,7 +3343,7 @@ type ContractEORegistryCoordinatorInitializedIterator struct { // 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 *ContractEORegistryCoordinatorInitializedIterator) Next() bool { +func (it *EORegistryCoordinatorOperatorRegisteredIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -2032,7 +3352,7 @@ func (it *ContractEORegistryCoordinatorInitializedIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(ContractEORegistryCoordinatorInitialized) + it.Event = new(EORegistryCoordinatorOperatorRegistered) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -2047,7 +3367,7 @@ func (it *ContractEORegistryCoordinatorInitializedIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(ContractEORegistryCoordinatorInitialized) + it.Event = new(EORegistryCoordinatorOperatorRegistered) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -2063,41 +3383,60 @@ func (it *ContractEORegistryCoordinatorInitializedIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *ContractEORegistryCoordinatorInitializedIterator) Error() error { +func (it *EORegistryCoordinatorOperatorRegisteredIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *ContractEORegistryCoordinatorInitializedIterator) Close() error { +func (it *EORegistryCoordinatorOperatorRegisteredIterator) Close() error { it.sub.Unsubscribe() return nil } -// ContractEORegistryCoordinatorInitialized represents a Initialized event raised by the ContractEORegistryCoordinator contract. -type ContractEORegistryCoordinatorInitialized struct { - Version uint8 - Raw types.Log // Blockchain specific contextual infos +// EORegistryCoordinatorOperatorRegistered represents a OperatorRegistered event raised by the EORegistryCoordinator contract. +type EORegistryCoordinatorOperatorRegistered struct { + Operator common.Address + OperatorId [32]byte + Raw types.Log // Blockchain specific contextual infos } -// FilterInitialized is a free log retrieval operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// FilterOperatorRegistered is a free log retrieval operation binding the contract event 0xe8e68cef1c3a761ed7be7e8463a375f27f7bc335e51824223cacce636ec5c3fe. // -// Solidity: event Initialized(uint8 version) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) FilterInitialized(opts *bind.FilterOpts) (*ContractEORegistryCoordinatorInitializedIterator, error) { +// Solidity: event OperatorRegistered(address indexed operator, bytes32 indexed operatorId) +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) FilterOperatorRegistered(opts *bind.FilterOpts, operator []common.Address, operatorId [][32]byte) (*EORegistryCoordinatorOperatorRegisteredIterator, error) { - logs, sub, err := _ContractEORegistryCoordinator.contract.FilterLogs(opts, "Initialized") + var operatorRule []interface{} + for _, operatorItem := range operator { + operatorRule = append(operatorRule, operatorItem) + } + var operatorIdRule []interface{} + for _, operatorIdItem := range operatorId { + operatorIdRule = append(operatorIdRule, operatorIdItem) + } + + logs, sub, err := _EORegistryCoordinator.contract.FilterLogs(opts, "OperatorRegistered", operatorRule, operatorIdRule) if err != nil { return nil, err } - return &ContractEORegistryCoordinatorInitializedIterator{contract: _ContractEORegistryCoordinator.contract, event: "Initialized", logs: logs, sub: sub}, nil + return &EORegistryCoordinatorOperatorRegisteredIterator{contract: _EORegistryCoordinator.contract, event: "OperatorRegistered", logs: logs, sub: sub}, nil } -// WatchInitialized is a free log subscription operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// WatchOperatorRegistered is a free log subscription operation binding the contract event 0xe8e68cef1c3a761ed7be7e8463a375f27f7bc335e51824223cacce636ec5c3fe. // -// Solidity: event Initialized(uint8 version) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *ContractEORegistryCoordinatorInitialized) (event.Subscription, error) { +// Solidity: event OperatorRegistered(address indexed operator, bytes32 indexed operatorId) +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) WatchOperatorRegistered(opts *bind.WatchOpts, sink chan<- *EORegistryCoordinatorOperatorRegistered, operator []common.Address, operatorId [][32]byte) (event.Subscription, error) { + + var operatorRule []interface{} + for _, operatorItem := range operator { + operatorRule = append(operatorRule, operatorItem) + } + var operatorIdRule []interface{} + for _, operatorIdItem := range operatorId { + operatorIdRule = append(operatorIdRule, operatorIdItem) + } - logs, sub, err := _ContractEORegistryCoordinator.contract.WatchLogs(opts, "Initialized") + logs, sub, err := _EORegistryCoordinator.contract.WatchLogs(opts, "OperatorRegistered", operatorRule, operatorIdRule) if err != nil { return nil, err } @@ -2107,8 +3446,8 @@ func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) Wat select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(ContractEORegistryCoordinatorInitialized) - if err := _ContractEORegistryCoordinator.contract.UnpackLog(event, "Initialized", log); err != nil { + event := new(EORegistryCoordinatorOperatorRegistered) + if err := _EORegistryCoordinator.contract.UnpackLog(event, "OperatorRegistered", log); err != nil { return err } event.Raw = log @@ -2129,21 +3468,21 @@ func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) Wat }), nil } -// ParseInitialized is a log parse operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// ParseOperatorRegistered is a log parse operation binding the contract event 0xe8e68cef1c3a761ed7be7e8463a375f27f7bc335e51824223cacce636ec5c3fe. // -// Solidity: event Initialized(uint8 version) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) ParseInitialized(log types.Log) (*ContractEORegistryCoordinatorInitialized, error) { - event := new(ContractEORegistryCoordinatorInitialized) - if err := _ContractEORegistryCoordinator.contract.UnpackLog(event, "Initialized", log); err != nil { +// Solidity: event OperatorRegistered(address indexed operator, bytes32 indexed operatorId) +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) ParseOperatorRegistered(log types.Log) (*EORegistryCoordinatorOperatorRegistered, error) { + event := new(EORegistryCoordinatorOperatorRegistered) + if err := _EORegistryCoordinator.contract.UnpackLog(event, "OperatorRegistered", log); err != nil { return nil, err } event.Raw = log return event, nil } -// ContractEORegistryCoordinatorOperatorDeregisteredIterator is returned from FilterOperatorDeregistered and is used to iterate over the raw logs and unpacked data for OperatorDeregistered events raised by the ContractEORegistryCoordinator contract. -type ContractEORegistryCoordinatorOperatorDeregisteredIterator struct { - Event *ContractEORegistryCoordinatorOperatorDeregistered // Event containing the contract specifics and raw log +// EORegistryCoordinatorOperatorSetParamsUpdatedIterator is returned from FilterOperatorSetParamsUpdated and is used to iterate over the raw logs and unpacked data for OperatorSetParamsUpdated events raised by the EORegistryCoordinator contract. +type EORegistryCoordinatorOperatorSetParamsUpdatedIterator struct { + Event *EORegistryCoordinatorOperatorSetParamsUpdated // 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 @@ -2157,7 +3496,7 @@ type ContractEORegistryCoordinatorOperatorDeregisteredIterator struct { // 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 *ContractEORegistryCoordinatorOperatorDeregisteredIterator) Next() bool { +func (it *EORegistryCoordinatorOperatorSetParamsUpdatedIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -2166,7 +3505,7 @@ func (it *ContractEORegistryCoordinatorOperatorDeregisteredIterator) Next() bool if it.done { select { case log := <-it.logs: - it.Event = new(ContractEORegistryCoordinatorOperatorDeregistered) + it.Event = new(EORegistryCoordinatorOperatorSetParamsUpdated) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -2181,7 +3520,7 @@ func (it *ContractEORegistryCoordinatorOperatorDeregisteredIterator) Next() bool // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(ContractEORegistryCoordinatorOperatorDeregistered) + it.Event = new(EORegistryCoordinatorOperatorSetParamsUpdated) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -2197,60 +3536,52 @@ func (it *ContractEORegistryCoordinatorOperatorDeregisteredIterator) Next() bool } // Error returns any retrieval or parsing error occurred during filtering. -func (it *ContractEORegistryCoordinatorOperatorDeregisteredIterator) Error() error { +func (it *EORegistryCoordinatorOperatorSetParamsUpdatedIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *ContractEORegistryCoordinatorOperatorDeregisteredIterator) Close() error { +func (it *EORegistryCoordinatorOperatorSetParamsUpdatedIterator) Close() error { it.sub.Unsubscribe() return nil } -// ContractEORegistryCoordinatorOperatorDeregistered represents a OperatorDeregistered event raised by the ContractEORegistryCoordinator contract. -type ContractEORegistryCoordinatorOperatorDeregistered struct { - Operator common.Address - OperatorId [32]byte - Raw types.Log // Blockchain specific contextual infos +// EORegistryCoordinatorOperatorSetParamsUpdated represents a OperatorSetParamsUpdated event raised by the EORegistryCoordinator contract. +type EORegistryCoordinatorOperatorSetParamsUpdated struct { + QuorumNumber uint8 + OperatorSetParams ISlashingRegistryCoordinatorTypesOperatorSetParam + Raw types.Log // Blockchain specific contextual infos } -// FilterOperatorDeregistered is a free log retrieval operation binding the contract event 0x396fdcb180cb0fea26928113fb0fd1c3549863f9cd563e6a184f1d578116c8e4. +// FilterOperatorSetParamsUpdated is a free log retrieval operation binding the contract event 0x3ee6fe8d54610244c3e9d3c066ae4aee997884aa28f10616ae821925401318ac. // -// Solidity: event OperatorDeregistered(address indexed operator, bytes32 indexed operatorId) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) FilterOperatorDeregistered(opts *bind.FilterOpts, operator []common.Address, operatorId [][32]byte) (*ContractEORegistryCoordinatorOperatorDeregisteredIterator, error) { +// Solidity: event OperatorSetParamsUpdated(uint8 indexed quorumNumber, (uint32,uint16,uint16) operatorSetParams) +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) FilterOperatorSetParamsUpdated(opts *bind.FilterOpts, quorumNumber []uint8) (*EORegistryCoordinatorOperatorSetParamsUpdatedIterator, error) { - var operatorRule []interface{} - for _, operatorItem := range operator { - operatorRule = append(operatorRule, operatorItem) - } - var operatorIdRule []interface{} - for _, operatorIdItem := range operatorId { - operatorIdRule = append(operatorIdRule, operatorIdItem) + var quorumNumberRule []interface{} + for _, quorumNumberItem := range quorumNumber { + quorumNumberRule = append(quorumNumberRule, quorumNumberItem) } - logs, sub, err := _ContractEORegistryCoordinator.contract.FilterLogs(opts, "OperatorDeregistered", operatorRule, operatorIdRule) + logs, sub, err := _EORegistryCoordinator.contract.FilterLogs(opts, "OperatorSetParamsUpdated", quorumNumberRule) if err != nil { return nil, err } - return &ContractEORegistryCoordinatorOperatorDeregisteredIterator{contract: _ContractEORegistryCoordinator.contract, event: "OperatorDeregistered", logs: logs, sub: sub}, nil + return &EORegistryCoordinatorOperatorSetParamsUpdatedIterator{contract: _EORegistryCoordinator.contract, event: "OperatorSetParamsUpdated", logs: logs, sub: sub}, nil } -// WatchOperatorDeregistered is a free log subscription operation binding the contract event 0x396fdcb180cb0fea26928113fb0fd1c3549863f9cd563e6a184f1d578116c8e4. +// WatchOperatorSetParamsUpdated is a free log subscription operation binding the contract event 0x3ee6fe8d54610244c3e9d3c066ae4aee997884aa28f10616ae821925401318ac. // -// Solidity: event OperatorDeregistered(address indexed operator, bytes32 indexed operatorId) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) WatchOperatorDeregistered(opts *bind.WatchOpts, sink chan<- *ContractEORegistryCoordinatorOperatorDeregistered, operator []common.Address, operatorId [][32]byte) (event.Subscription, error) { +// Solidity: event OperatorSetParamsUpdated(uint8 indexed quorumNumber, (uint32,uint16,uint16) operatorSetParams) +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) WatchOperatorSetParamsUpdated(opts *bind.WatchOpts, sink chan<- *EORegistryCoordinatorOperatorSetParamsUpdated, quorumNumber []uint8) (event.Subscription, error) { - var operatorRule []interface{} - for _, operatorItem := range operator { - operatorRule = append(operatorRule, operatorItem) - } - var operatorIdRule []interface{} - for _, operatorIdItem := range operatorId { - operatorIdRule = append(operatorIdRule, operatorIdItem) + var quorumNumberRule []interface{} + for _, quorumNumberItem := range quorumNumber { + quorumNumberRule = append(quorumNumberRule, quorumNumberItem) } - logs, sub, err := _ContractEORegistryCoordinator.contract.WatchLogs(opts, "OperatorDeregistered", operatorRule, operatorIdRule) + logs, sub, err := _EORegistryCoordinator.contract.WatchLogs(opts, "OperatorSetParamsUpdated", quorumNumberRule) if err != nil { return nil, err } @@ -2260,8 +3591,8 @@ func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) Wat select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(ContractEORegistryCoordinatorOperatorDeregistered) - if err := _ContractEORegistryCoordinator.contract.UnpackLog(event, "OperatorDeregistered", log); err != nil { + event := new(EORegistryCoordinatorOperatorSetParamsUpdated) + if err := _EORegistryCoordinator.contract.UnpackLog(event, "OperatorSetParamsUpdated", log); err != nil { return err } event.Raw = log @@ -2282,21 +3613,21 @@ func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) Wat }), nil } -// ParseOperatorDeregistered is a log parse operation binding the contract event 0x396fdcb180cb0fea26928113fb0fd1c3549863f9cd563e6a184f1d578116c8e4. +// ParseOperatorSetParamsUpdated is a log parse operation binding the contract event 0x3ee6fe8d54610244c3e9d3c066ae4aee997884aa28f10616ae821925401318ac. // -// Solidity: event OperatorDeregistered(address indexed operator, bytes32 indexed operatorId) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) ParseOperatorDeregistered(log types.Log) (*ContractEORegistryCoordinatorOperatorDeregistered, error) { - event := new(ContractEORegistryCoordinatorOperatorDeregistered) - if err := _ContractEORegistryCoordinator.contract.UnpackLog(event, "OperatorDeregistered", log); err != nil { +// Solidity: event OperatorSetParamsUpdated(uint8 indexed quorumNumber, (uint32,uint16,uint16) operatorSetParams) +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) ParseOperatorSetParamsUpdated(log types.Log) (*EORegistryCoordinatorOperatorSetParamsUpdated, error) { + event := new(EORegistryCoordinatorOperatorSetParamsUpdated) + if err := _EORegistryCoordinator.contract.UnpackLog(event, "OperatorSetParamsUpdated", log); err != nil { return nil, err } event.Raw = log return event, nil } -// ContractEORegistryCoordinatorOperatorRegisteredIterator is returned from FilterOperatorRegistered and is used to iterate over the raw logs and unpacked data for OperatorRegistered events raised by the ContractEORegistryCoordinator contract. -type ContractEORegistryCoordinatorOperatorRegisteredIterator struct { - Event *ContractEORegistryCoordinatorOperatorRegistered // Event containing the contract specifics and raw log +// EORegistryCoordinatorOperatorSetsEnabledIterator is returned from FilterOperatorSetsEnabled and is used to iterate over the raw logs and unpacked data for OperatorSetsEnabled events raised by the EORegistryCoordinator contract. +type EORegistryCoordinatorOperatorSetsEnabledIterator struct { + Event *EORegistryCoordinatorOperatorSetsEnabled // 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 @@ -2310,7 +3641,7 @@ type ContractEORegistryCoordinatorOperatorRegisteredIterator struct { // 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 *ContractEORegistryCoordinatorOperatorRegisteredIterator) Next() bool { +func (it *EORegistryCoordinatorOperatorSetsEnabledIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -2319,7 +3650,7 @@ func (it *ContractEORegistryCoordinatorOperatorRegisteredIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(ContractEORegistryCoordinatorOperatorRegistered) + it.Event = new(EORegistryCoordinatorOperatorSetsEnabled) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -2334,7 +3665,7 @@ func (it *ContractEORegistryCoordinatorOperatorRegisteredIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(ContractEORegistryCoordinatorOperatorRegistered) + it.Event = new(EORegistryCoordinatorOperatorSetsEnabled) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -2350,60 +3681,40 @@ func (it *ContractEORegistryCoordinatorOperatorRegisteredIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *ContractEORegistryCoordinatorOperatorRegisteredIterator) Error() error { +func (it *EORegistryCoordinatorOperatorSetsEnabledIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *ContractEORegistryCoordinatorOperatorRegisteredIterator) Close() error { +func (it *EORegistryCoordinatorOperatorSetsEnabledIterator) Close() error { it.sub.Unsubscribe() return nil } -// ContractEORegistryCoordinatorOperatorRegistered represents a OperatorRegistered event raised by the ContractEORegistryCoordinator contract. -type ContractEORegistryCoordinatorOperatorRegistered struct { - Operator common.Address - OperatorId [32]byte - Raw types.Log // Blockchain specific contextual infos +// EORegistryCoordinatorOperatorSetsEnabled represents a OperatorSetsEnabled event raised by the EORegistryCoordinator contract. +type EORegistryCoordinatorOperatorSetsEnabled struct { + Raw types.Log // Blockchain specific contextual infos } -// FilterOperatorRegistered is a free log retrieval operation binding the contract event 0xe8e68cef1c3a761ed7be7e8463a375f27f7bc335e51824223cacce636ec5c3fe. +// FilterOperatorSetsEnabled is a free log retrieval operation binding the contract event 0x0b88306ff4627121f5b3e5b1c5f88f6b1e42fd2c0478ef1c91662d49d1f07755. // -// Solidity: event OperatorRegistered(address indexed operator, bytes32 indexed operatorId) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) FilterOperatorRegistered(opts *bind.FilterOpts, operator []common.Address, operatorId [][32]byte) (*ContractEORegistryCoordinatorOperatorRegisteredIterator, error) { - - var operatorRule []interface{} - for _, operatorItem := range operator { - operatorRule = append(operatorRule, operatorItem) - } - var operatorIdRule []interface{} - for _, operatorIdItem := range operatorId { - operatorIdRule = append(operatorIdRule, operatorIdItem) - } +// Solidity: event OperatorSetsEnabled() +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) FilterOperatorSetsEnabled(opts *bind.FilterOpts) (*EORegistryCoordinatorOperatorSetsEnabledIterator, error) { - logs, sub, err := _ContractEORegistryCoordinator.contract.FilterLogs(opts, "OperatorRegistered", operatorRule, operatorIdRule) + logs, sub, err := _EORegistryCoordinator.contract.FilterLogs(opts, "OperatorSetsEnabled") if err != nil { return nil, err } - return &ContractEORegistryCoordinatorOperatorRegisteredIterator{contract: _ContractEORegistryCoordinator.contract, event: "OperatorRegistered", logs: logs, sub: sub}, nil + return &EORegistryCoordinatorOperatorSetsEnabledIterator{contract: _EORegistryCoordinator.contract, event: "OperatorSetsEnabled", logs: logs, sub: sub}, nil } -// WatchOperatorRegistered is a free log subscription operation binding the contract event 0xe8e68cef1c3a761ed7be7e8463a375f27f7bc335e51824223cacce636ec5c3fe. +// WatchOperatorSetsEnabled is a free log subscription operation binding the contract event 0x0b88306ff4627121f5b3e5b1c5f88f6b1e42fd2c0478ef1c91662d49d1f07755. // -// Solidity: event OperatorRegistered(address indexed operator, bytes32 indexed operatorId) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) WatchOperatorRegistered(opts *bind.WatchOpts, sink chan<- *ContractEORegistryCoordinatorOperatorRegistered, operator []common.Address, operatorId [][32]byte) (event.Subscription, error) { - - var operatorRule []interface{} - for _, operatorItem := range operator { - operatorRule = append(operatorRule, operatorItem) - } - var operatorIdRule []interface{} - for _, operatorIdItem := range operatorId { - operatorIdRule = append(operatorIdRule, operatorIdItem) - } +// Solidity: event OperatorSetsEnabled() +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) WatchOperatorSetsEnabled(opts *bind.WatchOpts, sink chan<- *EORegistryCoordinatorOperatorSetsEnabled) (event.Subscription, error) { - logs, sub, err := _ContractEORegistryCoordinator.contract.WatchLogs(opts, "OperatorRegistered", operatorRule, operatorIdRule) + logs, sub, err := _EORegistryCoordinator.contract.WatchLogs(opts, "OperatorSetsEnabled") if err != nil { return nil, err } @@ -2413,8 +3724,8 @@ func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) Wat select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(ContractEORegistryCoordinatorOperatorRegistered) - if err := _ContractEORegistryCoordinator.contract.UnpackLog(event, "OperatorRegistered", log); err != nil { + event := new(EORegistryCoordinatorOperatorSetsEnabled) + if err := _EORegistryCoordinator.contract.UnpackLog(event, "OperatorSetsEnabled", log); err != nil { return err } event.Raw = log @@ -2435,21 +3746,21 @@ func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) Wat }), nil } -// ParseOperatorRegistered is a log parse operation binding the contract event 0xe8e68cef1c3a761ed7be7e8463a375f27f7bc335e51824223cacce636ec5c3fe. +// ParseOperatorSetsEnabled is a log parse operation binding the contract event 0x0b88306ff4627121f5b3e5b1c5f88f6b1e42fd2c0478ef1c91662d49d1f07755. // -// Solidity: event OperatorRegistered(address indexed operator, bytes32 indexed operatorId) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) ParseOperatorRegistered(log types.Log) (*ContractEORegistryCoordinatorOperatorRegistered, error) { - event := new(ContractEORegistryCoordinatorOperatorRegistered) - if err := _ContractEORegistryCoordinator.contract.UnpackLog(event, "OperatorRegistered", log); err != nil { +// Solidity: event OperatorSetsEnabled() +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) ParseOperatorSetsEnabled(log types.Log) (*EORegistryCoordinatorOperatorSetsEnabled, error) { + event := new(EORegistryCoordinatorOperatorSetsEnabled) + if err := _EORegistryCoordinator.contract.UnpackLog(event, "OperatorSetsEnabled", log); err != nil { return nil, err } event.Raw = log return event, nil } -// ContractEORegistryCoordinatorOperatorSetParamsUpdatedIterator is returned from FilterOperatorSetParamsUpdated and is used to iterate over the raw logs and unpacked data for OperatorSetParamsUpdated events raised by the ContractEORegistryCoordinator contract. -type ContractEORegistryCoordinatorOperatorSetParamsUpdatedIterator struct { - Event *ContractEORegistryCoordinatorOperatorSetParamsUpdated // Event containing the contract specifics and raw log +// EORegistryCoordinatorOperatorSocketUpdateIterator is returned from FilterOperatorSocketUpdate and is used to iterate over the raw logs and unpacked data for OperatorSocketUpdate events raised by the EORegistryCoordinator contract. +type EORegistryCoordinatorOperatorSocketUpdateIterator struct { + Event *EORegistryCoordinatorOperatorSocketUpdate // 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 @@ -2463,7 +3774,7 @@ type ContractEORegistryCoordinatorOperatorSetParamsUpdatedIterator struct { // 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 *ContractEORegistryCoordinatorOperatorSetParamsUpdatedIterator) Next() bool { +func (it *EORegistryCoordinatorOperatorSocketUpdateIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -2472,7 +3783,7 @@ func (it *ContractEORegistryCoordinatorOperatorSetParamsUpdatedIterator) Next() if it.done { select { case log := <-it.logs: - it.Event = new(ContractEORegistryCoordinatorOperatorSetParamsUpdated) + it.Event = new(EORegistryCoordinatorOperatorSocketUpdate) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -2487,7 +3798,7 @@ func (it *ContractEORegistryCoordinatorOperatorSetParamsUpdatedIterator) Next() // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(ContractEORegistryCoordinatorOperatorSetParamsUpdated) + it.Event = new(EORegistryCoordinatorOperatorSocketUpdate) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -2503,52 +3814,52 @@ func (it *ContractEORegistryCoordinatorOperatorSetParamsUpdatedIterator) Next() } // Error returns any retrieval or parsing error occurred during filtering. -func (it *ContractEORegistryCoordinatorOperatorSetParamsUpdatedIterator) Error() error { +func (it *EORegistryCoordinatorOperatorSocketUpdateIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *ContractEORegistryCoordinatorOperatorSetParamsUpdatedIterator) Close() error { +func (it *EORegistryCoordinatorOperatorSocketUpdateIterator) Close() error { it.sub.Unsubscribe() return nil } -// ContractEORegistryCoordinatorOperatorSetParamsUpdated represents a OperatorSetParamsUpdated event raised by the ContractEORegistryCoordinator contract. -type ContractEORegistryCoordinatorOperatorSetParamsUpdated struct { - QuorumNumber uint8 - OperatorSetParams IEORegistryCoordinatorOperatorSetParam - Raw types.Log // Blockchain specific contextual infos +// EORegistryCoordinatorOperatorSocketUpdate represents a OperatorSocketUpdate event raised by the EORegistryCoordinator contract. +type EORegistryCoordinatorOperatorSocketUpdate struct { + OperatorId [32]byte + Socket string + Raw types.Log // Blockchain specific contextual infos } -// FilterOperatorSetParamsUpdated is a free log retrieval operation binding the contract event 0x3ee6fe8d54610244c3e9d3c066ae4aee997884aa28f10616ae821925401318ac. +// FilterOperatorSocketUpdate is a free log retrieval operation binding the contract event 0xec2963ab21c1e50e1e582aa542af2e4bf7bf38e6e1403c27b42e1c5d6e621eaa. // -// Solidity: event OperatorSetParamsUpdated(uint8 indexed quorumNumber, (uint32,uint16,uint16) operatorSetParams) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) FilterOperatorSetParamsUpdated(opts *bind.FilterOpts, quorumNumber []uint8) (*ContractEORegistryCoordinatorOperatorSetParamsUpdatedIterator, error) { +// Solidity: event OperatorSocketUpdate(bytes32 indexed operatorId, string socket) +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) FilterOperatorSocketUpdate(opts *bind.FilterOpts, operatorId [][32]byte) (*EORegistryCoordinatorOperatorSocketUpdateIterator, error) { - var quorumNumberRule []interface{} - for _, quorumNumberItem := range quorumNumber { - quorumNumberRule = append(quorumNumberRule, quorumNumberItem) + var operatorIdRule []interface{} + for _, operatorIdItem := range operatorId { + operatorIdRule = append(operatorIdRule, operatorIdItem) } - logs, sub, err := _ContractEORegistryCoordinator.contract.FilterLogs(opts, "OperatorSetParamsUpdated", quorumNumberRule) + logs, sub, err := _EORegistryCoordinator.contract.FilterLogs(opts, "OperatorSocketUpdate", operatorIdRule) if err != nil { return nil, err } - return &ContractEORegistryCoordinatorOperatorSetParamsUpdatedIterator{contract: _ContractEORegistryCoordinator.contract, event: "OperatorSetParamsUpdated", logs: logs, sub: sub}, nil + return &EORegistryCoordinatorOperatorSocketUpdateIterator{contract: _EORegistryCoordinator.contract, event: "OperatorSocketUpdate", logs: logs, sub: sub}, nil } -// WatchOperatorSetParamsUpdated is a free log subscription operation binding the contract event 0x3ee6fe8d54610244c3e9d3c066ae4aee997884aa28f10616ae821925401318ac. +// WatchOperatorSocketUpdate is a free log subscription operation binding the contract event 0xec2963ab21c1e50e1e582aa542af2e4bf7bf38e6e1403c27b42e1c5d6e621eaa. // -// Solidity: event OperatorSetParamsUpdated(uint8 indexed quorumNumber, (uint32,uint16,uint16) operatorSetParams) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) WatchOperatorSetParamsUpdated(opts *bind.WatchOpts, sink chan<- *ContractEORegistryCoordinatorOperatorSetParamsUpdated, quorumNumber []uint8) (event.Subscription, error) { +// Solidity: event OperatorSocketUpdate(bytes32 indexed operatorId, string socket) +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) WatchOperatorSocketUpdate(opts *bind.WatchOpts, sink chan<- *EORegistryCoordinatorOperatorSocketUpdate, operatorId [][32]byte) (event.Subscription, error) { - var quorumNumberRule []interface{} - for _, quorumNumberItem := range quorumNumber { - quorumNumberRule = append(quorumNumberRule, quorumNumberItem) + var operatorIdRule []interface{} + for _, operatorIdItem := range operatorId { + operatorIdRule = append(operatorIdRule, operatorIdItem) } - logs, sub, err := _ContractEORegistryCoordinator.contract.WatchLogs(opts, "OperatorSetParamsUpdated", quorumNumberRule) + logs, sub, err := _EORegistryCoordinator.contract.WatchLogs(opts, "OperatorSocketUpdate", operatorIdRule) if err != nil { return nil, err } @@ -2558,8 +3869,8 @@ func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) Wat select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(ContractEORegistryCoordinatorOperatorSetParamsUpdated) - if err := _ContractEORegistryCoordinator.contract.UnpackLog(event, "OperatorSetParamsUpdated", log); err != nil { + event := new(EORegistryCoordinatorOperatorSocketUpdate) + if err := _EORegistryCoordinator.contract.UnpackLog(event, "OperatorSocketUpdate", log); err != nil { return err } event.Raw = log @@ -2580,21 +3891,21 @@ func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) Wat }), nil } -// ParseOperatorSetParamsUpdated is a log parse operation binding the contract event 0x3ee6fe8d54610244c3e9d3c066ae4aee997884aa28f10616ae821925401318ac. +// ParseOperatorSocketUpdate is a log parse operation binding the contract event 0xec2963ab21c1e50e1e582aa542af2e4bf7bf38e6e1403c27b42e1c5d6e621eaa. // -// Solidity: event OperatorSetParamsUpdated(uint8 indexed quorumNumber, (uint32,uint16,uint16) operatorSetParams) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) ParseOperatorSetParamsUpdated(log types.Log) (*ContractEORegistryCoordinatorOperatorSetParamsUpdated, error) { - event := new(ContractEORegistryCoordinatorOperatorSetParamsUpdated) - if err := _ContractEORegistryCoordinator.contract.UnpackLog(event, "OperatorSetParamsUpdated", log); err != nil { +// Solidity: event OperatorSocketUpdate(bytes32 indexed operatorId, string socket) +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) ParseOperatorSocketUpdate(log types.Log) (*EORegistryCoordinatorOperatorSocketUpdate, error) { + event := new(EORegistryCoordinatorOperatorSocketUpdate) + if err := _EORegistryCoordinator.contract.UnpackLog(event, "OperatorSocketUpdate", log); err != nil { return nil, err } event.Raw = log return event, nil } -// ContractEORegistryCoordinatorOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the ContractEORegistryCoordinator contract. -type ContractEORegistryCoordinatorOwnershipTransferredIterator struct { - Event *ContractEORegistryCoordinatorOwnershipTransferred // Event containing the contract specifics and raw log +// EORegistryCoordinatorOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the EORegistryCoordinator contract. +type EORegistryCoordinatorOwnershipTransferredIterator struct { + Event *EORegistryCoordinatorOwnershipTransferred // 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 @@ -2608,7 +3919,7 @@ type ContractEORegistryCoordinatorOwnershipTransferredIterator struct { // 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 *ContractEORegistryCoordinatorOwnershipTransferredIterator) Next() bool { +func (it *EORegistryCoordinatorOwnershipTransferredIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -2617,7 +3928,7 @@ func (it *ContractEORegistryCoordinatorOwnershipTransferredIterator) Next() bool if it.done { select { case log := <-it.logs: - it.Event = new(ContractEORegistryCoordinatorOwnershipTransferred) + it.Event = new(EORegistryCoordinatorOwnershipTransferred) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -2632,7 +3943,7 @@ func (it *ContractEORegistryCoordinatorOwnershipTransferredIterator) Next() bool // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(ContractEORegistryCoordinatorOwnershipTransferred) + it.Event = new(EORegistryCoordinatorOwnershipTransferred) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -2648,19 +3959,19 @@ func (it *ContractEORegistryCoordinatorOwnershipTransferredIterator) Next() bool } // Error returns any retrieval or parsing error occurred during filtering. -func (it *ContractEORegistryCoordinatorOwnershipTransferredIterator) Error() error { +func (it *EORegistryCoordinatorOwnershipTransferredIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *ContractEORegistryCoordinatorOwnershipTransferredIterator) Close() error { +func (it *EORegistryCoordinatorOwnershipTransferredIterator) Close() error { it.sub.Unsubscribe() return nil } -// ContractEORegistryCoordinatorOwnershipTransferred represents a OwnershipTransferred event raised by the ContractEORegistryCoordinator contract. -type ContractEORegistryCoordinatorOwnershipTransferred struct { +// EORegistryCoordinatorOwnershipTransferred represents a OwnershipTransferred event raised by the EORegistryCoordinator contract. +type EORegistryCoordinatorOwnershipTransferred struct { PreviousOwner common.Address NewOwner common.Address Raw types.Log // Blockchain specific contextual infos @@ -2669,7 +3980,7 @@ type ContractEORegistryCoordinatorOwnershipTransferred struct { // FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. // // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*ContractEORegistryCoordinatorOwnershipTransferredIterator, error) { +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*EORegistryCoordinatorOwnershipTransferredIterator, error) { var previousOwnerRule []interface{} for _, previousOwnerItem := range previousOwner { @@ -2680,17 +3991,17 @@ func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) Fil newOwnerRule = append(newOwnerRule, newOwnerItem) } - logs, sub, err := _ContractEORegistryCoordinator.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) + logs, sub, err := _EORegistryCoordinator.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) if err != nil { return nil, err } - return &ContractEORegistryCoordinatorOwnershipTransferredIterator{contract: _ContractEORegistryCoordinator.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil + return &EORegistryCoordinatorOwnershipTransferredIterator{contract: _EORegistryCoordinator.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 (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *ContractEORegistryCoordinatorOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) { +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *EORegistryCoordinatorOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) { var previousOwnerRule []interface{} for _, previousOwnerItem := range previousOwner { @@ -2701,7 +4012,7 @@ func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) Wat newOwnerRule = append(newOwnerRule, newOwnerItem) } - logs, sub, err := _ContractEORegistryCoordinator.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) + logs, sub, err := _EORegistryCoordinator.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) if err != nil { return nil, err } @@ -2711,8 +4022,8 @@ func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) Wat select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(ContractEORegistryCoordinatorOwnershipTransferred) - if err := _ContractEORegistryCoordinator.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { + event := new(EORegistryCoordinatorOwnershipTransferred) + if err := _EORegistryCoordinator.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { return err } event.Raw = log @@ -2736,18 +4047,18 @@ func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) Wat // ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. // // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) ParseOwnershipTransferred(log types.Log) (*ContractEORegistryCoordinatorOwnershipTransferred, error) { - event := new(ContractEORegistryCoordinatorOwnershipTransferred) - if err := _ContractEORegistryCoordinator.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) ParseOwnershipTransferred(log types.Log) (*EORegistryCoordinatorOwnershipTransferred, error) { + event := new(EORegistryCoordinatorOwnershipTransferred) + if err := _EORegistryCoordinator.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { return nil, err } event.Raw = log return event, nil } -// ContractEORegistryCoordinatorPausedIterator is returned from FilterPaused and is used to iterate over the raw logs and unpacked data for Paused events raised by the ContractEORegistryCoordinator contract. -type ContractEORegistryCoordinatorPausedIterator struct { - Event *ContractEORegistryCoordinatorPaused // Event containing the contract specifics and raw log +// EORegistryCoordinatorPausedIterator is returned from FilterPaused and is used to iterate over the raw logs and unpacked data for Paused events raised by the EORegistryCoordinator contract. +type EORegistryCoordinatorPausedIterator struct { + Event *EORegistryCoordinatorPaused // 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 @@ -2761,7 +4072,7 @@ type ContractEORegistryCoordinatorPausedIterator struct { // 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 *ContractEORegistryCoordinatorPausedIterator) Next() bool { +func (it *EORegistryCoordinatorPausedIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -2770,7 +4081,7 @@ func (it *ContractEORegistryCoordinatorPausedIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(ContractEORegistryCoordinatorPaused) + it.Event = new(EORegistryCoordinatorPaused) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -2785,7 +4096,7 @@ func (it *ContractEORegistryCoordinatorPausedIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(ContractEORegistryCoordinatorPaused) + it.Event = new(EORegistryCoordinatorPaused) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -2801,19 +4112,19 @@ func (it *ContractEORegistryCoordinatorPausedIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *ContractEORegistryCoordinatorPausedIterator) Error() error { +func (it *EORegistryCoordinatorPausedIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *ContractEORegistryCoordinatorPausedIterator) Close() error { +func (it *EORegistryCoordinatorPausedIterator) Close() error { it.sub.Unsubscribe() return nil } -// ContractEORegistryCoordinatorPaused represents a Paused event raised by the ContractEORegistryCoordinator contract. -type ContractEORegistryCoordinatorPaused struct { +// EORegistryCoordinatorPaused represents a Paused event raised by the EORegistryCoordinator contract. +type EORegistryCoordinatorPaused struct { Account common.Address NewPausedStatus *big.Int Raw types.Log // Blockchain specific contextual infos @@ -2822,31 +4133,31 @@ type ContractEORegistryCoordinatorPaused struct { // FilterPaused is a free log retrieval operation binding the contract event 0xab40a374bc51de372200a8bc981af8c9ecdc08dfdaef0bb6e09f88f3c616ef3d. // // Solidity: event Paused(address indexed account, uint256 newPausedStatus) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) FilterPaused(opts *bind.FilterOpts, account []common.Address) (*ContractEORegistryCoordinatorPausedIterator, error) { +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) FilterPaused(opts *bind.FilterOpts, account []common.Address) (*EORegistryCoordinatorPausedIterator, error) { var accountRule []interface{} for _, accountItem := range account { accountRule = append(accountRule, accountItem) } - logs, sub, err := _ContractEORegistryCoordinator.contract.FilterLogs(opts, "Paused", accountRule) + logs, sub, err := _EORegistryCoordinator.contract.FilterLogs(opts, "Paused", accountRule) if err != nil { return nil, err } - return &ContractEORegistryCoordinatorPausedIterator{contract: _ContractEORegistryCoordinator.contract, event: "Paused", logs: logs, sub: sub}, nil + return &EORegistryCoordinatorPausedIterator{contract: _EORegistryCoordinator.contract, event: "Paused", logs: logs, sub: sub}, nil } // WatchPaused is a free log subscription operation binding the contract event 0xab40a374bc51de372200a8bc981af8c9ecdc08dfdaef0bb6e09f88f3c616ef3d. // // Solidity: event Paused(address indexed account, uint256 newPausedStatus) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) WatchPaused(opts *bind.WatchOpts, sink chan<- *ContractEORegistryCoordinatorPaused, account []common.Address) (event.Subscription, error) { +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) WatchPaused(opts *bind.WatchOpts, sink chan<- *EORegistryCoordinatorPaused, account []common.Address) (event.Subscription, error) { var accountRule []interface{} for _, accountItem := range account { accountRule = append(accountRule, accountItem) } - logs, sub, err := _ContractEORegistryCoordinator.contract.WatchLogs(opts, "Paused", accountRule) + logs, sub, err := _EORegistryCoordinator.contract.WatchLogs(opts, "Paused", accountRule) if err != nil { return nil, err } @@ -2856,8 +4167,8 @@ func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) Wat select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(ContractEORegistryCoordinatorPaused) - if err := _ContractEORegistryCoordinator.contract.UnpackLog(event, "Paused", log); err != nil { + event := new(EORegistryCoordinatorPaused) + if err := _EORegistryCoordinator.contract.UnpackLog(event, "Paused", log); err != nil { return err } event.Raw = log @@ -2881,18 +4192,18 @@ func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) Wat // ParsePaused is a log parse operation binding the contract event 0xab40a374bc51de372200a8bc981af8c9ecdc08dfdaef0bb6e09f88f3c616ef3d. // // Solidity: event Paused(address indexed account, uint256 newPausedStatus) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) ParsePaused(log types.Log) (*ContractEORegistryCoordinatorPaused, error) { - event := new(ContractEORegistryCoordinatorPaused) - if err := _ContractEORegistryCoordinator.contract.UnpackLog(event, "Paused", log); err != nil { +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) ParsePaused(log types.Log) (*EORegistryCoordinatorPaused, error) { + event := new(EORegistryCoordinatorPaused) + if err := _EORegistryCoordinator.contract.UnpackLog(event, "Paused", log); err != nil { return nil, err } event.Raw = log return event, nil } -// ContractEORegistryCoordinatorPauserRegistrySetIterator is returned from FilterPauserRegistrySet and is used to iterate over the raw logs and unpacked data for PauserRegistrySet events raised by the ContractEORegistryCoordinator contract. -type ContractEORegistryCoordinatorPauserRegistrySetIterator struct { - Event *ContractEORegistryCoordinatorPauserRegistrySet // Event containing the contract specifics and raw log +// EORegistryCoordinatorQuorumBlockNumberUpdatedIterator is returned from FilterQuorumBlockNumberUpdated and is used to iterate over the raw logs and unpacked data for QuorumBlockNumberUpdated events raised by the EORegistryCoordinator contract. +type EORegistryCoordinatorQuorumBlockNumberUpdatedIterator struct { + Event *EORegistryCoordinatorQuorumBlockNumberUpdated // 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 @@ -2906,7 +4217,7 @@ type ContractEORegistryCoordinatorPauserRegistrySetIterator struct { // 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 *ContractEORegistryCoordinatorPauserRegistrySetIterator) Next() bool { +func (it *EORegistryCoordinatorQuorumBlockNumberUpdatedIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -2915,7 +4226,7 @@ func (it *ContractEORegistryCoordinatorPauserRegistrySetIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(ContractEORegistryCoordinatorPauserRegistrySet) + it.Event = new(EORegistryCoordinatorQuorumBlockNumberUpdated) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -2930,7 +4241,7 @@ func (it *ContractEORegistryCoordinatorPauserRegistrySetIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(ContractEORegistryCoordinatorPauserRegistrySet) + it.Event = new(EORegistryCoordinatorQuorumBlockNumberUpdated) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -2946,42 +4257,52 @@ func (it *ContractEORegistryCoordinatorPauserRegistrySetIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *ContractEORegistryCoordinatorPauserRegistrySetIterator) Error() error { +func (it *EORegistryCoordinatorQuorumBlockNumberUpdatedIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *ContractEORegistryCoordinatorPauserRegistrySetIterator) Close() error { +func (it *EORegistryCoordinatorQuorumBlockNumberUpdatedIterator) Close() error { it.sub.Unsubscribe() return nil } -// ContractEORegistryCoordinatorPauserRegistrySet represents a PauserRegistrySet event raised by the ContractEORegistryCoordinator contract. -type ContractEORegistryCoordinatorPauserRegistrySet struct { - PauserRegistry common.Address - NewPauserRegistry common.Address - Raw types.Log // Blockchain specific contextual infos +// EORegistryCoordinatorQuorumBlockNumberUpdated represents a QuorumBlockNumberUpdated event raised by the EORegistryCoordinator contract. +type EORegistryCoordinatorQuorumBlockNumberUpdated struct { + QuorumNumber uint8 + Blocknumber *big.Int + Raw types.Log // Blockchain specific contextual infos } -// FilterPauserRegistrySet is a free log retrieval operation binding the contract event 0x6e9fcd539896fca60e8b0f01dd580233e48a6b0f7df013b89ba7f565869acdb6. +// FilterQuorumBlockNumberUpdated is a free log retrieval operation binding the contract event 0x46077d55330763f16269fd75e5761663f4192d2791747c0189b16ad31db07db4. // -// Solidity: event PauserRegistrySet(address pauserRegistry, address newPauserRegistry) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) FilterPauserRegistrySet(opts *bind.FilterOpts) (*ContractEORegistryCoordinatorPauserRegistrySetIterator, error) { +// Solidity: event QuorumBlockNumberUpdated(uint8 indexed quorumNumber, uint256 blocknumber) +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) FilterQuorumBlockNumberUpdated(opts *bind.FilterOpts, quorumNumber []uint8) (*EORegistryCoordinatorQuorumBlockNumberUpdatedIterator, error) { + + var quorumNumberRule []interface{} + for _, quorumNumberItem := range quorumNumber { + quorumNumberRule = append(quorumNumberRule, quorumNumberItem) + } - logs, sub, err := _ContractEORegistryCoordinator.contract.FilterLogs(opts, "PauserRegistrySet") + logs, sub, err := _EORegistryCoordinator.contract.FilterLogs(opts, "QuorumBlockNumberUpdated", quorumNumberRule) if err != nil { return nil, err } - return &ContractEORegistryCoordinatorPauserRegistrySetIterator{contract: _ContractEORegistryCoordinator.contract, event: "PauserRegistrySet", logs: logs, sub: sub}, nil + return &EORegistryCoordinatorQuorumBlockNumberUpdatedIterator{contract: _EORegistryCoordinator.contract, event: "QuorumBlockNumberUpdated", logs: logs, sub: sub}, nil } -// WatchPauserRegistrySet is a free log subscription operation binding the contract event 0x6e9fcd539896fca60e8b0f01dd580233e48a6b0f7df013b89ba7f565869acdb6. +// WatchQuorumBlockNumberUpdated is a free log subscription operation binding the contract event 0x46077d55330763f16269fd75e5761663f4192d2791747c0189b16ad31db07db4. // -// Solidity: event PauserRegistrySet(address pauserRegistry, address newPauserRegistry) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) WatchPauserRegistrySet(opts *bind.WatchOpts, sink chan<- *ContractEORegistryCoordinatorPauserRegistrySet) (event.Subscription, error) { +// Solidity: event QuorumBlockNumberUpdated(uint8 indexed quorumNumber, uint256 blocknumber) +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) WatchQuorumBlockNumberUpdated(opts *bind.WatchOpts, sink chan<- *EORegistryCoordinatorQuorumBlockNumberUpdated, quorumNumber []uint8) (event.Subscription, error) { + + var quorumNumberRule []interface{} + for _, quorumNumberItem := range quorumNumber { + quorumNumberRule = append(quorumNumberRule, quorumNumberItem) + } - logs, sub, err := _ContractEORegistryCoordinator.contract.WatchLogs(opts, "PauserRegistrySet") + logs, sub, err := _EORegistryCoordinator.contract.WatchLogs(opts, "QuorumBlockNumberUpdated", quorumNumberRule) if err != nil { return nil, err } @@ -2991,8 +4312,8 @@ func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) Wat select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(ContractEORegistryCoordinatorPauserRegistrySet) - if err := _ContractEORegistryCoordinator.contract.UnpackLog(event, "PauserRegistrySet", log); err != nil { + event := new(EORegistryCoordinatorQuorumBlockNumberUpdated) + if err := _EORegistryCoordinator.contract.UnpackLog(event, "QuorumBlockNumberUpdated", log); err != nil { return err } event.Raw = log @@ -3013,21 +4334,21 @@ func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) Wat }), nil } -// ParsePauserRegistrySet is a log parse operation binding the contract event 0x6e9fcd539896fca60e8b0f01dd580233e48a6b0f7df013b89ba7f565869acdb6. +// ParseQuorumBlockNumberUpdated is a log parse operation binding the contract event 0x46077d55330763f16269fd75e5761663f4192d2791747c0189b16ad31db07db4. // -// Solidity: event PauserRegistrySet(address pauserRegistry, address newPauserRegistry) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) ParsePauserRegistrySet(log types.Log) (*ContractEORegistryCoordinatorPauserRegistrySet, error) { - event := new(ContractEORegistryCoordinatorPauserRegistrySet) - if err := _ContractEORegistryCoordinator.contract.UnpackLog(event, "PauserRegistrySet", log); err != nil { +// Solidity: event QuorumBlockNumberUpdated(uint8 indexed quorumNumber, uint256 blocknumber) +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) ParseQuorumBlockNumberUpdated(log types.Log) (*EORegistryCoordinatorQuorumBlockNumberUpdated, error) { + event := new(EORegistryCoordinatorQuorumBlockNumberUpdated) + if err := _EORegistryCoordinator.contract.UnpackLog(event, "QuorumBlockNumberUpdated", log); err != nil { return nil, err } event.Raw = log return event, nil } -// ContractEORegistryCoordinatorQuorumBlockNumberUpdatedIterator is returned from FilterQuorumBlockNumberUpdated and is used to iterate over the raw logs and unpacked data for QuorumBlockNumberUpdated events raised by the ContractEORegistryCoordinator contract. -type ContractEORegistryCoordinatorQuorumBlockNumberUpdatedIterator struct { - Event *ContractEORegistryCoordinatorQuorumBlockNumberUpdated // Event containing the contract specifics and raw log +// EORegistryCoordinatorQuorumCreatedIterator is returned from FilterQuorumCreated and is used to iterate over the raw logs and unpacked data for QuorumCreated events raised by the EORegistryCoordinator contract. +type EORegistryCoordinatorQuorumCreatedIterator struct { + Event *EORegistryCoordinatorQuorumCreated // 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 @@ -3041,7 +4362,7 @@ type ContractEORegistryCoordinatorQuorumBlockNumberUpdatedIterator struct { // 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 *ContractEORegistryCoordinatorQuorumBlockNumberUpdatedIterator) Next() bool { +func (it *EORegistryCoordinatorQuorumCreatedIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -3050,7 +4371,7 @@ func (it *ContractEORegistryCoordinatorQuorumBlockNumberUpdatedIterator) Next() if it.done { select { case log := <-it.logs: - it.Event = new(ContractEORegistryCoordinatorQuorumBlockNumberUpdated) + it.Event = new(EORegistryCoordinatorQuorumCreated) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -3065,7 +4386,7 @@ func (it *ContractEORegistryCoordinatorQuorumBlockNumberUpdatedIterator) Next() // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(ContractEORegistryCoordinatorQuorumBlockNumberUpdated) + it.Event = new(EORegistryCoordinatorQuorumCreated) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -3081,52 +4402,56 @@ func (it *ContractEORegistryCoordinatorQuorumBlockNumberUpdatedIterator) Next() } // Error returns any retrieval or parsing error occurred during filtering. -func (it *ContractEORegistryCoordinatorQuorumBlockNumberUpdatedIterator) Error() error { +func (it *EORegistryCoordinatorQuorumCreatedIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *ContractEORegistryCoordinatorQuorumBlockNumberUpdatedIterator) Close() error { +func (it *EORegistryCoordinatorQuorumCreatedIterator) Close() error { it.sub.Unsubscribe() return nil } -// ContractEORegistryCoordinatorQuorumBlockNumberUpdated represents a QuorumBlockNumberUpdated event raised by the ContractEORegistryCoordinator contract. -type ContractEORegistryCoordinatorQuorumBlockNumberUpdated struct { - QuorumNumber uint8 - Blocknumber *big.Int - Raw types.Log // Blockchain specific contextual infos +// EORegistryCoordinatorQuorumCreated represents a QuorumCreated event raised by the EORegistryCoordinator contract. +type EORegistryCoordinatorQuorumCreated struct { + QuorumNumber uint8 + OperatorSetParams ISlashingRegistryCoordinatorTypesOperatorSetParam + MinimumStake *big.Int + StrategyParams []IStakeRegistryTypesStrategyParams + StakeType uint8 + LookAheadPeriod uint32 + Raw types.Log // Blockchain specific contextual infos } -// FilterQuorumBlockNumberUpdated is a free log retrieval operation binding the contract event 0x46077d55330763f16269fd75e5761663f4192d2791747c0189b16ad31db07db4. +// FilterQuorumCreated is a free log retrieval operation binding the contract event 0xa34835bc2b673ec37fcf1591a91295b163fc2e181e4ea4e733beb27de1ceac4c. // -// Solidity: event QuorumBlockNumberUpdated(uint8 indexed quorumNumber, uint256 blocknumber) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) FilterQuorumBlockNumberUpdated(opts *bind.FilterOpts, quorumNumber []uint8) (*ContractEORegistryCoordinatorQuorumBlockNumberUpdatedIterator, error) { +// Solidity: event QuorumCreated(uint8 indexed quorumNumber, (uint32,uint16,uint16) operatorSetParams, uint96 minimumStake, (address,uint96)[] strategyParams, uint8 stakeType, uint32 lookAheadPeriod) +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) FilterQuorumCreated(opts *bind.FilterOpts, quorumNumber []uint8) (*EORegistryCoordinatorQuorumCreatedIterator, error) { var quorumNumberRule []interface{} for _, quorumNumberItem := range quorumNumber { quorumNumberRule = append(quorumNumberRule, quorumNumberItem) } - logs, sub, err := _ContractEORegistryCoordinator.contract.FilterLogs(opts, "QuorumBlockNumberUpdated", quorumNumberRule) + logs, sub, err := _EORegistryCoordinator.contract.FilterLogs(opts, "QuorumCreated", quorumNumberRule) if err != nil { return nil, err } - return &ContractEORegistryCoordinatorQuorumBlockNumberUpdatedIterator{contract: _ContractEORegistryCoordinator.contract, event: "QuorumBlockNumberUpdated", logs: logs, sub: sub}, nil + return &EORegistryCoordinatorQuorumCreatedIterator{contract: _EORegistryCoordinator.contract, event: "QuorumCreated", logs: logs, sub: sub}, nil } -// WatchQuorumBlockNumberUpdated is a free log subscription operation binding the contract event 0x46077d55330763f16269fd75e5761663f4192d2791747c0189b16ad31db07db4. +// WatchQuorumCreated is a free log subscription operation binding the contract event 0xa34835bc2b673ec37fcf1591a91295b163fc2e181e4ea4e733beb27de1ceac4c. // -// Solidity: event QuorumBlockNumberUpdated(uint8 indexed quorumNumber, uint256 blocknumber) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) WatchQuorumBlockNumberUpdated(opts *bind.WatchOpts, sink chan<- *ContractEORegistryCoordinatorQuorumBlockNumberUpdated, quorumNumber []uint8) (event.Subscription, error) { +// Solidity: event QuorumCreated(uint8 indexed quorumNumber, (uint32,uint16,uint16) operatorSetParams, uint96 minimumStake, (address,uint96)[] strategyParams, uint8 stakeType, uint32 lookAheadPeriod) +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) WatchQuorumCreated(opts *bind.WatchOpts, sink chan<- *EORegistryCoordinatorQuorumCreated, quorumNumber []uint8) (event.Subscription, error) { var quorumNumberRule []interface{} for _, quorumNumberItem := range quorumNumber { quorumNumberRule = append(quorumNumberRule, quorumNumberItem) } - logs, sub, err := _ContractEORegistryCoordinator.contract.WatchLogs(opts, "QuorumBlockNumberUpdated", quorumNumberRule) + logs, sub, err := _EORegistryCoordinator.contract.WatchLogs(opts, "QuorumCreated", quorumNumberRule) if err != nil { return nil, err } @@ -3136,8 +4461,8 @@ func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) Wat select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(ContractEORegistryCoordinatorQuorumBlockNumberUpdated) - if err := _ContractEORegistryCoordinator.contract.UnpackLog(event, "QuorumBlockNumberUpdated", log); err != nil { + event := new(EORegistryCoordinatorQuorumCreated) + if err := _EORegistryCoordinator.contract.UnpackLog(event, "QuorumCreated", log); err != nil { return err } event.Raw = log @@ -3158,21 +4483,21 @@ func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) Wat }), nil } -// ParseQuorumBlockNumberUpdated is a log parse operation binding the contract event 0x46077d55330763f16269fd75e5761663f4192d2791747c0189b16ad31db07db4. +// ParseQuorumCreated is a log parse operation binding the contract event 0xa34835bc2b673ec37fcf1591a91295b163fc2e181e4ea4e733beb27de1ceac4c. // -// Solidity: event QuorumBlockNumberUpdated(uint8 indexed quorumNumber, uint256 blocknumber) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) ParseQuorumBlockNumberUpdated(log types.Log) (*ContractEORegistryCoordinatorQuorumBlockNumberUpdated, error) { - event := new(ContractEORegistryCoordinatorQuorumBlockNumberUpdated) - if err := _ContractEORegistryCoordinator.contract.UnpackLog(event, "QuorumBlockNumberUpdated", log); err != nil { +// Solidity: event QuorumCreated(uint8 indexed quorumNumber, (uint32,uint16,uint16) operatorSetParams, uint96 minimumStake, (address,uint96)[] strategyParams, uint8 stakeType, uint32 lookAheadPeriod) +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) ParseQuorumCreated(log types.Log) (*EORegistryCoordinatorQuorumCreated, error) { + event := new(EORegistryCoordinatorQuorumCreated) + if err := _EORegistryCoordinator.contract.UnpackLog(event, "QuorumCreated", log); err != nil { return nil, err } event.Raw = log return event, nil } -// ContractEORegistryCoordinatorUnpausedIterator is returned from FilterUnpaused and is used to iterate over the raw logs and unpacked data for Unpaused events raised by the ContractEORegistryCoordinator contract. -type ContractEORegistryCoordinatorUnpausedIterator struct { - Event *ContractEORegistryCoordinatorUnpaused // Event containing the contract specifics and raw log +// EORegistryCoordinatorUnpausedIterator is returned from FilterUnpaused and is used to iterate over the raw logs and unpacked data for Unpaused events raised by the EORegistryCoordinator contract. +type EORegistryCoordinatorUnpausedIterator struct { + Event *EORegistryCoordinatorUnpaused // 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 @@ -3186,7 +4511,7 @@ type ContractEORegistryCoordinatorUnpausedIterator struct { // 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 *ContractEORegistryCoordinatorUnpausedIterator) Next() bool { +func (it *EORegistryCoordinatorUnpausedIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -3195,7 +4520,7 @@ func (it *ContractEORegistryCoordinatorUnpausedIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(ContractEORegistryCoordinatorUnpaused) + it.Event = new(EORegistryCoordinatorUnpaused) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -3210,7 +4535,7 @@ func (it *ContractEORegistryCoordinatorUnpausedIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(ContractEORegistryCoordinatorUnpaused) + it.Event = new(EORegistryCoordinatorUnpaused) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -3226,19 +4551,19 @@ func (it *ContractEORegistryCoordinatorUnpausedIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *ContractEORegistryCoordinatorUnpausedIterator) Error() error { +func (it *EORegistryCoordinatorUnpausedIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *ContractEORegistryCoordinatorUnpausedIterator) Close() error { +func (it *EORegistryCoordinatorUnpausedIterator) Close() error { it.sub.Unsubscribe() return nil } -// ContractEORegistryCoordinatorUnpaused represents a Unpaused event raised by the ContractEORegistryCoordinator contract. -type ContractEORegistryCoordinatorUnpaused struct { +// EORegistryCoordinatorUnpaused represents a Unpaused event raised by the EORegistryCoordinator contract. +type EORegistryCoordinatorUnpaused struct { Account common.Address NewPausedStatus *big.Int Raw types.Log // Blockchain specific contextual infos @@ -3247,31 +4572,31 @@ type ContractEORegistryCoordinatorUnpaused struct { // FilterUnpaused is a free log retrieval operation binding the contract event 0x3582d1828e26bf56bd801502bc021ac0bc8afb57c826e4986b45593c8fad389c. // // Solidity: event Unpaused(address indexed account, uint256 newPausedStatus) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) FilterUnpaused(opts *bind.FilterOpts, account []common.Address) (*ContractEORegistryCoordinatorUnpausedIterator, error) { +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) FilterUnpaused(opts *bind.FilterOpts, account []common.Address) (*EORegistryCoordinatorUnpausedIterator, error) { var accountRule []interface{} for _, accountItem := range account { accountRule = append(accountRule, accountItem) } - logs, sub, err := _ContractEORegistryCoordinator.contract.FilterLogs(opts, "Unpaused", accountRule) + logs, sub, err := _EORegistryCoordinator.contract.FilterLogs(opts, "Unpaused", accountRule) if err != nil { return nil, err } - return &ContractEORegistryCoordinatorUnpausedIterator{contract: _ContractEORegistryCoordinator.contract, event: "Unpaused", logs: logs, sub: sub}, nil + return &EORegistryCoordinatorUnpausedIterator{contract: _EORegistryCoordinator.contract, event: "Unpaused", logs: logs, sub: sub}, nil } // WatchUnpaused is a free log subscription operation binding the contract event 0x3582d1828e26bf56bd801502bc021ac0bc8afb57c826e4986b45593c8fad389c. // // Solidity: event Unpaused(address indexed account, uint256 newPausedStatus) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) WatchUnpaused(opts *bind.WatchOpts, sink chan<- *ContractEORegistryCoordinatorUnpaused, account []common.Address) (event.Subscription, error) { +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) WatchUnpaused(opts *bind.WatchOpts, sink chan<- *EORegistryCoordinatorUnpaused, account []common.Address) (event.Subscription, error) { var accountRule []interface{} for _, accountItem := range account { accountRule = append(accountRule, accountItem) } - logs, sub, err := _ContractEORegistryCoordinator.contract.WatchLogs(opts, "Unpaused", accountRule) + logs, sub, err := _EORegistryCoordinator.contract.WatchLogs(opts, "Unpaused", accountRule) if err != nil { return nil, err } @@ -3281,8 +4606,8 @@ func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) Wat select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(ContractEORegistryCoordinatorUnpaused) - if err := _ContractEORegistryCoordinator.contract.UnpackLog(event, "Unpaused", log); err != nil { + event := new(EORegistryCoordinatorUnpaused) + if err := _EORegistryCoordinator.contract.UnpackLog(event, "Unpaused", log); err != nil { return err } event.Raw = log @@ -3306,9 +4631,9 @@ func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) Wat // ParseUnpaused is a log parse operation binding the contract event 0x3582d1828e26bf56bd801502bc021ac0bc8afb57c826e4986b45593c8fad389c. // // Solidity: event Unpaused(address indexed account, uint256 newPausedStatus) -func (_ContractEORegistryCoordinator *ContractEORegistryCoordinatorFilterer) ParseUnpaused(log types.Log) (*ContractEORegistryCoordinatorUnpaused, error) { - event := new(ContractEORegistryCoordinatorUnpaused) - if err := _ContractEORegistryCoordinator.contract.UnpackLog(event, "Unpaused", log); err != nil { +func (_EORegistryCoordinator *EORegistryCoordinatorFilterer) ParseUnpaused(log types.Log) (*EORegistryCoordinatorUnpaused, error) { + event := new(EORegistryCoordinatorUnpaused) + if err := _EORegistryCoordinator.contract.UnpackLog(event, "Unpaused", log); err != nil { return nil, err } event.Raw = log diff --git a/contracts/bindings/EOStakeRegistry/binding.go b/contracts/bindings/EOStakeRegistry/binding.go index 2c67bcd..6e93425 100644 --- a/contracts/bindings/EOStakeRegistry/binding.go +++ b/contracts/bindings/EOStakeRegistry/binding.go @@ -29,265 +29,126 @@ var ( _ = abi.ConvertType ) -// IEOStakeRegistryStakeUpdate is an auto generated low-level Go binding around an user-defined struct. -type IEOStakeRegistryStakeUpdate struct { +// IStakeRegistryTypesStakeUpdate is an auto generated low-level Go binding around an user-defined struct. +type IStakeRegistryTypesStakeUpdate struct { UpdateBlockNumber uint32 NextUpdateBlockNumber uint32 Stake *big.Int } -// IEOStakeRegistryStrategyParams is an auto generated low-level Go binding around an user-defined struct. -type IEOStakeRegistryStrategyParams struct { +// IStakeRegistryTypesStrategyParams is an auto generated low-level Go binding around an user-defined struct. +type IStakeRegistryTypesStrategyParams struct { Strategy common.Address Multiplier *big.Int } -// ContractEOStakeRegistryMetaData contains all meta data concerning the ContractEOStakeRegistry contract. -var ContractEOStakeRegistryMetaData = &bind.MetaData{ - ABI: "[{\"type\":\"constructor\",\"inputs\":[{\"name\":\"_registryCoordinator\",\"type\":\"address\",\"internalType\":\"contractIEORegistryCoordinator\"},{\"name\":\"_delegationManager\",\"type\":\"address\",\"internalType\":\"contractIDelegationManager\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"MAX_WEIGHING_FUNCTION_LENGTH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"WEIGHTING_DIVISOR\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"addStrategies\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"_strategyParams\",\"type\":\"tuple[]\",\"internalType\":\"structIEOStakeRegistry.StrategyParams[]\",\"components\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"multiplier\",\"type\":\"uint96\",\"internalType\":\"uint96\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"delegation\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIDelegationManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"deregisterOperator\",\"inputs\":[{\"name\":\"operatorId\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"quorumNumbers\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"getCurrentStake\",\"inputs\":[{\"name\":\"operatorId\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint96\",\"internalType\":\"uint96\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getCurrentTotalStake\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint96\",\"internalType\":\"uint96\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getLatestStakeUpdate\",\"inputs\":[{\"name\":\"operatorId\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structIEOStakeRegistry.StakeUpdate\",\"components\":[{\"name\":\"updateBlockNumber\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"nextUpdateBlockNumber\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"stake\",\"type\":\"uint96\",\"internalType\":\"uint96\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getStakeAtBlockNumber\",\"inputs\":[{\"name\":\"operatorId\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"blockNumber\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint96\",\"internalType\":\"uint96\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getStakeAtBlockNumberAndIndex\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"blockNumber\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"operatorId\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"index\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint96\",\"internalType\":\"uint96\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getStakeHistory\",\"inputs\":[{\"name\":\"operatorId\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple[]\",\"internalType\":\"structIEOStakeRegistry.StakeUpdate[]\",\"components\":[{\"name\":\"updateBlockNumber\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"nextUpdateBlockNumber\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"stake\",\"type\":\"uint96\",\"internalType\":\"uint96\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getStakeHistoryLength\",\"inputs\":[{\"name\":\"operatorId\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getStakeUpdateAtIndex\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"operatorId\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"index\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structIEOStakeRegistry.StakeUpdate\",\"components\":[{\"name\":\"updateBlockNumber\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"nextUpdateBlockNumber\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"stake\",\"type\":\"uint96\",\"internalType\":\"uint96\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getStakeUpdateIndexAtBlockNumber\",\"inputs\":[{\"name\":\"operatorId\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"blockNumber\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getTotalStakeAtBlockNumberFromIndex\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"blockNumber\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"index\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint96\",\"internalType\":\"uint96\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getTotalStakeHistoryLength\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getTotalStakeIndicesAtBlockNumber\",\"inputs\":[{\"name\":\"blockNumber\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"quorumNumbers\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint32[]\",\"internalType\":\"uint32[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getTotalStakeUpdateAtIndex\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"index\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structIEOStakeRegistry.StakeUpdate\",\"components\":[{\"name\":\"updateBlockNumber\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"nextUpdateBlockNumber\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"stake\",\"type\":\"uint96\",\"internalType\":\"uint96\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"initializeQuorum\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"minimumStake\",\"type\":\"uint96\",\"internalType\":\"uint96\"},{\"name\":\"_strategyParams\",\"type\":\"tuple[]\",\"internalType\":\"structIEOStakeRegistry.StrategyParams[]\",\"components\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"multiplier\",\"type\":\"uint96\",\"internalType\":\"uint96\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"minimumStakeForQuorum\",\"inputs\":[{\"name\":\"\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint96\",\"internalType\":\"uint96\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"modifyStrategyParams\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"strategyIndices\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"},{\"name\":\"newMultipliers\",\"type\":\"uint96[]\",\"internalType\":\"uint96[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"registerOperator\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorId\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"quorumNumbers\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint96[]\",\"internalType\":\"uint96[]\"},{\"name\":\"\",\"type\":\"uint96[]\",\"internalType\":\"uint96[]\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"registryCoordinator\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"removeStrategies\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"indicesToRemove\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setMinimumStakeForQuorum\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"minimumStake\",\"type\":\"uint96\",\"internalType\":\"uint96\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"strategiesPerQuorum\",\"inputs\":[{\"name\":\"\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"strategyParams\",\"inputs\":[{\"name\":\"\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"multiplier\",\"type\":\"uint96\",\"internalType\":\"uint96\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"strategyParamsByIndex\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"index\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structIEOStakeRegistry.StrategyParams\",\"components\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"multiplier\",\"type\":\"uint96\",\"internalType\":\"uint96\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"strategyParamsLength\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"updateOperatorStake\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorId\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"quorumNumbers\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint192\",\"internalType\":\"uint192\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"weightOfOperatorForQuorum\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint96\",\"internalType\":\"uint96\"}],\"stateMutability\":\"view\"},{\"type\":\"event\",\"name\":\"MinimumStakeForQuorumUpdated\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"indexed\":true,\"internalType\":\"uint8\"},{\"name\":\"minimumStake\",\"type\":\"uint96\",\"indexed\":false,\"internalType\":\"uint96\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorStakeUpdate\",\"inputs\":[{\"name\":\"operatorId\",\"type\":\"bytes32\",\"indexed\":true,\"internalType\":\"bytes32\"},{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"indexed\":false,\"internalType\":\"uint8\"},{\"name\":\"stake\",\"type\":\"uint96\",\"indexed\":false,\"internalType\":\"uint96\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"QuorumCreated\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"indexed\":true,\"internalType\":\"uint8\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StrategyAddedToQuorum\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"indexed\":true,\"internalType\":\"uint8\"},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StrategyMultiplierUpdated\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"indexed\":true,\"internalType\":\"uint8\"},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"multiplier\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StrategyRemovedFromQuorum\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"indexed\":true,\"internalType\":\"uint8\"},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"}],\"anonymous\":false}]", - Bin: "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", +// EOStakeRegistryMetaData contains all meta data concerning the EOStakeRegistry contract. +var EOStakeRegistryMetaData = &bind.MetaData{ + ABI: "[{\"type\":\"constructor\",\"inputs\":[{\"name\":\"_slashingRegistryCoordinator\",\"type\":\"address\",\"internalType\":\"contractISlashingRegistryCoordinator\"},{\"name\":\"_delegationManager\",\"type\":\"address\",\"internalType\":\"contractIDelegationManager\"},{\"name\":\"_avsDirectory\",\"type\":\"address\",\"internalType\":\"contractIAVSDirectory\"},{\"name\":\"_allocationManager\",\"type\":\"address\",\"internalType\":\"contractIAllocationManager\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"MAX_WEIGHING_FUNCTION_LENGTH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"WEIGHTING_DIVISOR\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"addStrategies\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"_strategyParams\",\"type\":\"tuple[]\",\"internalType\":\"structIStakeRegistryTypes.StrategyParams[]\",\"components\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"multiplier\",\"type\":\"uint96\",\"internalType\":\"uint96\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"allocationManager\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIAllocationManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"avsDirectory\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIAVSDirectory\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"chainManager\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIEOChainManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"delegation\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIDelegationManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"deregisterOperator\",\"inputs\":[{\"name\":\"operatorId\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"quorumNumbers\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"getCurrentStake\",\"inputs\":[{\"name\":\"operatorId\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint96\",\"internalType\":\"uint96\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getCurrentTotalStake\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint96\",\"internalType\":\"uint96\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getLatestStakeUpdate\",\"inputs\":[{\"name\":\"operatorId\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structIStakeRegistryTypes.StakeUpdate\",\"components\":[{\"name\":\"updateBlockNumber\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"nextUpdateBlockNumber\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"stake\",\"type\":\"uint96\",\"internalType\":\"uint96\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getStakeAtBlockNumber\",\"inputs\":[{\"name\":\"operatorId\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"blockNumber\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint96\",\"internalType\":\"uint96\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getStakeAtBlockNumberAndIndex\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"blockNumber\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"operatorId\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"index\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint96\",\"internalType\":\"uint96\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getStakeHistory\",\"inputs\":[{\"name\":\"operatorId\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple[]\",\"internalType\":\"structIStakeRegistryTypes.StakeUpdate[]\",\"components\":[{\"name\":\"updateBlockNumber\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"nextUpdateBlockNumber\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"stake\",\"type\":\"uint96\",\"internalType\":\"uint96\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getStakeHistoryLength\",\"inputs\":[{\"name\":\"operatorId\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getStakeUpdateAtIndex\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"operatorId\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"index\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structIStakeRegistryTypes.StakeUpdate\",\"components\":[{\"name\":\"updateBlockNumber\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"nextUpdateBlockNumber\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"stake\",\"type\":\"uint96\",\"internalType\":\"uint96\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getStakeUpdateIndexAtBlockNumber\",\"inputs\":[{\"name\":\"operatorId\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"blockNumber\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getTotalStakeAtBlockNumberFromIndex\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"blockNumber\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"index\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint96\",\"internalType\":\"uint96\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getTotalStakeHistoryLength\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getTotalStakeIndicesAtBlockNumber\",\"inputs\":[{\"name\":\"blockNumber\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"quorumNumbers\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint32[]\",\"internalType\":\"uint32[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getTotalStakeUpdateAtIndex\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"index\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structIStakeRegistryTypes.StakeUpdate\",\"components\":[{\"name\":\"updateBlockNumber\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"nextUpdateBlockNumber\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"stake\",\"type\":\"uint96\",\"internalType\":\"uint96\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"initializeDelegatedStakeQuorum\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"minimumStake\",\"type\":\"uint96\",\"internalType\":\"uint96\"},{\"name\":\"_strategyParams\",\"type\":\"tuple[]\",\"internalType\":\"structIStakeRegistryTypes.StrategyParams[]\",\"components\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"multiplier\",\"type\":\"uint96\",\"internalType\":\"uint96\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"initializeSlashableStakeQuorum\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"minimumStake\",\"type\":\"uint96\",\"internalType\":\"uint96\"},{\"name\":\"lookAheadPeriod\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"_strategyParams\",\"type\":\"tuple[]\",\"internalType\":\"structIStakeRegistryTypes.StrategyParams[]\",\"components\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"multiplier\",\"type\":\"uint96\",\"internalType\":\"uint96\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"minimumStakeForQuorum\",\"inputs\":[{\"name\":\"\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint96\",\"internalType\":\"uint96\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"modifyStrategyParams\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"strategyIndices\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"},{\"name\":\"newMultipliers\",\"type\":\"uint96[]\",\"internalType\":\"uint96[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"registerOperator\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorId\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"quorumNumbers\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint96[]\",\"internalType\":\"uint96[]\"},{\"name\":\"\",\"type\":\"uint96[]\",\"internalType\":\"uint96[]\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"registryCoordinator\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractISlashingRegistryCoordinator\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"removeStrategies\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"indicesToRemove\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setChainManager\",\"inputs\":[{\"name\":\"newChainManager\",\"type\":\"address\",\"internalType\":\"contractIEOChainManager\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setMinimumStakeForQuorum\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"minimumStake\",\"type\":\"uint96\",\"internalType\":\"uint96\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setSlashableStakeLookahead\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"_lookAheadBlocks\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"slashableStakeLookAheadPerQuorum\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"stakeTypePerQuorum\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint8\",\"internalType\":\"enumIStakeRegistryTypes.StakeType\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"strategiesPerQuorum\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"strategyParams\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"multiplier\",\"type\":\"uint96\",\"internalType\":\"uint96\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"strategyParamsByIndex\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"index\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structIStakeRegistryTypes.StrategyParams\",\"components\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"multiplier\",\"type\":\"uint96\",\"internalType\":\"uint96\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"strategyParamsLength\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"updateOperatorsStake\",\"inputs\":[{\"name\":\"operators\",\"type\":\"address[]\",\"internalType\":\"address[]\"},{\"name\":\"operatorIds\",\"type\":\"bytes32[]\",\"internalType\":\"bytes32[]\"},{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool[]\",\"internalType\":\"bool[]\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"updateOperatorsStake\",\"inputs\":[{\"name\":\"operators\",\"type\":\"address[]\",\"internalType\":\"address[]\"},{\"name\":\"operatorIds\",\"type\":\"bytes32[]\",\"internalType\":\"bytes32[]\"},{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"operatorSetId\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool[]\",\"internalType\":\"bool[]\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"weightOfOperatorForQuorum\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"internalType\":\"uint8\"},{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint96\",\"internalType\":\"uint96\"}],\"stateMutability\":\"view\"},{\"type\":\"event\",\"name\":\"LookAheadPeriodChanged\",\"inputs\":[{\"name\":\"oldLookAheadBlocks\",\"type\":\"uint32\",\"indexed\":false,\"internalType\":\"uint32\"},{\"name\":\"newLookAheadBlocks\",\"type\":\"uint32\",\"indexed\":false,\"internalType\":\"uint32\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"MinimumStakeForQuorumUpdated\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"indexed\":true,\"internalType\":\"uint8\"},{\"name\":\"minimumStake\",\"type\":\"uint96\",\"indexed\":false,\"internalType\":\"uint96\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorStakeUpdate\",\"inputs\":[{\"name\":\"operatorId\",\"type\":\"bytes32\",\"indexed\":true,\"internalType\":\"bytes32\"},{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"indexed\":false,\"internalType\":\"uint8\"},{\"name\":\"stake\",\"type\":\"uint96\",\"indexed\":false,\"internalType\":\"uint96\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"QuorumCreated\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"indexed\":true,\"internalType\":\"uint8\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StakeTypeSet\",\"inputs\":[{\"name\":\"newStakeType\",\"type\":\"uint8\",\"indexed\":false,\"internalType\":\"enumIStakeRegistryTypes.StakeType\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StrategyAddedToQuorum\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"indexed\":true,\"internalType\":\"uint8\"},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StrategyMultiplierUpdated\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"indexed\":true,\"internalType\":\"uint8\"},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"multiplier\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StrategyRemovedFromQuorum\",\"inputs\":[{\"name\":\"quorumNumber\",\"type\":\"uint8\",\"indexed\":true,\"internalType\":\"uint8\"},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"BelowMinimumStakeRequirement\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"EmptyStakeHistory\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InputArrayLengthMismatch\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InputArrayLengthZero\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InputDuplicateStrategy\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InputMultiplierZero\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidBlockNumber\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"LookAheadPeriodTooLong\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlySlashingRegistryCoordinator\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlySlashingRegistryCoordinatorOwner\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"QuorumAlreadyExists\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"QuorumDoesNotExist\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"QuorumNotSlashable\",\"inputs\":[]}]", } -// ContractEOStakeRegistryABI is the input ABI used to generate the binding from. -// Deprecated: Use ContractEOStakeRegistryMetaData.ABI instead. -var ContractEOStakeRegistryABI = ContractEOStakeRegistryMetaData.ABI +// EOStakeRegistryABI is the input ABI used to generate the binding from. +// Deprecated: Use EOStakeRegistryMetaData.ABI instead. +var EOStakeRegistryABI = EOStakeRegistryMetaData.ABI -// ContractEOStakeRegistryBin is the compiled bytecode used for deploying new contracts. -// Deprecated: Use ContractEOStakeRegistryMetaData.Bin instead. -var ContractEOStakeRegistryBin = ContractEOStakeRegistryMetaData.Bin - -// DeployContractEOStakeRegistry deploys a new Ethereum contract, binding an instance of ContractEOStakeRegistry to it. -func DeployContractEOStakeRegistry(auth *bind.TransactOpts, backend bind.ContractBackend, _registryCoordinator common.Address, _delegationManager common.Address) (common.Address, *types.Transaction, *ContractEOStakeRegistry, error) { - parsed, err := ContractEOStakeRegistryMetaData.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(ContractEOStakeRegistryBin), backend, _registryCoordinator, _delegationManager) - if err != nil { - return common.Address{}, nil, nil, err - } - return address, tx, &ContractEOStakeRegistry{ContractEOStakeRegistryCaller: ContractEOStakeRegistryCaller{contract: contract}, ContractEOStakeRegistryTransactor: ContractEOStakeRegistryTransactor{contract: contract}, ContractEOStakeRegistryFilterer: ContractEOStakeRegistryFilterer{contract: contract}}, nil -} - -// ContractEOStakeRegistryMethods is an auto generated interface around an Ethereum contract. -type ContractEOStakeRegistryMethods interface { - ContractEOStakeRegistryCalls - ContractEOStakeRegistryTransacts - ContractEOStakeRegistryFilters -} - -// ContractEOStakeRegistryCalls is an auto generated interface that defines the call methods available for an Ethereum contract. -type ContractEOStakeRegistryCalls interface { - MAXWEIGHINGFUNCTIONLENGTH(opts *bind.CallOpts) (uint8, error) - - WEIGHTINGDIVISOR(opts *bind.CallOpts) (*big.Int, error) - - Delegation(opts *bind.CallOpts) (common.Address, error) - - GetCurrentStake(opts *bind.CallOpts, operatorId [32]byte, quorumNumber uint8) (*big.Int, error) - - GetCurrentTotalStake(opts *bind.CallOpts, quorumNumber uint8) (*big.Int, error) - - GetLatestStakeUpdate(opts *bind.CallOpts, operatorId [32]byte, quorumNumber uint8) (IEOStakeRegistryStakeUpdate, error) - - GetStakeAtBlockNumber(opts *bind.CallOpts, operatorId [32]byte, quorumNumber uint8, blockNumber uint32) (*big.Int, error) - - GetStakeAtBlockNumberAndIndex(opts *bind.CallOpts, quorumNumber uint8, blockNumber uint32, operatorId [32]byte, index *big.Int) (*big.Int, error) - - GetStakeHistory(opts *bind.CallOpts, operatorId [32]byte, quorumNumber uint8) ([]IEOStakeRegistryStakeUpdate, error) - - GetStakeHistoryLength(opts *bind.CallOpts, operatorId [32]byte, quorumNumber uint8) (*big.Int, error) - - GetStakeUpdateAtIndex(opts *bind.CallOpts, quorumNumber uint8, operatorId [32]byte, index *big.Int) (IEOStakeRegistryStakeUpdate, error) - - GetStakeUpdateIndexAtBlockNumber(opts *bind.CallOpts, operatorId [32]byte, quorumNumber uint8, blockNumber uint32) (uint32, error) - - GetTotalStakeAtBlockNumberFromIndex(opts *bind.CallOpts, quorumNumber uint8, blockNumber uint32, index *big.Int) (*big.Int, error) - - GetTotalStakeHistoryLength(opts *bind.CallOpts, quorumNumber uint8) (*big.Int, error) - - GetTotalStakeIndicesAtBlockNumber(opts *bind.CallOpts, blockNumber uint32, quorumNumbers []byte) ([]uint32, error) - - GetTotalStakeUpdateAtIndex(opts *bind.CallOpts, quorumNumber uint8, index *big.Int) (IEOStakeRegistryStakeUpdate, error) - - MinimumStakeForQuorum(opts *bind.CallOpts, arg0 uint8) (*big.Int, error) - - RegistryCoordinator(opts *bind.CallOpts) (common.Address, error) - - StrategiesPerQuorum(opts *bind.CallOpts, arg0 uint8, arg1 *big.Int) (common.Address, error) - - StrategyParams(opts *bind.CallOpts, arg0 uint8, arg1 *big.Int) (struct { - Strategy common.Address - Multiplier *big.Int - }, error) - - StrategyParamsByIndex(opts *bind.CallOpts, quorumNumber uint8, index *big.Int) (IEOStakeRegistryStrategyParams, error) - - StrategyParamsLength(opts *bind.CallOpts, quorumNumber uint8) (*big.Int, error) - - WeightOfOperatorForQuorum(opts *bind.CallOpts, quorumNumber uint8, operator common.Address) (*big.Int, error) -} - -// ContractEOStakeRegistryTransacts is an auto generated interface that defines the transact methods available for an Ethereum contract. -type ContractEOStakeRegistryTransacts interface { - AddStrategies(opts *bind.TransactOpts, quorumNumber uint8, _strategyParams []IEOStakeRegistryStrategyParams) (*types.Transaction, error) - - DeregisterOperator(opts *bind.TransactOpts, operatorId [32]byte, quorumNumbers []byte) (*types.Transaction, error) - - InitializeQuorum(opts *bind.TransactOpts, quorumNumber uint8, minimumStake *big.Int, _strategyParams []IEOStakeRegistryStrategyParams) (*types.Transaction, error) - - ModifyStrategyParams(opts *bind.TransactOpts, quorumNumber uint8, strategyIndices []*big.Int, newMultipliers []*big.Int) (*types.Transaction, error) - - RegisterOperator(opts *bind.TransactOpts, operator common.Address, operatorId [32]byte, quorumNumbers []byte) (*types.Transaction, error) - - RemoveStrategies(opts *bind.TransactOpts, quorumNumber uint8, indicesToRemove []*big.Int) (*types.Transaction, error) - - SetMinimumStakeForQuorum(opts *bind.TransactOpts, quorumNumber uint8, minimumStake *big.Int) (*types.Transaction, error) - - UpdateOperatorStake(opts *bind.TransactOpts, operator common.Address, operatorId [32]byte, quorumNumbers []byte) (*types.Transaction, error) -} - -// ContractEOStakeRegistryFilterer is an auto generated interface that defines the log filtering methods available for an Ethereum contract. -type ContractEOStakeRegistryFilters interface { - FilterMinimumStakeForQuorumUpdated(opts *bind.FilterOpts, quorumNumber []uint8) (*ContractEOStakeRegistryMinimumStakeForQuorumUpdatedIterator, error) - WatchMinimumStakeForQuorumUpdated(opts *bind.WatchOpts, sink chan<- *ContractEOStakeRegistryMinimumStakeForQuorumUpdated, quorumNumber []uint8) (event.Subscription, error) - ParseMinimumStakeForQuorumUpdated(log types.Log) (*ContractEOStakeRegistryMinimumStakeForQuorumUpdated, error) - - FilterOperatorStakeUpdate(opts *bind.FilterOpts, operatorId [][32]byte) (*ContractEOStakeRegistryOperatorStakeUpdateIterator, error) - WatchOperatorStakeUpdate(opts *bind.WatchOpts, sink chan<- *ContractEOStakeRegistryOperatorStakeUpdate, operatorId [][32]byte) (event.Subscription, error) - ParseOperatorStakeUpdate(log types.Log) (*ContractEOStakeRegistryOperatorStakeUpdate, error) - - FilterQuorumCreated(opts *bind.FilterOpts, quorumNumber []uint8) (*ContractEOStakeRegistryQuorumCreatedIterator, error) - WatchQuorumCreated(opts *bind.WatchOpts, sink chan<- *ContractEOStakeRegistryQuorumCreated, quorumNumber []uint8) (event.Subscription, error) - ParseQuorumCreated(log types.Log) (*ContractEOStakeRegistryQuorumCreated, error) - - FilterStrategyAddedToQuorum(opts *bind.FilterOpts, quorumNumber []uint8) (*ContractEOStakeRegistryStrategyAddedToQuorumIterator, error) - WatchStrategyAddedToQuorum(opts *bind.WatchOpts, sink chan<- *ContractEOStakeRegistryStrategyAddedToQuorum, quorumNumber []uint8) (event.Subscription, error) - ParseStrategyAddedToQuorum(log types.Log) (*ContractEOStakeRegistryStrategyAddedToQuorum, error) - - FilterStrategyMultiplierUpdated(opts *bind.FilterOpts, quorumNumber []uint8) (*ContractEOStakeRegistryStrategyMultiplierUpdatedIterator, error) - WatchStrategyMultiplierUpdated(opts *bind.WatchOpts, sink chan<- *ContractEOStakeRegistryStrategyMultiplierUpdated, quorumNumber []uint8) (event.Subscription, error) - ParseStrategyMultiplierUpdated(log types.Log) (*ContractEOStakeRegistryStrategyMultiplierUpdated, error) - - FilterStrategyRemovedFromQuorum(opts *bind.FilterOpts, quorumNumber []uint8) (*ContractEOStakeRegistryStrategyRemovedFromQuorumIterator, error) - WatchStrategyRemovedFromQuorum(opts *bind.WatchOpts, sink chan<- *ContractEOStakeRegistryStrategyRemovedFromQuorum, quorumNumber []uint8) (event.Subscription, error) - ParseStrategyRemovedFromQuorum(log types.Log) (*ContractEOStakeRegistryStrategyRemovedFromQuorum, error) +// EOStakeRegistry is an auto generated Go binding around an Ethereum contract. +type EOStakeRegistry struct { + EOStakeRegistryCaller // Read-only binding to the contract + EOStakeRegistryTransactor // Write-only binding to the contract + EOStakeRegistryFilterer // Log filterer for contract events } -// ContractEOStakeRegistry is an auto generated Go binding around an Ethereum contract. -type ContractEOStakeRegistry struct { - ContractEOStakeRegistryCaller // Read-only binding to the contract - ContractEOStakeRegistryTransactor // Write-only binding to the contract - ContractEOStakeRegistryFilterer // Log filterer for contract events -} - -// ContractEOStakeRegistry implements the ContractEOStakeRegistryMethods interface. -var _ ContractEOStakeRegistryMethods = (*ContractEOStakeRegistry)(nil) - -// ContractEOStakeRegistryCaller is an auto generated read-only Go binding around an Ethereum contract. -type ContractEOStakeRegistryCaller struct { +// EOStakeRegistryCaller is an auto generated read-only Go binding around an Ethereum contract. +type EOStakeRegistryCaller struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } -// ContractEOStakeRegistryCaller implements the ContractEOStakeRegistryCalls interface. -var _ ContractEOStakeRegistryCalls = (*ContractEOStakeRegistryCaller)(nil) - -// ContractEOStakeRegistryTransactor is an auto generated write-only Go binding around an Ethereum contract. -type ContractEOStakeRegistryTransactor struct { +// EOStakeRegistryTransactor is an auto generated write-only Go binding around an Ethereum contract. +type EOStakeRegistryTransactor struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } -// ContractEOStakeRegistryTransactor implements the ContractEOStakeRegistryTransacts interface. -var _ ContractEOStakeRegistryTransacts = (*ContractEOStakeRegistryTransactor)(nil) - -// ContractEOStakeRegistryFilterer is an auto generated log filtering Go binding around an Ethereum contract events. -type ContractEOStakeRegistryFilterer struct { +// EOStakeRegistryFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type EOStakeRegistryFilterer struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } -// ContractEOStakeRegistryFilterer implements the ContractEOStakeRegistryFilters interface. -var _ ContractEOStakeRegistryFilters = (*ContractEOStakeRegistryFilterer)(nil) - -// ContractEOStakeRegistrySession is an auto generated Go binding around an Ethereum contract, +// EOStakeRegistrySession is an auto generated Go binding around an Ethereum contract, // with pre-set call and transact options. -type ContractEOStakeRegistrySession struct { - Contract *ContractEOStakeRegistry // 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 +type EOStakeRegistrySession struct { + Contract *EOStakeRegistry // 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 } -// ContractEOStakeRegistryCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// EOStakeRegistryCallerSession is an auto generated read-only Go binding around an Ethereum contract, // with pre-set call options. -type ContractEOStakeRegistryCallerSession struct { - Contract *ContractEOStakeRegistryCaller // Generic contract caller binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session +type EOStakeRegistryCallerSession struct { + Contract *EOStakeRegistryCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session } -// ContractEOStakeRegistryTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// EOStakeRegistryTransactorSession is an auto generated write-only Go binding around an Ethereum contract, // with pre-set transact options. -type ContractEOStakeRegistryTransactorSession struct { - Contract *ContractEOStakeRegistryTransactor // Generic contract transactor binding to set the session for - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +type EOStakeRegistryTransactorSession struct { + Contract *EOStakeRegistryTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session } -// ContractEOStakeRegistryRaw is an auto generated low-level Go binding around an Ethereum contract. -type ContractEOStakeRegistryRaw struct { - Contract *ContractEOStakeRegistry // Generic contract binding to access the raw methods on +// EOStakeRegistryRaw is an auto generated low-level Go binding around an Ethereum contract. +type EOStakeRegistryRaw struct { + Contract *EOStakeRegistry // Generic contract binding to access the raw methods on } -// ContractEOStakeRegistryCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. -type ContractEOStakeRegistryCallerRaw struct { - Contract *ContractEOStakeRegistryCaller // Generic read-only contract binding to access the raw methods on +// EOStakeRegistryCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type EOStakeRegistryCallerRaw struct { + Contract *EOStakeRegistryCaller // Generic read-only contract binding to access the raw methods on } -// ContractEOStakeRegistryTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. -type ContractEOStakeRegistryTransactorRaw struct { - Contract *ContractEOStakeRegistryTransactor // Generic write-only contract binding to access the raw methods on +// EOStakeRegistryTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type EOStakeRegistryTransactorRaw struct { + Contract *EOStakeRegistryTransactor // Generic write-only contract binding to access the raw methods on } -// NewContractEOStakeRegistry creates a new instance of ContractEOStakeRegistry, bound to a specific deployed contract. -func NewContractEOStakeRegistry(address common.Address, backend bind.ContractBackend) (*ContractEOStakeRegistry, error) { - contract, err := bindContractEOStakeRegistry(address, backend, backend, backend) +// NewEOStakeRegistry creates a new instance of EOStakeRegistry, bound to a specific deployed contract. +func NewEOStakeRegistry(address common.Address, backend bind.ContractBackend) (*EOStakeRegistry, error) { + contract, err := bindEOStakeRegistry(address, backend, backend, backend) if err != nil { return nil, err } - return &ContractEOStakeRegistry{ContractEOStakeRegistryCaller: ContractEOStakeRegistryCaller{contract: contract}, ContractEOStakeRegistryTransactor: ContractEOStakeRegistryTransactor{contract: contract}, ContractEOStakeRegistryFilterer: ContractEOStakeRegistryFilterer{contract: contract}}, nil + return &EOStakeRegistry{EOStakeRegistryCaller: EOStakeRegistryCaller{contract: contract}, EOStakeRegistryTransactor: EOStakeRegistryTransactor{contract: contract}, EOStakeRegistryFilterer: EOStakeRegistryFilterer{contract: contract}}, nil } -// NewContractEOStakeRegistryCaller creates a new read-only instance of ContractEOStakeRegistry, bound to a specific deployed contract. -func NewContractEOStakeRegistryCaller(address common.Address, caller bind.ContractCaller) (*ContractEOStakeRegistryCaller, error) { - contract, err := bindContractEOStakeRegistry(address, caller, nil, nil) +// NewEOStakeRegistryCaller creates a new read-only instance of EOStakeRegistry, bound to a specific deployed contract. +func NewEOStakeRegistryCaller(address common.Address, caller bind.ContractCaller) (*EOStakeRegistryCaller, error) { + contract, err := bindEOStakeRegistry(address, caller, nil, nil) if err != nil { return nil, err } - return &ContractEOStakeRegistryCaller{contract: contract}, nil + return &EOStakeRegistryCaller{contract: contract}, nil } -// NewContractEOStakeRegistryTransactor creates a new write-only instance of ContractEOStakeRegistry, bound to a specific deployed contract. -func NewContractEOStakeRegistryTransactor(address common.Address, transactor bind.ContractTransactor) (*ContractEOStakeRegistryTransactor, error) { - contract, err := bindContractEOStakeRegistry(address, nil, transactor, nil) +// NewEOStakeRegistryTransactor creates a new write-only instance of EOStakeRegistry, bound to a specific deployed contract. +func NewEOStakeRegistryTransactor(address common.Address, transactor bind.ContractTransactor) (*EOStakeRegistryTransactor, error) { + contract, err := bindEOStakeRegistry(address, nil, transactor, nil) if err != nil { return nil, err } - return &ContractEOStakeRegistryTransactor{contract: contract}, nil + return &EOStakeRegistryTransactor{contract: contract}, nil } -// NewContractEOStakeRegistryFilterer creates a new log filterer instance of ContractEOStakeRegistry, bound to a specific deployed contract. -func NewContractEOStakeRegistryFilterer(address common.Address, filterer bind.ContractFilterer) (*ContractEOStakeRegistryFilterer, error) { - contract, err := bindContractEOStakeRegistry(address, nil, nil, filterer) +// NewEOStakeRegistryFilterer creates a new log filterer instance of EOStakeRegistry, bound to a specific deployed contract. +func NewEOStakeRegistryFilterer(address common.Address, filterer bind.ContractFilterer) (*EOStakeRegistryFilterer, error) { + contract, err := bindEOStakeRegistry(address, nil, nil, filterer) if err != nil { return nil, err } - return &ContractEOStakeRegistryFilterer{contract: contract}, nil + return &EOStakeRegistryFilterer{contract: contract}, nil } -// bindContractEOStakeRegistry binds a generic wrapper to an already deployed contract. -func bindContractEOStakeRegistry(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { - parsed, err := ContractEOStakeRegistryMetaData.GetAbi() +// bindEOStakeRegistry binds a generic wrapper to an already deployed contract. +func bindEOStakeRegistry(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := EOStakeRegistryMetaData.GetAbi() if err != nil { return nil, err } @@ -298,46 +159,46 @@ func bindContractEOStakeRegistry(address common.Address, caller bind.ContractCal // 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 (_ContractEOStakeRegistry *ContractEOStakeRegistryRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _ContractEOStakeRegistry.Contract.ContractEOStakeRegistryCaller.contract.Call(opts, result, method, params...) +func (_EOStakeRegistry *EOStakeRegistryRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _EOStakeRegistry.Contract.EOStakeRegistryCaller.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 (_ContractEOStakeRegistry *ContractEOStakeRegistryRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _ContractEOStakeRegistry.Contract.ContractEOStakeRegistryTransactor.contract.Transfer(opts) +func (_EOStakeRegistry *EOStakeRegistryRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _EOStakeRegistry.Contract.EOStakeRegistryTransactor.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. -func (_ContractEOStakeRegistry *ContractEOStakeRegistryRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _ContractEOStakeRegistry.Contract.ContractEOStakeRegistryTransactor.contract.Transact(opts, method, params...) +func (_EOStakeRegistry *EOStakeRegistryRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _EOStakeRegistry.Contract.EOStakeRegistryTransactor.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 (_ContractEOStakeRegistry *ContractEOStakeRegistryCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _ContractEOStakeRegistry.Contract.contract.Call(opts, result, method, params...) +func (_EOStakeRegistry *EOStakeRegistryCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _EOStakeRegistry.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 (_ContractEOStakeRegistry *ContractEOStakeRegistryTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _ContractEOStakeRegistry.Contract.contract.Transfer(opts) +func (_EOStakeRegistry *EOStakeRegistryTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _EOStakeRegistry.Contract.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. -func (_ContractEOStakeRegistry *ContractEOStakeRegistryTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _ContractEOStakeRegistry.Contract.contract.Transact(opts, method, params...) +func (_EOStakeRegistry *EOStakeRegistryTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _EOStakeRegistry.Contract.contract.Transact(opts, method, params...) } // MAXWEIGHINGFUNCTIONLENGTH is a free data retrieval call binding the contract method 0x7c172347. // // Solidity: function MAX_WEIGHING_FUNCTION_LENGTH() view returns(uint8) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryCaller) MAXWEIGHINGFUNCTIONLENGTH(opts *bind.CallOpts) (uint8, error) { +func (_EOStakeRegistry *EOStakeRegistryCaller) MAXWEIGHINGFUNCTIONLENGTH(opts *bind.CallOpts) (uint8, error) { var out []interface{} - err := _ContractEOStakeRegistry.contract.Call(opts, &out, "MAX_WEIGHING_FUNCTION_LENGTH") + err := _EOStakeRegistry.contract.Call(opts, &out, "MAX_WEIGHING_FUNCTION_LENGTH") if err != nil { return *new(uint8), err @@ -352,23 +213,23 @@ func (_ContractEOStakeRegistry *ContractEOStakeRegistryCaller) MAXWEIGHINGFUNCTI // MAXWEIGHINGFUNCTIONLENGTH is a free data retrieval call binding the contract method 0x7c172347. // // Solidity: function MAX_WEIGHING_FUNCTION_LENGTH() view returns(uint8) -func (_ContractEOStakeRegistry *ContractEOStakeRegistrySession) MAXWEIGHINGFUNCTIONLENGTH() (uint8, error) { - return _ContractEOStakeRegistry.Contract.MAXWEIGHINGFUNCTIONLENGTH(&_ContractEOStakeRegistry.CallOpts) +func (_EOStakeRegistry *EOStakeRegistrySession) MAXWEIGHINGFUNCTIONLENGTH() (uint8, error) { + return _EOStakeRegistry.Contract.MAXWEIGHINGFUNCTIONLENGTH(&_EOStakeRegistry.CallOpts) } // MAXWEIGHINGFUNCTIONLENGTH is a free data retrieval call binding the contract method 0x7c172347. // // Solidity: function MAX_WEIGHING_FUNCTION_LENGTH() view returns(uint8) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryCallerSession) MAXWEIGHINGFUNCTIONLENGTH() (uint8, error) { - return _ContractEOStakeRegistry.Contract.MAXWEIGHINGFUNCTIONLENGTH(&_ContractEOStakeRegistry.CallOpts) +func (_EOStakeRegistry *EOStakeRegistryCallerSession) MAXWEIGHINGFUNCTIONLENGTH() (uint8, error) { + return _EOStakeRegistry.Contract.MAXWEIGHINGFUNCTIONLENGTH(&_EOStakeRegistry.CallOpts) } // WEIGHTINGDIVISOR is a free data retrieval call binding the contract method 0x5e5a6775. // // Solidity: function WEIGHTING_DIVISOR() view returns(uint256) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryCaller) WEIGHTINGDIVISOR(opts *bind.CallOpts) (*big.Int, error) { +func (_EOStakeRegistry *EOStakeRegistryCaller) WEIGHTINGDIVISOR(opts *bind.CallOpts) (*big.Int, error) { var out []interface{} - err := _ContractEOStakeRegistry.contract.Call(opts, &out, "WEIGHTING_DIVISOR") + err := _EOStakeRegistry.contract.Call(opts, &out, "WEIGHTING_DIVISOR") if err != nil { return *new(*big.Int), err @@ -383,23 +244,116 @@ func (_ContractEOStakeRegistry *ContractEOStakeRegistryCaller) WEIGHTINGDIVISOR( // WEIGHTINGDIVISOR is a free data retrieval call binding the contract method 0x5e5a6775. // // Solidity: function WEIGHTING_DIVISOR() view returns(uint256) -func (_ContractEOStakeRegistry *ContractEOStakeRegistrySession) WEIGHTINGDIVISOR() (*big.Int, error) { - return _ContractEOStakeRegistry.Contract.WEIGHTINGDIVISOR(&_ContractEOStakeRegistry.CallOpts) +func (_EOStakeRegistry *EOStakeRegistrySession) WEIGHTINGDIVISOR() (*big.Int, error) { + return _EOStakeRegistry.Contract.WEIGHTINGDIVISOR(&_EOStakeRegistry.CallOpts) } // WEIGHTINGDIVISOR is a free data retrieval call binding the contract method 0x5e5a6775. // // Solidity: function WEIGHTING_DIVISOR() view returns(uint256) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryCallerSession) WEIGHTINGDIVISOR() (*big.Int, error) { - return _ContractEOStakeRegistry.Contract.WEIGHTINGDIVISOR(&_ContractEOStakeRegistry.CallOpts) +func (_EOStakeRegistry *EOStakeRegistryCallerSession) WEIGHTINGDIVISOR() (*big.Int, error) { + return _EOStakeRegistry.Contract.WEIGHTINGDIVISOR(&_EOStakeRegistry.CallOpts) +} + +// AllocationManager is a free data retrieval call binding the contract method 0xca8aa7c7. +// +// Solidity: function allocationManager() view returns(address) +func (_EOStakeRegistry *EOStakeRegistryCaller) AllocationManager(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _EOStakeRegistry.contract.Call(opts, &out, "allocationManager") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// AllocationManager is a free data retrieval call binding the contract method 0xca8aa7c7. +// +// Solidity: function allocationManager() view returns(address) +func (_EOStakeRegistry *EOStakeRegistrySession) AllocationManager() (common.Address, error) { + return _EOStakeRegistry.Contract.AllocationManager(&_EOStakeRegistry.CallOpts) +} + +// AllocationManager is a free data retrieval call binding the contract method 0xca8aa7c7. +// +// Solidity: function allocationManager() view returns(address) +func (_EOStakeRegistry *EOStakeRegistryCallerSession) AllocationManager() (common.Address, error) { + return _EOStakeRegistry.Contract.AllocationManager(&_EOStakeRegistry.CallOpts) +} + +// AvsDirectory is a free data retrieval call binding the contract method 0x6b3aa72e. +// +// Solidity: function avsDirectory() view returns(address) +func (_EOStakeRegistry *EOStakeRegistryCaller) AvsDirectory(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _EOStakeRegistry.contract.Call(opts, &out, "avsDirectory") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// AvsDirectory is a free data retrieval call binding the contract method 0x6b3aa72e. +// +// Solidity: function avsDirectory() view returns(address) +func (_EOStakeRegistry *EOStakeRegistrySession) AvsDirectory() (common.Address, error) { + return _EOStakeRegistry.Contract.AvsDirectory(&_EOStakeRegistry.CallOpts) +} + +// AvsDirectory is a free data retrieval call binding the contract method 0x6b3aa72e. +// +// Solidity: function avsDirectory() view returns(address) +func (_EOStakeRegistry *EOStakeRegistryCallerSession) AvsDirectory() (common.Address, error) { + return _EOStakeRegistry.Contract.AvsDirectory(&_EOStakeRegistry.CallOpts) +} + +// ChainManager is a free data retrieval call binding the contract method 0x5d824812. +// +// Solidity: function chainManager() view returns(address) +func (_EOStakeRegistry *EOStakeRegistryCaller) ChainManager(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _EOStakeRegistry.contract.Call(opts, &out, "chainManager") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// ChainManager is a free data retrieval call binding the contract method 0x5d824812. +// +// Solidity: function chainManager() view returns(address) +func (_EOStakeRegistry *EOStakeRegistrySession) ChainManager() (common.Address, error) { + return _EOStakeRegistry.Contract.ChainManager(&_EOStakeRegistry.CallOpts) +} + +// ChainManager is a free data retrieval call binding the contract method 0x5d824812. +// +// Solidity: function chainManager() view returns(address) +func (_EOStakeRegistry *EOStakeRegistryCallerSession) ChainManager() (common.Address, error) { + return _EOStakeRegistry.Contract.ChainManager(&_EOStakeRegistry.CallOpts) } // Delegation is a free data retrieval call binding the contract method 0xdf5cf723. // // Solidity: function delegation() view returns(address) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryCaller) Delegation(opts *bind.CallOpts) (common.Address, error) { +func (_EOStakeRegistry *EOStakeRegistryCaller) Delegation(opts *bind.CallOpts) (common.Address, error) { var out []interface{} - err := _ContractEOStakeRegistry.contract.Call(opts, &out, "delegation") + err := _EOStakeRegistry.contract.Call(opts, &out, "delegation") if err != nil { return *new(common.Address), err @@ -414,23 +368,23 @@ func (_ContractEOStakeRegistry *ContractEOStakeRegistryCaller) Delegation(opts * // Delegation is a free data retrieval call binding the contract method 0xdf5cf723. // // Solidity: function delegation() view returns(address) -func (_ContractEOStakeRegistry *ContractEOStakeRegistrySession) Delegation() (common.Address, error) { - return _ContractEOStakeRegistry.Contract.Delegation(&_ContractEOStakeRegistry.CallOpts) +func (_EOStakeRegistry *EOStakeRegistrySession) Delegation() (common.Address, error) { + return _EOStakeRegistry.Contract.Delegation(&_EOStakeRegistry.CallOpts) } // Delegation is a free data retrieval call binding the contract method 0xdf5cf723. // // Solidity: function delegation() view returns(address) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryCallerSession) Delegation() (common.Address, error) { - return _ContractEOStakeRegistry.Contract.Delegation(&_ContractEOStakeRegistry.CallOpts) +func (_EOStakeRegistry *EOStakeRegistryCallerSession) Delegation() (common.Address, error) { + return _EOStakeRegistry.Contract.Delegation(&_EOStakeRegistry.CallOpts) } // GetCurrentStake is a free data retrieval call binding the contract method 0x5401ed27. // // Solidity: function getCurrentStake(bytes32 operatorId, uint8 quorumNumber) view returns(uint96) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryCaller) GetCurrentStake(opts *bind.CallOpts, operatorId [32]byte, quorumNumber uint8) (*big.Int, error) { +func (_EOStakeRegistry *EOStakeRegistryCaller) GetCurrentStake(opts *bind.CallOpts, operatorId [32]byte, quorumNumber uint8) (*big.Int, error) { var out []interface{} - err := _ContractEOStakeRegistry.contract.Call(opts, &out, "getCurrentStake", operatorId, quorumNumber) + err := _EOStakeRegistry.contract.Call(opts, &out, "getCurrentStake", operatorId, quorumNumber) if err != nil { return *new(*big.Int), err @@ -445,23 +399,23 @@ func (_ContractEOStakeRegistry *ContractEOStakeRegistryCaller) GetCurrentStake(o // GetCurrentStake is a free data retrieval call binding the contract method 0x5401ed27. // // Solidity: function getCurrentStake(bytes32 operatorId, uint8 quorumNumber) view returns(uint96) -func (_ContractEOStakeRegistry *ContractEOStakeRegistrySession) GetCurrentStake(operatorId [32]byte, quorumNumber uint8) (*big.Int, error) { - return _ContractEOStakeRegistry.Contract.GetCurrentStake(&_ContractEOStakeRegistry.CallOpts, operatorId, quorumNumber) +func (_EOStakeRegistry *EOStakeRegistrySession) GetCurrentStake(operatorId [32]byte, quorumNumber uint8) (*big.Int, error) { + return _EOStakeRegistry.Contract.GetCurrentStake(&_EOStakeRegistry.CallOpts, operatorId, quorumNumber) } // GetCurrentStake is a free data retrieval call binding the contract method 0x5401ed27. // // Solidity: function getCurrentStake(bytes32 operatorId, uint8 quorumNumber) view returns(uint96) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryCallerSession) GetCurrentStake(operatorId [32]byte, quorumNumber uint8) (*big.Int, error) { - return _ContractEOStakeRegistry.Contract.GetCurrentStake(&_ContractEOStakeRegistry.CallOpts, operatorId, quorumNumber) +func (_EOStakeRegistry *EOStakeRegistryCallerSession) GetCurrentStake(operatorId [32]byte, quorumNumber uint8) (*big.Int, error) { + return _EOStakeRegistry.Contract.GetCurrentStake(&_EOStakeRegistry.CallOpts, operatorId, quorumNumber) } // GetCurrentTotalStake is a free data retrieval call binding the contract method 0xd5eccc05. // // Solidity: function getCurrentTotalStake(uint8 quorumNumber) view returns(uint96) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryCaller) GetCurrentTotalStake(opts *bind.CallOpts, quorumNumber uint8) (*big.Int, error) { +func (_EOStakeRegistry *EOStakeRegistryCaller) GetCurrentTotalStake(opts *bind.CallOpts, quorumNumber uint8) (*big.Int, error) { var out []interface{} - err := _ContractEOStakeRegistry.contract.Call(opts, &out, "getCurrentTotalStake", quorumNumber) + err := _EOStakeRegistry.contract.Call(opts, &out, "getCurrentTotalStake", quorumNumber) if err != nil { return *new(*big.Int), err @@ -476,29 +430,29 @@ func (_ContractEOStakeRegistry *ContractEOStakeRegistryCaller) GetCurrentTotalSt // GetCurrentTotalStake is a free data retrieval call binding the contract method 0xd5eccc05. // // Solidity: function getCurrentTotalStake(uint8 quorumNumber) view returns(uint96) -func (_ContractEOStakeRegistry *ContractEOStakeRegistrySession) GetCurrentTotalStake(quorumNumber uint8) (*big.Int, error) { - return _ContractEOStakeRegistry.Contract.GetCurrentTotalStake(&_ContractEOStakeRegistry.CallOpts, quorumNumber) +func (_EOStakeRegistry *EOStakeRegistrySession) GetCurrentTotalStake(quorumNumber uint8) (*big.Int, error) { + return _EOStakeRegistry.Contract.GetCurrentTotalStake(&_EOStakeRegistry.CallOpts, quorumNumber) } // GetCurrentTotalStake is a free data retrieval call binding the contract method 0xd5eccc05. // // Solidity: function getCurrentTotalStake(uint8 quorumNumber) view returns(uint96) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryCallerSession) GetCurrentTotalStake(quorumNumber uint8) (*big.Int, error) { - return _ContractEOStakeRegistry.Contract.GetCurrentTotalStake(&_ContractEOStakeRegistry.CallOpts, quorumNumber) +func (_EOStakeRegistry *EOStakeRegistryCallerSession) GetCurrentTotalStake(quorumNumber uint8) (*big.Int, error) { + return _EOStakeRegistry.Contract.GetCurrentTotalStake(&_EOStakeRegistry.CallOpts, quorumNumber) } // GetLatestStakeUpdate is a free data retrieval call binding the contract method 0xf851e198. // // Solidity: function getLatestStakeUpdate(bytes32 operatorId, uint8 quorumNumber) view returns((uint32,uint32,uint96)) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryCaller) GetLatestStakeUpdate(opts *bind.CallOpts, operatorId [32]byte, quorumNumber uint8) (IEOStakeRegistryStakeUpdate, error) { +func (_EOStakeRegistry *EOStakeRegistryCaller) GetLatestStakeUpdate(opts *bind.CallOpts, operatorId [32]byte, quorumNumber uint8) (IStakeRegistryTypesStakeUpdate, error) { var out []interface{} - err := _ContractEOStakeRegistry.contract.Call(opts, &out, "getLatestStakeUpdate", operatorId, quorumNumber) + err := _EOStakeRegistry.contract.Call(opts, &out, "getLatestStakeUpdate", operatorId, quorumNumber) if err != nil { - return *new(IEOStakeRegistryStakeUpdate), err + return *new(IStakeRegistryTypesStakeUpdate), err } - out0 := *abi.ConvertType(out[0], new(IEOStakeRegistryStakeUpdate)).(*IEOStakeRegistryStakeUpdate) + out0 := *abi.ConvertType(out[0], new(IStakeRegistryTypesStakeUpdate)).(*IStakeRegistryTypesStakeUpdate) return out0, err @@ -507,23 +461,23 @@ func (_ContractEOStakeRegistry *ContractEOStakeRegistryCaller) GetLatestStakeUpd // GetLatestStakeUpdate is a free data retrieval call binding the contract method 0xf851e198. // // Solidity: function getLatestStakeUpdate(bytes32 operatorId, uint8 quorumNumber) view returns((uint32,uint32,uint96)) -func (_ContractEOStakeRegistry *ContractEOStakeRegistrySession) GetLatestStakeUpdate(operatorId [32]byte, quorumNumber uint8) (IEOStakeRegistryStakeUpdate, error) { - return _ContractEOStakeRegistry.Contract.GetLatestStakeUpdate(&_ContractEOStakeRegistry.CallOpts, operatorId, quorumNumber) +func (_EOStakeRegistry *EOStakeRegistrySession) GetLatestStakeUpdate(operatorId [32]byte, quorumNumber uint8) (IStakeRegistryTypesStakeUpdate, error) { + return _EOStakeRegistry.Contract.GetLatestStakeUpdate(&_EOStakeRegistry.CallOpts, operatorId, quorumNumber) } // GetLatestStakeUpdate is a free data retrieval call binding the contract method 0xf851e198. // // Solidity: function getLatestStakeUpdate(bytes32 operatorId, uint8 quorumNumber) view returns((uint32,uint32,uint96)) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryCallerSession) GetLatestStakeUpdate(operatorId [32]byte, quorumNumber uint8) (IEOStakeRegistryStakeUpdate, error) { - return _ContractEOStakeRegistry.Contract.GetLatestStakeUpdate(&_ContractEOStakeRegistry.CallOpts, operatorId, quorumNumber) +func (_EOStakeRegistry *EOStakeRegistryCallerSession) GetLatestStakeUpdate(operatorId [32]byte, quorumNumber uint8) (IStakeRegistryTypesStakeUpdate, error) { + return _EOStakeRegistry.Contract.GetLatestStakeUpdate(&_EOStakeRegistry.CallOpts, operatorId, quorumNumber) } // GetStakeAtBlockNumber is a free data retrieval call binding the contract method 0xfa28c627. // // Solidity: function getStakeAtBlockNumber(bytes32 operatorId, uint8 quorumNumber, uint32 blockNumber) view returns(uint96) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryCaller) GetStakeAtBlockNumber(opts *bind.CallOpts, operatorId [32]byte, quorumNumber uint8, blockNumber uint32) (*big.Int, error) { +func (_EOStakeRegistry *EOStakeRegistryCaller) GetStakeAtBlockNumber(opts *bind.CallOpts, operatorId [32]byte, quorumNumber uint8, blockNumber uint32) (*big.Int, error) { var out []interface{} - err := _ContractEOStakeRegistry.contract.Call(opts, &out, "getStakeAtBlockNumber", operatorId, quorumNumber, blockNumber) + err := _EOStakeRegistry.contract.Call(opts, &out, "getStakeAtBlockNumber", operatorId, quorumNumber, blockNumber) if err != nil { return *new(*big.Int), err @@ -538,23 +492,23 @@ func (_ContractEOStakeRegistry *ContractEOStakeRegistryCaller) GetStakeAtBlockNu // GetStakeAtBlockNumber is a free data retrieval call binding the contract method 0xfa28c627. // // Solidity: function getStakeAtBlockNumber(bytes32 operatorId, uint8 quorumNumber, uint32 blockNumber) view returns(uint96) -func (_ContractEOStakeRegistry *ContractEOStakeRegistrySession) GetStakeAtBlockNumber(operatorId [32]byte, quorumNumber uint8, blockNumber uint32) (*big.Int, error) { - return _ContractEOStakeRegistry.Contract.GetStakeAtBlockNumber(&_ContractEOStakeRegistry.CallOpts, operatorId, quorumNumber, blockNumber) +func (_EOStakeRegistry *EOStakeRegistrySession) GetStakeAtBlockNumber(operatorId [32]byte, quorumNumber uint8, blockNumber uint32) (*big.Int, error) { + return _EOStakeRegistry.Contract.GetStakeAtBlockNumber(&_EOStakeRegistry.CallOpts, operatorId, quorumNumber, blockNumber) } // GetStakeAtBlockNumber is a free data retrieval call binding the contract method 0xfa28c627. // // Solidity: function getStakeAtBlockNumber(bytes32 operatorId, uint8 quorumNumber, uint32 blockNumber) view returns(uint96) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryCallerSession) GetStakeAtBlockNumber(operatorId [32]byte, quorumNumber uint8, blockNumber uint32) (*big.Int, error) { - return _ContractEOStakeRegistry.Contract.GetStakeAtBlockNumber(&_ContractEOStakeRegistry.CallOpts, operatorId, quorumNumber, blockNumber) +func (_EOStakeRegistry *EOStakeRegistryCallerSession) GetStakeAtBlockNumber(operatorId [32]byte, quorumNumber uint8, blockNumber uint32) (*big.Int, error) { + return _EOStakeRegistry.Contract.GetStakeAtBlockNumber(&_EOStakeRegistry.CallOpts, operatorId, quorumNumber, blockNumber) } // GetStakeAtBlockNumberAndIndex is a free data retrieval call binding the contract method 0xf2be94ae. // // Solidity: function getStakeAtBlockNumberAndIndex(uint8 quorumNumber, uint32 blockNumber, bytes32 operatorId, uint256 index) view returns(uint96) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryCaller) GetStakeAtBlockNumberAndIndex(opts *bind.CallOpts, quorumNumber uint8, blockNumber uint32, operatorId [32]byte, index *big.Int) (*big.Int, error) { +func (_EOStakeRegistry *EOStakeRegistryCaller) GetStakeAtBlockNumberAndIndex(opts *bind.CallOpts, quorumNumber uint8, blockNumber uint32, operatorId [32]byte, index *big.Int) (*big.Int, error) { var out []interface{} - err := _ContractEOStakeRegistry.contract.Call(opts, &out, "getStakeAtBlockNumberAndIndex", quorumNumber, blockNumber, operatorId, index) + err := _EOStakeRegistry.contract.Call(opts, &out, "getStakeAtBlockNumberAndIndex", quorumNumber, blockNumber, operatorId, index) if err != nil { return *new(*big.Int), err @@ -569,29 +523,29 @@ func (_ContractEOStakeRegistry *ContractEOStakeRegistryCaller) GetStakeAtBlockNu // GetStakeAtBlockNumberAndIndex is a free data retrieval call binding the contract method 0xf2be94ae. // // Solidity: function getStakeAtBlockNumberAndIndex(uint8 quorumNumber, uint32 blockNumber, bytes32 operatorId, uint256 index) view returns(uint96) -func (_ContractEOStakeRegistry *ContractEOStakeRegistrySession) GetStakeAtBlockNumberAndIndex(quorumNumber uint8, blockNumber uint32, operatorId [32]byte, index *big.Int) (*big.Int, error) { - return _ContractEOStakeRegistry.Contract.GetStakeAtBlockNumberAndIndex(&_ContractEOStakeRegistry.CallOpts, quorumNumber, blockNumber, operatorId, index) +func (_EOStakeRegistry *EOStakeRegistrySession) GetStakeAtBlockNumberAndIndex(quorumNumber uint8, blockNumber uint32, operatorId [32]byte, index *big.Int) (*big.Int, error) { + return _EOStakeRegistry.Contract.GetStakeAtBlockNumberAndIndex(&_EOStakeRegistry.CallOpts, quorumNumber, blockNumber, operatorId, index) } // GetStakeAtBlockNumberAndIndex is a free data retrieval call binding the contract method 0xf2be94ae. // // Solidity: function getStakeAtBlockNumberAndIndex(uint8 quorumNumber, uint32 blockNumber, bytes32 operatorId, uint256 index) view returns(uint96) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryCallerSession) GetStakeAtBlockNumberAndIndex(quorumNumber uint8, blockNumber uint32, operatorId [32]byte, index *big.Int) (*big.Int, error) { - return _ContractEOStakeRegistry.Contract.GetStakeAtBlockNumberAndIndex(&_ContractEOStakeRegistry.CallOpts, quorumNumber, blockNumber, operatorId, index) +func (_EOStakeRegistry *EOStakeRegistryCallerSession) GetStakeAtBlockNumberAndIndex(quorumNumber uint8, blockNumber uint32, operatorId [32]byte, index *big.Int) (*big.Int, error) { + return _EOStakeRegistry.Contract.GetStakeAtBlockNumberAndIndex(&_EOStakeRegistry.CallOpts, quorumNumber, blockNumber, operatorId, index) } // GetStakeHistory is a free data retrieval call binding the contract method 0x2cd95940. // // Solidity: function getStakeHistory(bytes32 operatorId, uint8 quorumNumber) view returns((uint32,uint32,uint96)[]) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryCaller) GetStakeHistory(opts *bind.CallOpts, operatorId [32]byte, quorumNumber uint8) ([]IEOStakeRegistryStakeUpdate, error) { +func (_EOStakeRegistry *EOStakeRegistryCaller) GetStakeHistory(opts *bind.CallOpts, operatorId [32]byte, quorumNumber uint8) ([]IStakeRegistryTypesStakeUpdate, error) { var out []interface{} - err := _ContractEOStakeRegistry.contract.Call(opts, &out, "getStakeHistory", operatorId, quorumNumber) + err := _EOStakeRegistry.contract.Call(opts, &out, "getStakeHistory", operatorId, quorumNumber) if err != nil { - return *new([]IEOStakeRegistryStakeUpdate), err + return *new([]IStakeRegistryTypesStakeUpdate), err } - out0 := *abi.ConvertType(out[0], new([]IEOStakeRegistryStakeUpdate)).(*[]IEOStakeRegistryStakeUpdate) + out0 := *abi.ConvertType(out[0], new([]IStakeRegistryTypesStakeUpdate)).(*[]IStakeRegistryTypesStakeUpdate) return out0, err @@ -600,23 +554,23 @@ func (_ContractEOStakeRegistry *ContractEOStakeRegistryCaller) GetStakeHistory(o // GetStakeHistory is a free data retrieval call binding the contract method 0x2cd95940. // // Solidity: function getStakeHistory(bytes32 operatorId, uint8 quorumNumber) view returns((uint32,uint32,uint96)[]) -func (_ContractEOStakeRegistry *ContractEOStakeRegistrySession) GetStakeHistory(operatorId [32]byte, quorumNumber uint8) ([]IEOStakeRegistryStakeUpdate, error) { - return _ContractEOStakeRegistry.Contract.GetStakeHistory(&_ContractEOStakeRegistry.CallOpts, operatorId, quorumNumber) +func (_EOStakeRegistry *EOStakeRegistrySession) GetStakeHistory(operatorId [32]byte, quorumNumber uint8) ([]IStakeRegistryTypesStakeUpdate, error) { + return _EOStakeRegistry.Contract.GetStakeHistory(&_EOStakeRegistry.CallOpts, operatorId, quorumNumber) } // GetStakeHistory is a free data retrieval call binding the contract method 0x2cd95940. // // Solidity: function getStakeHistory(bytes32 operatorId, uint8 quorumNumber) view returns((uint32,uint32,uint96)[]) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryCallerSession) GetStakeHistory(operatorId [32]byte, quorumNumber uint8) ([]IEOStakeRegistryStakeUpdate, error) { - return _ContractEOStakeRegistry.Contract.GetStakeHistory(&_ContractEOStakeRegistry.CallOpts, operatorId, quorumNumber) +func (_EOStakeRegistry *EOStakeRegistryCallerSession) GetStakeHistory(operatorId [32]byte, quorumNumber uint8) ([]IStakeRegistryTypesStakeUpdate, error) { + return _EOStakeRegistry.Contract.GetStakeHistory(&_EOStakeRegistry.CallOpts, operatorId, quorumNumber) } // GetStakeHistoryLength is a free data retrieval call binding the contract method 0x4bd26e09. // // Solidity: function getStakeHistoryLength(bytes32 operatorId, uint8 quorumNumber) view returns(uint256) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryCaller) GetStakeHistoryLength(opts *bind.CallOpts, operatorId [32]byte, quorumNumber uint8) (*big.Int, error) { +func (_EOStakeRegistry *EOStakeRegistryCaller) GetStakeHistoryLength(opts *bind.CallOpts, operatorId [32]byte, quorumNumber uint8) (*big.Int, error) { var out []interface{} - err := _ContractEOStakeRegistry.contract.Call(opts, &out, "getStakeHistoryLength", operatorId, quorumNumber) + err := _EOStakeRegistry.contract.Call(opts, &out, "getStakeHistoryLength", operatorId, quorumNumber) if err != nil { return *new(*big.Int), err @@ -631,29 +585,29 @@ func (_ContractEOStakeRegistry *ContractEOStakeRegistryCaller) GetStakeHistoryLe // GetStakeHistoryLength is a free data retrieval call binding the contract method 0x4bd26e09. // // Solidity: function getStakeHistoryLength(bytes32 operatorId, uint8 quorumNumber) view returns(uint256) -func (_ContractEOStakeRegistry *ContractEOStakeRegistrySession) GetStakeHistoryLength(operatorId [32]byte, quorumNumber uint8) (*big.Int, error) { - return _ContractEOStakeRegistry.Contract.GetStakeHistoryLength(&_ContractEOStakeRegistry.CallOpts, operatorId, quorumNumber) +func (_EOStakeRegistry *EOStakeRegistrySession) GetStakeHistoryLength(operatorId [32]byte, quorumNumber uint8) (*big.Int, error) { + return _EOStakeRegistry.Contract.GetStakeHistoryLength(&_EOStakeRegistry.CallOpts, operatorId, quorumNumber) } // GetStakeHistoryLength is a free data retrieval call binding the contract method 0x4bd26e09. // // Solidity: function getStakeHistoryLength(bytes32 operatorId, uint8 quorumNumber) view returns(uint256) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryCallerSession) GetStakeHistoryLength(operatorId [32]byte, quorumNumber uint8) (*big.Int, error) { - return _ContractEOStakeRegistry.Contract.GetStakeHistoryLength(&_ContractEOStakeRegistry.CallOpts, operatorId, quorumNumber) +func (_EOStakeRegistry *EOStakeRegistryCallerSession) GetStakeHistoryLength(operatorId [32]byte, quorumNumber uint8) (*big.Int, error) { + return _EOStakeRegistry.Contract.GetStakeHistoryLength(&_EOStakeRegistry.CallOpts, operatorId, quorumNumber) } // GetStakeUpdateAtIndex is a free data retrieval call binding the contract method 0xac6bfb03. // // Solidity: function getStakeUpdateAtIndex(uint8 quorumNumber, bytes32 operatorId, uint256 index) view returns((uint32,uint32,uint96)) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryCaller) GetStakeUpdateAtIndex(opts *bind.CallOpts, quorumNumber uint8, operatorId [32]byte, index *big.Int) (IEOStakeRegistryStakeUpdate, error) { +func (_EOStakeRegistry *EOStakeRegistryCaller) GetStakeUpdateAtIndex(opts *bind.CallOpts, quorumNumber uint8, operatorId [32]byte, index *big.Int) (IStakeRegistryTypesStakeUpdate, error) { var out []interface{} - err := _ContractEOStakeRegistry.contract.Call(opts, &out, "getStakeUpdateAtIndex", quorumNumber, operatorId, index) + err := _EOStakeRegistry.contract.Call(opts, &out, "getStakeUpdateAtIndex", quorumNumber, operatorId, index) if err != nil { - return *new(IEOStakeRegistryStakeUpdate), err + return *new(IStakeRegistryTypesStakeUpdate), err } - out0 := *abi.ConvertType(out[0], new(IEOStakeRegistryStakeUpdate)).(*IEOStakeRegistryStakeUpdate) + out0 := *abi.ConvertType(out[0], new(IStakeRegistryTypesStakeUpdate)).(*IStakeRegistryTypesStakeUpdate) return out0, err @@ -662,23 +616,23 @@ func (_ContractEOStakeRegistry *ContractEOStakeRegistryCaller) GetStakeUpdateAtI // GetStakeUpdateAtIndex is a free data retrieval call binding the contract method 0xac6bfb03. // // Solidity: function getStakeUpdateAtIndex(uint8 quorumNumber, bytes32 operatorId, uint256 index) view returns((uint32,uint32,uint96)) -func (_ContractEOStakeRegistry *ContractEOStakeRegistrySession) GetStakeUpdateAtIndex(quorumNumber uint8, operatorId [32]byte, index *big.Int) (IEOStakeRegistryStakeUpdate, error) { - return _ContractEOStakeRegistry.Contract.GetStakeUpdateAtIndex(&_ContractEOStakeRegistry.CallOpts, quorumNumber, operatorId, index) +func (_EOStakeRegistry *EOStakeRegistrySession) GetStakeUpdateAtIndex(quorumNumber uint8, operatorId [32]byte, index *big.Int) (IStakeRegistryTypesStakeUpdate, error) { + return _EOStakeRegistry.Contract.GetStakeUpdateAtIndex(&_EOStakeRegistry.CallOpts, quorumNumber, operatorId, index) } // GetStakeUpdateAtIndex is a free data retrieval call binding the contract method 0xac6bfb03. // // Solidity: function getStakeUpdateAtIndex(uint8 quorumNumber, bytes32 operatorId, uint256 index) view returns((uint32,uint32,uint96)) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryCallerSession) GetStakeUpdateAtIndex(quorumNumber uint8, operatorId [32]byte, index *big.Int) (IEOStakeRegistryStakeUpdate, error) { - return _ContractEOStakeRegistry.Contract.GetStakeUpdateAtIndex(&_ContractEOStakeRegistry.CallOpts, quorumNumber, operatorId, index) +func (_EOStakeRegistry *EOStakeRegistryCallerSession) GetStakeUpdateAtIndex(quorumNumber uint8, operatorId [32]byte, index *big.Int) (IStakeRegistryTypesStakeUpdate, error) { + return _EOStakeRegistry.Contract.GetStakeUpdateAtIndex(&_EOStakeRegistry.CallOpts, quorumNumber, operatorId, index) } // GetStakeUpdateIndexAtBlockNumber is a free data retrieval call binding the contract method 0xdd9846b9. // // Solidity: function getStakeUpdateIndexAtBlockNumber(bytes32 operatorId, uint8 quorumNumber, uint32 blockNumber) view returns(uint32) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryCaller) GetStakeUpdateIndexAtBlockNumber(opts *bind.CallOpts, operatorId [32]byte, quorumNumber uint8, blockNumber uint32) (uint32, error) { +func (_EOStakeRegistry *EOStakeRegistryCaller) GetStakeUpdateIndexAtBlockNumber(opts *bind.CallOpts, operatorId [32]byte, quorumNumber uint8, blockNumber uint32) (uint32, error) { var out []interface{} - err := _ContractEOStakeRegistry.contract.Call(opts, &out, "getStakeUpdateIndexAtBlockNumber", operatorId, quorumNumber, blockNumber) + err := _EOStakeRegistry.contract.Call(opts, &out, "getStakeUpdateIndexAtBlockNumber", operatorId, quorumNumber, blockNumber) if err != nil { return *new(uint32), err @@ -693,23 +647,23 @@ func (_ContractEOStakeRegistry *ContractEOStakeRegistryCaller) GetStakeUpdateInd // GetStakeUpdateIndexAtBlockNumber is a free data retrieval call binding the contract method 0xdd9846b9. // // Solidity: function getStakeUpdateIndexAtBlockNumber(bytes32 operatorId, uint8 quorumNumber, uint32 blockNumber) view returns(uint32) -func (_ContractEOStakeRegistry *ContractEOStakeRegistrySession) GetStakeUpdateIndexAtBlockNumber(operatorId [32]byte, quorumNumber uint8, blockNumber uint32) (uint32, error) { - return _ContractEOStakeRegistry.Contract.GetStakeUpdateIndexAtBlockNumber(&_ContractEOStakeRegistry.CallOpts, operatorId, quorumNumber, blockNumber) +func (_EOStakeRegistry *EOStakeRegistrySession) GetStakeUpdateIndexAtBlockNumber(operatorId [32]byte, quorumNumber uint8, blockNumber uint32) (uint32, error) { + return _EOStakeRegistry.Contract.GetStakeUpdateIndexAtBlockNumber(&_EOStakeRegistry.CallOpts, operatorId, quorumNumber, blockNumber) } // GetStakeUpdateIndexAtBlockNumber is a free data retrieval call binding the contract method 0xdd9846b9. // // Solidity: function getStakeUpdateIndexAtBlockNumber(bytes32 operatorId, uint8 quorumNumber, uint32 blockNumber) view returns(uint32) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryCallerSession) GetStakeUpdateIndexAtBlockNumber(operatorId [32]byte, quorumNumber uint8, blockNumber uint32) (uint32, error) { - return _ContractEOStakeRegistry.Contract.GetStakeUpdateIndexAtBlockNumber(&_ContractEOStakeRegistry.CallOpts, operatorId, quorumNumber, blockNumber) +func (_EOStakeRegistry *EOStakeRegistryCallerSession) GetStakeUpdateIndexAtBlockNumber(operatorId [32]byte, quorumNumber uint8, blockNumber uint32) (uint32, error) { + return _EOStakeRegistry.Contract.GetStakeUpdateIndexAtBlockNumber(&_EOStakeRegistry.CallOpts, operatorId, quorumNumber, blockNumber) } // GetTotalStakeAtBlockNumberFromIndex is a free data retrieval call binding the contract method 0xc8294c56. // // Solidity: function getTotalStakeAtBlockNumberFromIndex(uint8 quorumNumber, uint32 blockNumber, uint256 index) view returns(uint96) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryCaller) GetTotalStakeAtBlockNumberFromIndex(opts *bind.CallOpts, quorumNumber uint8, blockNumber uint32, index *big.Int) (*big.Int, error) { +func (_EOStakeRegistry *EOStakeRegistryCaller) GetTotalStakeAtBlockNumberFromIndex(opts *bind.CallOpts, quorumNumber uint8, blockNumber uint32, index *big.Int) (*big.Int, error) { var out []interface{} - err := _ContractEOStakeRegistry.contract.Call(opts, &out, "getTotalStakeAtBlockNumberFromIndex", quorumNumber, blockNumber, index) + err := _EOStakeRegistry.contract.Call(opts, &out, "getTotalStakeAtBlockNumberFromIndex", quorumNumber, blockNumber, index) if err != nil { return *new(*big.Int), err @@ -724,23 +678,23 @@ func (_ContractEOStakeRegistry *ContractEOStakeRegistryCaller) GetTotalStakeAtBl // GetTotalStakeAtBlockNumberFromIndex is a free data retrieval call binding the contract method 0xc8294c56. // // Solidity: function getTotalStakeAtBlockNumberFromIndex(uint8 quorumNumber, uint32 blockNumber, uint256 index) view returns(uint96) -func (_ContractEOStakeRegistry *ContractEOStakeRegistrySession) GetTotalStakeAtBlockNumberFromIndex(quorumNumber uint8, blockNumber uint32, index *big.Int) (*big.Int, error) { - return _ContractEOStakeRegistry.Contract.GetTotalStakeAtBlockNumberFromIndex(&_ContractEOStakeRegistry.CallOpts, quorumNumber, blockNumber, index) +func (_EOStakeRegistry *EOStakeRegistrySession) GetTotalStakeAtBlockNumberFromIndex(quorumNumber uint8, blockNumber uint32, index *big.Int) (*big.Int, error) { + return _EOStakeRegistry.Contract.GetTotalStakeAtBlockNumberFromIndex(&_EOStakeRegistry.CallOpts, quorumNumber, blockNumber, index) } // GetTotalStakeAtBlockNumberFromIndex is a free data retrieval call binding the contract method 0xc8294c56. // // Solidity: function getTotalStakeAtBlockNumberFromIndex(uint8 quorumNumber, uint32 blockNumber, uint256 index) view returns(uint96) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryCallerSession) GetTotalStakeAtBlockNumberFromIndex(quorumNumber uint8, blockNumber uint32, index *big.Int) (*big.Int, error) { - return _ContractEOStakeRegistry.Contract.GetTotalStakeAtBlockNumberFromIndex(&_ContractEOStakeRegistry.CallOpts, quorumNumber, blockNumber, index) +func (_EOStakeRegistry *EOStakeRegistryCallerSession) GetTotalStakeAtBlockNumberFromIndex(quorumNumber uint8, blockNumber uint32, index *big.Int) (*big.Int, error) { + return _EOStakeRegistry.Contract.GetTotalStakeAtBlockNumberFromIndex(&_EOStakeRegistry.CallOpts, quorumNumber, blockNumber, index) } // GetTotalStakeHistoryLength is a free data retrieval call binding the contract method 0x0491b41c. // // Solidity: function getTotalStakeHistoryLength(uint8 quorumNumber) view returns(uint256) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryCaller) GetTotalStakeHistoryLength(opts *bind.CallOpts, quorumNumber uint8) (*big.Int, error) { +func (_EOStakeRegistry *EOStakeRegistryCaller) GetTotalStakeHistoryLength(opts *bind.CallOpts, quorumNumber uint8) (*big.Int, error) { var out []interface{} - err := _ContractEOStakeRegistry.contract.Call(opts, &out, "getTotalStakeHistoryLength", quorumNumber) + err := _EOStakeRegistry.contract.Call(opts, &out, "getTotalStakeHistoryLength", quorumNumber) if err != nil { return *new(*big.Int), err @@ -755,23 +709,23 @@ func (_ContractEOStakeRegistry *ContractEOStakeRegistryCaller) GetTotalStakeHist // GetTotalStakeHistoryLength is a free data retrieval call binding the contract method 0x0491b41c. // // Solidity: function getTotalStakeHistoryLength(uint8 quorumNumber) view returns(uint256) -func (_ContractEOStakeRegistry *ContractEOStakeRegistrySession) GetTotalStakeHistoryLength(quorumNumber uint8) (*big.Int, error) { - return _ContractEOStakeRegistry.Contract.GetTotalStakeHistoryLength(&_ContractEOStakeRegistry.CallOpts, quorumNumber) +func (_EOStakeRegistry *EOStakeRegistrySession) GetTotalStakeHistoryLength(quorumNumber uint8) (*big.Int, error) { + return _EOStakeRegistry.Contract.GetTotalStakeHistoryLength(&_EOStakeRegistry.CallOpts, quorumNumber) } // GetTotalStakeHistoryLength is a free data retrieval call binding the contract method 0x0491b41c. // // Solidity: function getTotalStakeHistoryLength(uint8 quorumNumber) view returns(uint256) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryCallerSession) GetTotalStakeHistoryLength(quorumNumber uint8) (*big.Int, error) { - return _ContractEOStakeRegistry.Contract.GetTotalStakeHistoryLength(&_ContractEOStakeRegistry.CallOpts, quorumNumber) +func (_EOStakeRegistry *EOStakeRegistryCallerSession) GetTotalStakeHistoryLength(quorumNumber uint8) (*big.Int, error) { + return _EOStakeRegistry.Contract.GetTotalStakeHistoryLength(&_EOStakeRegistry.CallOpts, quorumNumber) } // GetTotalStakeIndicesAtBlockNumber is a free data retrieval call binding the contract method 0x81c07502. // // Solidity: function getTotalStakeIndicesAtBlockNumber(uint32 blockNumber, bytes quorumNumbers) view returns(uint32[]) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryCaller) GetTotalStakeIndicesAtBlockNumber(opts *bind.CallOpts, blockNumber uint32, quorumNumbers []byte) ([]uint32, error) { +func (_EOStakeRegistry *EOStakeRegistryCaller) GetTotalStakeIndicesAtBlockNumber(opts *bind.CallOpts, blockNumber uint32, quorumNumbers []byte) ([]uint32, error) { var out []interface{} - err := _ContractEOStakeRegistry.contract.Call(opts, &out, "getTotalStakeIndicesAtBlockNumber", blockNumber, quorumNumbers) + err := _EOStakeRegistry.contract.Call(opts, &out, "getTotalStakeIndicesAtBlockNumber", blockNumber, quorumNumbers) if err != nil { return *new([]uint32), err @@ -786,29 +740,29 @@ func (_ContractEOStakeRegistry *ContractEOStakeRegistryCaller) GetTotalStakeIndi // GetTotalStakeIndicesAtBlockNumber is a free data retrieval call binding the contract method 0x81c07502. // // Solidity: function getTotalStakeIndicesAtBlockNumber(uint32 blockNumber, bytes quorumNumbers) view returns(uint32[]) -func (_ContractEOStakeRegistry *ContractEOStakeRegistrySession) GetTotalStakeIndicesAtBlockNumber(blockNumber uint32, quorumNumbers []byte) ([]uint32, error) { - return _ContractEOStakeRegistry.Contract.GetTotalStakeIndicesAtBlockNumber(&_ContractEOStakeRegistry.CallOpts, blockNumber, quorumNumbers) +func (_EOStakeRegistry *EOStakeRegistrySession) GetTotalStakeIndicesAtBlockNumber(blockNumber uint32, quorumNumbers []byte) ([]uint32, error) { + return _EOStakeRegistry.Contract.GetTotalStakeIndicesAtBlockNumber(&_EOStakeRegistry.CallOpts, blockNumber, quorumNumbers) } // GetTotalStakeIndicesAtBlockNumber is a free data retrieval call binding the contract method 0x81c07502. // // Solidity: function getTotalStakeIndicesAtBlockNumber(uint32 blockNumber, bytes quorumNumbers) view returns(uint32[]) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryCallerSession) GetTotalStakeIndicesAtBlockNumber(blockNumber uint32, quorumNumbers []byte) ([]uint32, error) { - return _ContractEOStakeRegistry.Contract.GetTotalStakeIndicesAtBlockNumber(&_ContractEOStakeRegistry.CallOpts, blockNumber, quorumNumbers) +func (_EOStakeRegistry *EOStakeRegistryCallerSession) GetTotalStakeIndicesAtBlockNumber(blockNumber uint32, quorumNumbers []byte) ([]uint32, error) { + return _EOStakeRegistry.Contract.GetTotalStakeIndicesAtBlockNumber(&_EOStakeRegistry.CallOpts, blockNumber, quorumNumbers) } // GetTotalStakeUpdateAtIndex is a free data retrieval call binding the contract method 0xb6904b78. // // Solidity: function getTotalStakeUpdateAtIndex(uint8 quorumNumber, uint256 index) view returns((uint32,uint32,uint96)) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryCaller) GetTotalStakeUpdateAtIndex(opts *bind.CallOpts, quorumNumber uint8, index *big.Int) (IEOStakeRegistryStakeUpdate, error) { +func (_EOStakeRegistry *EOStakeRegistryCaller) GetTotalStakeUpdateAtIndex(opts *bind.CallOpts, quorumNumber uint8, index *big.Int) (IStakeRegistryTypesStakeUpdate, error) { var out []interface{} - err := _ContractEOStakeRegistry.contract.Call(opts, &out, "getTotalStakeUpdateAtIndex", quorumNumber, index) + err := _EOStakeRegistry.contract.Call(opts, &out, "getTotalStakeUpdateAtIndex", quorumNumber, index) if err != nil { - return *new(IEOStakeRegistryStakeUpdate), err + return *new(IStakeRegistryTypesStakeUpdate), err } - out0 := *abi.ConvertType(out[0], new(IEOStakeRegistryStakeUpdate)).(*IEOStakeRegistryStakeUpdate) + out0 := *abi.ConvertType(out[0], new(IStakeRegistryTypesStakeUpdate)).(*IStakeRegistryTypesStakeUpdate) return out0, err @@ -817,23 +771,23 @@ func (_ContractEOStakeRegistry *ContractEOStakeRegistryCaller) GetTotalStakeUpda // GetTotalStakeUpdateAtIndex is a free data retrieval call binding the contract method 0xb6904b78. // // Solidity: function getTotalStakeUpdateAtIndex(uint8 quorumNumber, uint256 index) view returns((uint32,uint32,uint96)) -func (_ContractEOStakeRegistry *ContractEOStakeRegistrySession) GetTotalStakeUpdateAtIndex(quorumNumber uint8, index *big.Int) (IEOStakeRegistryStakeUpdate, error) { - return _ContractEOStakeRegistry.Contract.GetTotalStakeUpdateAtIndex(&_ContractEOStakeRegistry.CallOpts, quorumNumber, index) +func (_EOStakeRegistry *EOStakeRegistrySession) GetTotalStakeUpdateAtIndex(quorumNumber uint8, index *big.Int) (IStakeRegistryTypesStakeUpdate, error) { + return _EOStakeRegistry.Contract.GetTotalStakeUpdateAtIndex(&_EOStakeRegistry.CallOpts, quorumNumber, index) } // GetTotalStakeUpdateAtIndex is a free data retrieval call binding the contract method 0xb6904b78. // // Solidity: function getTotalStakeUpdateAtIndex(uint8 quorumNumber, uint256 index) view returns((uint32,uint32,uint96)) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryCallerSession) GetTotalStakeUpdateAtIndex(quorumNumber uint8, index *big.Int) (IEOStakeRegistryStakeUpdate, error) { - return _ContractEOStakeRegistry.Contract.GetTotalStakeUpdateAtIndex(&_ContractEOStakeRegistry.CallOpts, quorumNumber, index) +func (_EOStakeRegistry *EOStakeRegistryCallerSession) GetTotalStakeUpdateAtIndex(quorumNumber uint8, index *big.Int) (IStakeRegistryTypesStakeUpdate, error) { + return _EOStakeRegistry.Contract.GetTotalStakeUpdateAtIndex(&_EOStakeRegistry.CallOpts, quorumNumber, index) } // MinimumStakeForQuorum is a free data retrieval call binding the contract method 0xc46778a5. // // Solidity: function minimumStakeForQuorum(uint8 ) view returns(uint96) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryCaller) MinimumStakeForQuorum(opts *bind.CallOpts, arg0 uint8) (*big.Int, error) { +func (_EOStakeRegistry *EOStakeRegistryCaller) MinimumStakeForQuorum(opts *bind.CallOpts, arg0 uint8) (*big.Int, error) { var out []interface{} - err := _ContractEOStakeRegistry.contract.Call(opts, &out, "minimumStakeForQuorum", arg0) + err := _EOStakeRegistry.contract.Call(opts, &out, "minimumStakeForQuorum", arg0) if err != nil { return *new(*big.Int), err @@ -848,23 +802,23 @@ func (_ContractEOStakeRegistry *ContractEOStakeRegistryCaller) MinimumStakeForQu // MinimumStakeForQuorum is a free data retrieval call binding the contract method 0xc46778a5. // // Solidity: function minimumStakeForQuorum(uint8 ) view returns(uint96) -func (_ContractEOStakeRegistry *ContractEOStakeRegistrySession) MinimumStakeForQuorum(arg0 uint8) (*big.Int, error) { - return _ContractEOStakeRegistry.Contract.MinimumStakeForQuorum(&_ContractEOStakeRegistry.CallOpts, arg0) +func (_EOStakeRegistry *EOStakeRegistrySession) MinimumStakeForQuorum(arg0 uint8) (*big.Int, error) { + return _EOStakeRegistry.Contract.MinimumStakeForQuorum(&_EOStakeRegistry.CallOpts, arg0) } // MinimumStakeForQuorum is a free data retrieval call binding the contract method 0xc46778a5. // // Solidity: function minimumStakeForQuorum(uint8 ) view returns(uint96) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryCallerSession) MinimumStakeForQuorum(arg0 uint8) (*big.Int, error) { - return _ContractEOStakeRegistry.Contract.MinimumStakeForQuorum(&_ContractEOStakeRegistry.CallOpts, arg0) +func (_EOStakeRegistry *EOStakeRegistryCallerSession) MinimumStakeForQuorum(arg0 uint8) (*big.Int, error) { + return _EOStakeRegistry.Contract.MinimumStakeForQuorum(&_EOStakeRegistry.CallOpts, arg0) } // RegistryCoordinator is a free data retrieval call binding the contract method 0x6d14a987. // // Solidity: function registryCoordinator() view returns(address) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryCaller) RegistryCoordinator(opts *bind.CallOpts) (common.Address, error) { +func (_EOStakeRegistry *EOStakeRegistryCaller) RegistryCoordinator(opts *bind.CallOpts) (common.Address, error) { var out []interface{} - err := _ContractEOStakeRegistry.contract.Call(opts, &out, "registryCoordinator") + err := _EOStakeRegistry.contract.Call(opts, &out, "registryCoordinator") if err != nil { return *new(common.Address), err @@ -879,23 +833,85 @@ func (_ContractEOStakeRegistry *ContractEOStakeRegistryCaller) RegistryCoordinat // RegistryCoordinator is a free data retrieval call binding the contract method 0x6d14a987. // // Solidity: function registryCoordinator() view returns(address) -func (_ContractEOStakeRegistry *ContractEOStakeRegistrySession) RegistryCoordinator() (common.Address, error) { - return _ContractEOStakeRegistry.Contract.RegistryCoordinator(&_ContractEOStakeRegistry.CallOpts) +func (_EOStakeRegistry *EOStakeRegistrySession) RegistryCoordinator() (common.Address, error) { + return _EOStakeRegistry.Contract.RegistryCoordinator(&_EOStakeRegistry.CallOpts) } // RegistryCoordinator is a free data retrieval call binding the contract method 0x6d14a987. // // Solidity: function registryCoordinator() view returns(address) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryCallerSession) RegistryCoordinator() (common.Address, error) { - return _ContractEOStakeRegistry.Contract.RegistryCoordinator(&_ContractEOStakeRegistry.CallOpts) +func (_EOStakeRegistry *EOStakeRegistryCallerSession) RegistryCoordinator() (common.Address, error) { + return _EOStakeRegistry.Contract.RegistryCoordinator(&_EOStakeRegistry.CallOpts) +} + +// SlashableStakeLookAheadPerQuorum is a free data retrieval call binding the contract method 0x9ab4d6ff. +// +// Solidity: function slashableStakeLookAheadPerQuorum(uint8 quorumNumber) view returns(uint32) +func (_EOStakeRegistry *EOStakeRegistryCaller) SlashableStakeLookAheadPerQuorum(opts *bind.CallOpts, quorumNumber uint8) (uint32, error) { + var out []interface{} + err := _EOStakeRegistry.contract.Call(opts, &out, "slashableStakeLookAheadPerQuorum", quorumNumber) + + if err != nil { + return *new(uint32), err + } + + out0 := *abi.ConvertType(out[0], new(uint32)).(*uint32) + + return out0, err + +} + +// SlashableStakeLookAheadPerQuorum is a free data retrieval call binding the contract method 0x9ab4d6ff. +// +// Solidity: function slashableStakeLookAheadPerQuorum(uint8 quorumNumber) view returns(uint32) +func (_EOStakeRegistry *EOStakeRegistrySession) SlashableStakeLookAheadPerQuorum(quorumNumber uint8) (uint32, error) { + return _EOStakeRegistry.Contract.SlashableStakeLookAheadPerQuorum(&_EOStakeRegistry.CallOpts, quorumNumber) +} + +// SlashableStakeLookAheadPerQuorum is a free data retrieval call binding the contract method 0x9ab4d6ff. +// +// Solidity: function slashableStakeLookAheadPerQuorum(uint8 quorumNumber) view returns(uint32) +func (_EOStakeRegistry *EOStakeRegistryCallerSession) SlashableStakeLookAheadPerQuorum(quorumNumber uint8) (uint32, error) { + return _EOStakeRegistry.Contract.SlashableStakeLookAheadPerQuorum(&_EOStakeRegistry.CallOpts, quorumNumber) +} + +// StakeTypePerQuorum is a free data retrieval call binding the contract method 0x697fbd93. +// +// Solidity: function stakeTypePerQuorum(uint8 quorumNumber) view returns(uint8) +func (_EOStakeRegistry *EOStakeRegistryCaller) StakeTypePerQuorum(opts *bind.CallOpts, quorumNumber uint8) (uint8, error) { + var out []interface{} + err := _EOStakeRegistry.contract.Call(opts, &out, "stakeTypePerQuorum", quorumNumber) + + if err != nil { + return *new(uint8), err + } + + out0 := *abi.ConvertType(out[0], new(uint8)).(*uint8) + + return out0, err + +} + +// StakeTypePerQuorum is a free data retrieval call binding the contract method 0x697fbd93. +// +// Solidity: function stakeTypePerQuorum(uint8 quorumNumber) view returns(uint8) +func (_EOStakeRegistry *EOStakeRegistrySession) StakeTypePerQuorum(quorumNumber uint8) (uint8, error) { + return _EOStakeRegistry.Contract.StakeTypePerQuorum(&_EOStakeRegistry.CallOpts, quorumNumber) +} + +// StakeTypePerQuorum is a free data retrieval call binding the contract method 0x697fbd93. +// +// Solidity: function stakeTypePerQuorum(uint8 quorumNumber) view returns(uint8) +func (_EOStakeRegistry *EOStakeRegistryCallerSession) StakeTypePerQuorum(quorumNumber uint8) (uint8, error) { + return _EOStakeRegistry.Contract.StakeTypePerQuorum(&_EOStakeRegistry.CallOpts, quorumNumber) } // StrategiesPerQuorum is a free data retrieval call binding the contract method 0x9f3ccf65. // -// Solidity: function strategiesPerQuorum(uint8 , uint256 ) view returns(address) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryCaller) StrategiesPerQuorum(opts *bind.CallOpts, arg0 uint8, arg1 *big.Int) (common.Address, error) { +// Solidity: function strategiesPerQuorum(uint8 quorumNumber, uint256 ) view returns(address) +func (_EOStakeRegistry *EOStakeRegistryCaller) StrategiesPerQuorum(opts *bind.CallOpts, quorumNumber uint8, arg1 *big.Int) (common.Address, error) { var out []interface{} - err := _ContractEOStakeRegistry.contract.Call(opts, &out, "strategiesPerQuorum", arg0, arg1) + err := _EOStakeRegistry.contract.Call(opts, &out, "strategiesPerQuorum", quorumNumber, arg1) if err != nil { return *new(common.Address), err @@ -909,27 +925,27 @@ func (_ContractEOStakeRegistry *ContractEOStakeRegistryCaller) StrategiesPerQuor // StrategiesPerQuorum is a free data retrieval call binding the contract method 0x9f3ccf65. // -// Solidity: function strategiesPerQuorum(uint8 , uint256 ) view returns(address) -func (_ContractEOStakeRegistry *ContractEOStakeRegistrySession) StrategiesPerQuorum(arg0 uint8, arg1 *big.Int) (common.Address, error) { - return _ContractEOStakeRegistry.Contract.StrategiesPerQuorum(&_ContractEOStakeRegistry.CallOpts, arg0, arg1) +// Solidity: function strategiesPerQuorum(uint8 quorumNumber, uint256 ) view returns(address) +func (_EOStakeRegistry *EOStakeRegistrySession) StrategiesPerQuorum(quorumNumber uint8, arg1 *big.Int) (common.Address, error) { + return _EOStakeRegistry.Contract.StrategiesPerQuorum(&_EOStakeRegistry.CallOpts, quorumNumber, arg1) } // StrategiesPerQuorum is a free data retrieval call binding the contract method 0x9f3ccf65. // -// Solidity: function strategiesPerQuorum(uint8 , uint256 ) view returns(address) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryCallerSession) StrategiesPerQuorum(arg0 uint8, arg1 *big.Int) (common.Address, error) { - return _ContractEOStakeRegistry.Contract.StrategiesPerQuorum(&_ContractEOStakeRegistry.CallOpts, arg0, arg1) +// Solidity: function strategiesPerQuorum(uint8 quorumNumber, uint256 ) view returns(address) +func (_EOStakeRegistry *EOStakeRegistryCallerSession) StrategiesPerQuorum(quorumNumber uint8, arg1 *big.Int) (common.Address, error) { + return _EOStakeRegistry.Contract.StrategiesPerQuorum(&_EOStakeRegistry.CallOpts, quorumNumber, arg1) } // StrategyParams is a free data retrieval call binding the contract method 0x08732461. // -// Solidity: function strategyParams(uint8 , uint256 ) view returns(address strategy, uint96 multiplier) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryCaller) StrategyParams(opts *bind.CallOpts, arg0 uint8, arg1 *big.Int) (struct { +// Solidity: function strategyParams(uint8 quorumNumber, uint256 ) view returns(address strategy, uint96 multiplier) +func (_EOStakeRegistry *EOStakeRegistryCaller) StrategyParams(opts *bind.CallOpts, quorumNumber uint8, arg1 *big.Int) (struct { Strategy common.Address Multiplier *big.Int }, error) { var out []interface{} - err := _ContractEOStakeRegistry.contract.Call(opts, &out, "strategyParams", arg0, arg1) + err := _EOStakeRegistry.contract.Call(opts, &out, "strategyParams", quorumNumber, arg1) outstruct := new(struct { Strategy common.Address @@ -948,36 +964,36 @@ func (_ContractEOStakeRegistry *ContractEOStakeRegistryCaller) StrategyParams(op // StrategyParams is a free data retrieval call binding the contract method 0x08732461. // -// Solidity: function strategyParams(uint8 , uint256 ) view returns(address strategy, uint96 multiplier) -func (_ContractEOStakeRegistry *ContractEOStakeRegistrySession) StrategyParams(arg0 uint8, arg1 *big.Int) (struct { +// Solidity: function strategyParams(uint8 quorumNumber, uint256 ) view returns(address strategy, uint96 multiplier) +func (_EOStakeRegistry *EOStakeRegistrySession) StrategyParams(quorumNumber uint8, arg1 *big.Int) (struct { Strategy common.Address Multiplier *big.Int }, error) { - return _ContractEOStakeRegistry.Contract.StrategyParams(&_ContractEOStakeRegistry.CallOpts, arg0, arg1) + return _EOStakeRegistry.Contract.StrategyParams(&_EOStakeRegistry.CallOpts, quorumNumber, arg1) } // StrategyParams is a free data retrieval call binding the contract method 0x08732461. // -// Solidity: function strategyParams(uint8 , uint256 ) view returns(address strategy, uint96 multiplier) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryCallerSession) StrategyParams(arg0 uint8, arg1 *big.Int) (struct { +// Solidity: function strategyParams(uint8 quorumNumber, uint256 ) view returns(address strategy, uint96 multiplier) +func (_EOStakeRegistry *EOStakeRegistryCallerSession) StrategyParams(quorumNumber uint8, arg1 *big.Int) (struct { Strategy common.Address Multiplier *big.Int }, error) { - return _ContractEOStakeRegistry.Contract.StrategyParams(&_ContractEOStakeRegistry.CallOpts, arg0, arg1) + return _EOStakeRegistry.Contract.StrategyParams(&_EOStakeRegistry.CallOpts, quorumNumber, arg1) } // StrategyParamsByIndex is a free data retrieval call binding the contract method 0xadc804da. // // Solidity: function strategyParamsByIndex(uint8 quorumNumber, uint256 index) view returns((address,uint96)) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryCaller) StrategyParamsByIndex(opts *bind.CallOpts, quorumNumber uint8, index *big.Int) (IEOStakeRegistryStrategyParams, error) { +func (_EOStakeRegistry *EOStakeRegistryCaller) StrategyParamsByIndex(opts *bind.CallOpts, quorumNumber uint8, index *big.Int) (IStakeRegistryTypesStrategyParams, error) { var out []interface{} - err := _ContractEOStakeRegistry.contract.Call(opts, &out, "strategyParamsByIndex", quorumNumber, index) + err := _EOStakeRegistry.contract.Call(opts, &out, "strategyParamsByIndex", quorumNumber, index) if err != nil { - return *new(IEOStakeRegistryStrategyParams), err + return *new(IStakeRegistryTypesStrategyParams), err } - out0 := *abi.ConvertType(out[0], new(IEOStakeRegistryStrategyParams)).(*IEOStakeRegistryStrategyParams) + out0 := *abi.ConvertType(out[0], new(IStakeRegistryTypesStrategyParams)).(*IStakeRegistryTypesStrategyParams) return out0, err @@ -986,23 +1002,23 @@ func (_ContractEOStakeRegistry *ContractEOStakeRegistryCaller) StrategyParamsByI // StrategyParamsByIndex is a free data retrieval call binding the contract method 0xadc804da. // // Solidity: function strategyParamsByIndex(uint8 quorumNumber, uint256 index) view returns((address,uint96)) -func (_ContractEOStakeRegistry *ContractEOStakeRegistrySession) StrategyParamsByIndex(quorumNumber uint8, index *big.Int) (IEOStakeRegistryStrategyParams, error) { - return _ContractEOStakeRegistry.Contract.StrategyParamsByIndex(&_ContractEOStakeRegistry.CallOpts, quorumNumber, index) +func (_EOStakeRegistry *EOStakeRegistrySession) StrategyParamsByIndex(quorumNumber uint8, index *big.Int) (IStakeRegistryTypesStrategyParams, error) { + return _EOStakeRegistry.Contract.StrategyParamsByIndex(&_EOStakeRegistry.CallOpts, quorumNumber, index) } // StrategyParamsByIndex is a free data retrieval call binding the contract method 0xadc804da. // // Solidity: function strategyParamsByIndex(uint8 quorumNumber, uint256 index) view returns((address,uint96)) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryCallerSession) StrategyParamsByIndex(quorumNumber uint8, index *big.Int) (IEOStakeRegistryStrategyParams, error) { - return _ContractEOStakeRegistry.Contract.StrategyParamsByIndex(&_ContractEOStakeRegistry.CallOpts, quorumNumber, index) +func (_EOStakeRegistry *EOStakeRegistryCallerSession) StrategyParamsByIndex(quorumNumber uint8, index *big.Int) (IStakeRegistryTypesStrategyParams, error) { + return _EOStakeRegistry.Contract.StrategyParamsByIndex(&_EOStakeRegistry.CallOpts, quorumNumber, index) } // StrategyParamsLength is a free data retrieval call binding the contract method 0x3ca5a5f5. // // Solidity: function strategyParamsLength(uint8 quorumNumber) view returns(uint256) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryCaller) StrategyParamsLength(opts *bind.CallOpts, quorumNumber uint8) (*big.Int, error) { +func (_EOStakeRegistry *EOStakeRegistryCaller) StrategyParamsLength(opts *bind.CallOpts, quorumNumber uint8) (*big.Int, error) { var out []interface{} - err := _ContractEOStakeRegistry.contract.Call(opts, &out, "strategyParamsLength", quorumNumber) + err := _EOStakeRegistry.contract.Call(opts, &out, "strategyParamsLength", quorumNumber) if err != nil { return *new(*big.Int), err @@ -1017,23 +1033,23 @@ func (_ContractEOStakeRegistry *ContractEOStakeRegistryCaller) StrategyParamsLen // StrategyParamsLength is a free data retrieval call binding the contract method 0x3ca5a5f5. // // Solidity: function strategyParamsLength(uint8 quorumNumber) view returns(uint256) -func (_ContractEOStakeRegistry *ContractEOStakeRegistrySession) StrategyParamsLength(quorumNumber uint8) (*big.Int, error) { - return _ContractEOStakeRegistry.Contract.StrategyParamsLength(&_ContractEOStakeRegistry.CallOpts, quorumNumber) +func (_EOStakeRegistry *EOStakeRegistrySession) StrategyParamsLength(quorumNumber uint8) (*big.Int, error) { + return _EOStakeRegistry.Contract.StrategyParamsLength(&_EOStakeRegistry.CallOpts, quorumNumber) } // StrategyParamsLength is a free data retrieval call binding the contract method 0x3ca5a5f5. // // Solidity: function strategyParamsLength(uint8 quorumNumber) view returns(uint256) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryCallerSession) StrategyParamsLength(quorumNumber uint8) (*big.Int, error) { - return _ContractEOStakeRegistry.Contract.StrategyParamsLength(&_ContractEOStakeRegistry.CallOpts, quorumNumber) +func (_EOStakeRegistry *EOStakeRegistryCallerSession) StrategyParamsLength(quorumNumber uint8) (*big.Int, error) { + return _EOStakeRegistry.Contract.StrategyParamsLength(&_EOStakeRegistry.CallOpts, quorumNumber) } // WeightOfOperatorForQuorum is a free data retrieval call binding the contract method 0x1f9b74e0. // // Solidity: function weightOfOperatorForQuorum(uint8 quorumNumber, address operator) view returns(uint96) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryCaller) WeightOfOperatorForQuorum(opts *bind.CallOpts, quorumNumber uint8, operator common.Address) (*big.Int, error) { +func (_EOStakeRegistry *EOStakeRegistryCaller) WeightOfOperatorForQuorum(opts *bind.CallOpts, quorumNumber uint8, operator common.Address) (*big.Int, error) { var out []interface{} - err := _ContractEOStakeRegistry.contract.Call(opts, &out, "weightOfOperatorForQuorum", quorumNumber, operator) + err := _EOStakeRegistry.contract.Call(opts, &out, "weightOfOperatorForQuorum", quorumNumber, operator) if err != nil { return *new(*big.Int), err @@ -1048,188 +1064,272 @@ func (_ContractEOStakeRegistry *ContractEOStakeRegistryCaller) WeightOfOperatorF // WeightOfOperatorForQuorum is a free data retrieval call binding the contract method 0x1f9b74e0. // // Solidity: function weightOfOperatorForQuorum(uint8 quorumNumber, address operator) view returns(uint96) -func (_ContractEOStakeRegistry *ContractEOStakeRegistrySession) WeightOfOperatorForQuorum(quorumNumber uint8, operator common.Address) (*big.Int, error) { - return _ContractEOStakeRegistry.Contract.WeightOfOperatorForQuorum(&_ContractEOStakeRegistry.CallOpts, quorumNumber, operator) +func (_EOStakeRegistry *EOStakeRegistrySession) WeightOfOperatorForQuorum(quorumNumber uint8, operator common.Address) (*big.Int, error) { + return _EOStakeRegistry.Contract.WeightOfOperatorForQuorum(&_EOStakeRegistry.CallOpts, quorumNumber, operator) } // WeightOfOperatorForQuorum is a free data retrieval call binding the contract method 0x1f9b74e0. // // Solidity: function weightOfOperatorForQuorum(uint8 quorumNumber, address operator) view returns(uint96) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryCallerSession) WeightOfOperatorForQuorum(quorumNumber uint8, operator common.Address) (*big.Int, error) { - return _ContractEOStakeRegistry.Contract.WeightOfOperatorForQuorum(&_ContractEOStakeRegistry.CallOpts, quorumNumber, operator) +func (_EOStakeRegistry *EOStakeRegistryCallerSession) WeightOfOperatorForQuorum(quorumNumber uint8, operator common.Address) (*big.Int, error) { + return _EOStakeRegistry.Contract.WeightOfOperatorForQuorum(&_EOStakeRegistry.CallOpts, quorumNumber, operator) } // AddStrategies is a paid mutator transaction binding the contract method 0xc601527d. // // Solidity: function addStrategies(uint8 quorumNumber, (address,uint96)[] _strategyParams) returns() -func (_ContractEOStakeRegistry *ContractEOStakeRegistryTransactor) AddStrategies(opts *bind.TransactOpts, quorumNumber uint8, _strategyParams []IEOStakeRegistryStrategyParams) (*types.Transaction, error) { - return _ContractEOStakeRegistry.contract.Transact(opts, "addStrategies", quorumNumber, _strategyParams) +func (_EOStakeRegistry *EOStakeRegistryTransactor) AddStrategies(opts *bind.TransactOpts, quorumNumber uint8, _strategyParams []IStakeRegistryTypesStrategyParams) (*types.Transaction, error) { + return _EOStakeRegistry.contract.Transact(opts, "addStrategies", quorumNumber, _strategyParams) } // AddStrategies is a paid mutator transaction binding the contract method 0xc601527d. // // Solidity: function addStrategies(uint8 quorumNumber, (address,uint96)[] _strategyParams) returns() -func (_ContractEOStakeRegistry *ContractEOStakeRegistrySession) AddStrategies(quorumNumber uint8, _strategyParams []IEOStakeRegistryStrategyParams) (*types.Transaction, error) { - return _ContractEOStakeRegistry.Contract.AddStrategies(&_ContractEOStakeRegistry.TransactOpts, quorumNumber, _strategyParams) +func (_EOStakeRegistry *EOStakeRegistrySession) AddStrategies(quorumNumber uint8, _strategyParams []IStakeRegistryTypesStrategyParams) (*types.Transaction, error) { + return _EOStakeRegistry.Contract.AddStrategies(&_EOStakeRegistry.TransactOpts, quorumNumber, _strategyParams) } // AddStrategies is a paid mutator transaction binding the contract method 0xc601527d. // // Solidity: function addStrategies(uint8 quorumNumber, (address,uint96)[] _strategyParams) returns() -func (_ContractEOStakeRegistry *ContractEOStakeRegistryTransactorSession) AddStrategies(quorumNumber uint8, _strategyParams []IEOStakeRegistryStrategyParams) (*types.Transaction, error) { - return _ContractEOStakeRegistry.Contract.AddStrategies(&_ContractEOStakeRegistry.TransactOpts, quorumNumber, _strategyParams) +func (_EOStakeRegistry *EOStakeRegistryTransactorSession) AddStrategies(quorumNumber uint8, _strategyParams []IStakeRegistryTypesStrategyParams) (*types.Transaction, error) { + return _EOStakeRegistry.Contract.AddStrategies(&_EOStakeRegistry.TransactOpts, quorumNumber, _strategyParams) } // DeregisterOperator is a paid mutator transaction binding the contract method 0xbd29b8cd. // // Solidity: function deregisterOperator(bytes32 operatorId, bytes quorumNumbers) returns() -func (_ContractEOStakeRegistry *ContractEOStakeRegistryTransactor) DeregisterOperator(opts *bind.TransactOpts, operatorId [32]byte, quorumNumbers []byte) (*types.Transaction, error) { - return _ContractEOStakeRegistry.contract.Transact(opts, "deregisterOperator", operatorId, quorumNumbers) +func (_EOStakeRegistry *EOStakeRegistryTransactor) DeregisterOperator(opts *bind.TransactOpts, operatorId [32]byte, quorumNumbers []byte) (*types.Transaction, error) { + return _EOStakeRegistry.contract.Transact(opts, "deregisterOperator", operatorId, quorumNumbers) } // DeregisterOperator is a paid mutator transaction binding the contract method 0xbd29b8cd. // // Solidity: function deregisterOperator(bytes32 operatorId, bytes quorumNumbers) returns() -func (_ContractEOStakeRegistry *ContractEOStakeRegistrySession) DeregisterOperator(operatorId [32]byte, quorumNumbers []byte) (*types.Transaction, error) { - return _ContractEOStakeRegistry.Contract.DeregisterOperator(&_ContractEOStakeRegistry.TransactOpts, operatorId, quorumNumbers) +func (_EOStakeRegistry *EOStakeRegistrySession) DeregisterOperator(operatorId [32]byte, quorumNumbers []byte) (*types.Transaction, error) { + return _EOStakeRegistry.Contract.DeregisterOperator(&_EOStakeRegistry.TransactOpts, operatorId, quorumNumbers) } // DeregisterOperator is a paid mutator transaction binding the contract method 0xbd29b8cd. // // Solidity: function deregisterOperator(bytes32 operatorId, bytes quorumNumbers) returns() -func (_ContractEOStakeRegistry *ContractEOStakeRegistryTransactorSession) DeregisterOperator(operatorId [32]byte, quorumNumbers []byte) (*types.Transaction, error) { - return _ContractEOStakeRegistry.Contract.DeregisterOperator(&_ContractEOStakeRegistry.TransactOpts, operatorId, quorumNumbers) +func (_EOStakeRegistry *EOStakeRegistryTransactorSession) DeregisterOperator(operatorId [32]byte, quorumNumbers []byte) (*types.Transaction, error) { + return _EOStakeRegistry.Contract.DeregisterOperator(&_EOStakeRegistry.TransactOpts, operatorId, quorumNumbers) +} + +// InitializeDelegatedStakeQuorum is a paid mutator transaction binding the contract method 0x75d4173a. +// +// Solidity: function initializeDelegatedStakeQuorum(uint8 quorumNumber, uint96 minimumStake, (address,uint96)[] _strategyParams) returns() +func (_EOStakeRegistry *EOStakeRegistryTransactor) InitializeDelegatedStakeQuorum(opts *bind.TransactOpts, quorumNumber uint8, minimumStake *big.Int, _strategyParams []IStakeRegistryTypesStrategyParams) (*types.Transaction, error) { + return _EOStakeRegistry.contract.Transact(opts, "initializeDelegatedStakeQuorum", quorumNumber, minimumStake, _strategyParams) +} + +// InitializeDelegatedStakeQuorum is a paid mutator transaction binding the contract method 0x75d4173a. +// +// Solidity: function initializeDelegatedStakeQuorum(uint8 quorumNumber, uint96 minimumStake, (address,uint96)[] _strategyParams) returns() +func (_EOStakeRegistry *EOStakeRegistrySession) InitializeDelegatedStakeQuorum(quorumNumber uint8, minimumStake *big.Int, _strategyParams []IStakeRegistryTypesStrategyParams) (*types.Transaction, error) { + return _EOStakeRegistry.Contract.InitializeDelegatedStakeQuorum(&_EOStakeRegistry.TransactOpts, quorumNumber, minimumStake, _strategyParams) } -// InitializeQuorum is a paid mutator transaction binding the contract method 0xff694a77. +// InitializeDelegatedStakeQuorum is a paid mutator transaction binding the contract method 0x75d4173a. // -// Solidity: function initializeQuorum(uint8 quorumNumber, uint96 minimumStake, (address,uint96)[] _strategyParams) returns() -func (_ContractEOStakeRegistry *ContractEOStakeRegistryTransactor) InitializeQuorum(opts *bind.TransactOpts, quorumNumber uint8, minimumStake *big.Int, _strategyParams []IEOStakeRegistryStrategyParams) (*types.Transaction, error) { - return _ContractEOStakeRegistry.contract.Transact(opts, "initializeQuorum", quorumNumber, minimumStake, _strategyParams) +// Solidity: function initializeDelegatedStakeQuorum(uint8 quorumNumber, uint96 minimumStake, (address,uint96)[] _strategyParams) returns() +func (_EOStakeRegistry *EOStakeRegistryTransactorSession) InitializeDelegatedStakeQuorum(quorumNumber uint8, minimumStake *big.Int, _strategyParams []IStakeRegistryTypesStrategyParams) (*types.Transaction, error) { + return _EOStakeRegistry.Contract.InitializeDelegatedStakeQuorum(&_EOStakeRegistry.TransactOpts, quorumNumber, minimumStake, _strategyParams) } -// InitializeQuorum is a paid mutator transaction binding the contract method 0xff694a77. +// InitializeSlashableStakeQuorum is a paid mutator transaction binding the contract method 0xcc5a7c20. // -// Solidity: function initializeQuorum(uint8 quorumNumber, uint96 minimumStake, (address,uint96)[] _strategyParams) returns() -func (_ContractEOStakeRegistry *ContractEOStakeRegistrySession) InitializeQuorum(quorumNumber uint8, minimumStake *big.Int, _strategyParams []IEOStakeRegistryStrategyParams) (*types.Transaction, error) { - return _ContractEOStakeRegistry.Contract.InitializeQuorum(&_ContractEOStakeRegistry.TransactOpts, quorumNumber, minimumStake, _strategyParams) +// Solidity: function initializeSlashableStakeQuorum(uint8 quorumNumber, uint96 minimumStake, uint32 lookAheadPeriod, (address,uint96)[] _strategyParams) returns() +func (_EOStakeRegistry *EOStakeRegistryTransactor) InitializeSlashableStakeQuorum(opts *bind.TransactOpts, quorumNumber uint8, minimumStake *big.Int, lookAheadPeriod uint32, _strategyParams []IStakeRegistryTypesStrategyParams) (*types.Transaction, error) { + return _EOStakeRegistry.contract.Transact(opts, "initializeSlashableStakeQuorum", quorumNumber, minimumStake, lookAheadPeriod, _strategyParams) } -// InitializeQuorum is a paid mutator transaction binding the contract method 0xff694a77. +// InitializeSlashableStakeQuorum is a paid mutator transaction binding the contract method 0xcc5a7c20. // -// Solidity: function initializeQuorum(uint8 quorumNumber, uint96 minimumStake, (address,uint96)[] _strategyParams) returns() -func (_ContractEOStakeRegistry *ContractEOStakeRegistryTransactorSession) InitializeQuorum(quorumNumber uint8, minimumStake *big.Int, _strategyParams []IEOStakeRegistryStrategyParams) (*types.Transaction, error) { - return _ContractEOStakeRegistry.Contract.InitializeQuorum(&_ContractEOStakeRegistry.TransactOpts, quorumNumber, minimumStake, _strategyParams) +// Solidity: function initializeSlashableStakeQuorum(uint8 quorumNumber, uint96 minimumStake, uint32 lookAheadPeriod, (address,uint96)[] _strategyParams) returns() +func (_EOStakeRegistry *EOStakeRegistrySession) InitializeSlashableStakeQuorum(quorumNumber uint8, minimumStake *big.Int, lookAheadPeriod uint32, _strategyParams []IStakeRegistryTypesStrategyParams) (*types.Transaction, error) { + return _EOStakeRegistry.Contract.InitializeSlashableStakeQuorum(&_EOStakeRegistry.TransactOpts, quorumNumber, minimumStake, lookAheadPeriod, _strategyParams) +} + +// InitializeSlashableStakeQuorum is a paid mutator transaction binding the contract method 0xcc5a7c20. +// +// Solidity: function initializeSlashableStakeQuorum(uint8 quorumNumber, uint96 minimumStake, uint32 lookAheadPeriod, (address,uint96)[] _strategyParams) returns() +func (_EOStakeRegistry *EOStakeRegistryTransactorSession) InitializeSlashableStakeQuorum(quorumNumber uint8, minimumStake *big.Int, lookAheadPeriod uint32, _strategyParams []IStakeRegistryTypesStrategyParams) (*types.Transaction, error) { + return _EOStakeRegistry.Contract.InitializeSlashableStakeQuorum(&_EOStakeRegistry.TransactOpts, quorumNumber, minimumStake, lookAheadPeriod, _strategyParams) } // ModifyStrategyParams is a paid mutator transaction binding the contract method 0x20b66298. // // Solidity: function modifyStrategyParams(uint8 quorumNumber, uint256[] strategyIndices, uint96[] newMultipliers) returns() -func (_ContractEOStakeRegistry *ContractEOStakeRegistryTransactor) ModifyStrategyParams(opts *bind.TransactOpts, quorumNumber uint8, strategyIndices []*big.Int, newMultipliers []*big.Int) (*types.Transaction, error) { - return _ContractEOStakeRegistry.contract.Transact(opts, "modifyStrategyParams", quorumNumber, strategyIndices, newMultipliers) +func (_EOStakeRegistry *EOStakeRegistryTransactor) ModifyStrategyParams(opts *bind.TransactOpts, quorumNumber uint8, strategyIndices []*big.Int, newMultipliers []*big.Int) (*types.Transaction, error) { + return _EOStakeRegistry.contract.Transact(opts, "modifyStrategyParams", quorumNumber, strategyIndices, newMultipliers) } // ModifyStrategyParams is a paid mutator transaction binding the contract method 0x20b66298. // // Solidity: function modifyStrategyParams(uint8 quorumNumber, uint256[] strategyIndices, uint96[] newMultipliers) returns() -func (_ContractEOStakeRegistry *ContractEOStakeRegistrySession) ModifyStrategyParams(quorumNumber uint8, strategyIndices []*big.Int, newMultipliers []*big.Int) (*types.Transaction, error) { - return _ContractEOStakeRegistry.Contract.ModifyStrategyParams(&_ContractEOStakeRegistry.TransactOpts, quorumNumber, strategyIndices, newMultipliers) +func (_EOStakeRegistry *EOStakeRegistrySession) ModifyStrategyParams(quorumNumber uint8, strategyIndices []*big.Int, newMultipliers []*big.Int) (*types.Transaction, error) { + return _EOStakeRegistry.Contract.ModifyStrategyParams(&_EOStakeRegistry.TransactOpts, quorumNumber, strategyIndices, newMultipliers) } // ModifyStrategyParams is a paid mutator transaction binding the contract method 0x20b66298. // // Solidity: function modifyStrategyParams(uint8 quorumNumber, uint256[] strategyIndices, uint96[] newMultipliers) returns() -func (_ContractEOStakeRegistry *ContractEOStakeRegistryTransactorSession) ModifyStrategyParams(quorumNumber uint8, strategyIndices []*big.Int, newMultipliers []*big.Int) (*types.Transaction, error) { - return _ContractEOStakeRegistry.Contract.ModifyStrategyParams(&_ContractEOStakeRegistry.TransactOpts, quorumNumber, strategyIndices, newMultipliers) +func (_EOStakeRegistry *EOStakeRegistryTransactorSession) ModifyStrategyParams(quorumNumber uint8, strategyIndices []*big.Int, newMultipliers []*big.Int) (*types.Transaction, error) { + return _EOStakeRegistry.Contract.ModifyStrategyParams(&_EOStakeRegistry.TransactOpts, quorumNumber, strategyIndices, newMultipliers) } // RegisterOperator is a paid mutator transaction binding the contract method 0x25504777. // // Solidity: function registerOperator(address operator, bytes32 operatorId, bytes quorumNumbers) returns(uint96[], uint96[]) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryTransactor) RegisterOperator(opts *bind.TransactOpts, operator common.Address, operatorId [32]byte, quorumNumbers []byte) (*types.Transaction, error) { - return _ContractEOStakeRegistry.contract.Transact(opts, "registerOperator", operator, operatorId, quorumNumbers) +func (_EOStakeRegistry *EOStakeRegistryTransactor) RegisterOperator(opts *bind.TransactOpts, operator common.Address, operatorId [32]byte, quorumNumbers []byte) (*types.Transaction, error) { + return _EOStakeRegistry.contract.Transact(opts, "registerOperator", operator, operatorId, quorumNumbers) } // RegisterOperator is a paid mutator transaction binding the contract method 0x25504777. // // Solidity: function registerOperator(address operator, bytes32 operatorId, bytes quorumNumbers) returns(uint96[], uint96[]) -func (_ContractEOStakeRegistry *ContractEOStakeRegistrySession) RegisterOperator(operator common.Address, operatorId [32]byte, quorumNumbers []byte) (*types.Transaction, error) { - return _ContractEOStakeRegistry.Contract.RegisterOperator(&_ContractEOStakeRegistry.TransactOpts, operator, operatorId, quorumNumbers) +func (_EOStakeRegistry *EOStakeRegistrySession) RegisterOperator(operator common.Address, operatorId [32]byte, quorumNumbers []byte) (*types.Transaction, error) { + return _EOStakeRegistry.Contract.RegisterOperator(&_EOStakeRegistry.TransactOpts, operator, operatorId, quorumNumbers) } // RegisterOperator is a paid mutator transaction binding the contract method 0x25504777. // // Solidity: function registerOperator(address operator, bytes32 operatorId, bytes quorumNumbers) returns(uint96[], uint96[]) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryTransactorSession) RegisterOperator(operator common.Address, operatorId [32]byte, quorumNumbers []byte) (*types.Transaction, error) { - return _ContractEOStakeRegistry.Contract.RegisterOperator(&_ContractEOStakeRegistry.TransactOpts, operator, operatorId, quorumNumbers) +func (_EOStakeRegistry *EOStakeRegistryTransactorSession) RegisterOperator(operator common.Address, operatorId [32]byte, quorumNumbers []byte) (*types.Transaction, error) { + return _EOStakeRegistry.Contract.RegisterOperator(&_EOStakeRegistry.TransactOpts, operator, operatorId, quorumNumbers) } // RemoveStrategies is a paid mutator transaction binding the contract method 0x5f1f2d77. // // Solidity: function removeStrategies(uint8 quorumNumber, uint256[] indicesToRemove) returns() -func (_ContractEOStakeRegistry *ContractEOStakeRegistryTransactor) RemoveStrategies(opts *bind.TransactOpts, quorumNumber uint8, indicesToRemove []*big.Int) (*types.Transaction, error) { - return _ContractEOStakeRegistry.contract.Transact(opts, "removeStrategies", quorumNumber, indicesToRemove) +func (_EOStakeRegistry *EOStakeRegistryTransactor) RemoveStrategies(opts *bind.TransactOpts, quorumNumber uint8, indicesToRemove []*big.Int) (*types.Transaction, error) { + return _EOStakeRegistry.contract.Transact(opts, "removeStrategies", quorumNumber, indicesToRemove) } // RemoveStrategies is a paid mutator transaction binding the contract method 0x5f1f2d77. // // Solidity: function removeStrategies(uint8 quorumNumber, uint256[] indicesToRemove) returns() -func (_ContractEOStakeRegistry *ContractEOStakeRegistrySession) RemoveStrategies(quorumNumber uint8, indicesToRemove []*big.Int) (*types.Transaction, error) { - return _ContractEOStakeRegistry.Contract.RemoveStrategies(&_ContractEOStakeRegistry.TransactOpts, quorumNumber, indicesToRemove) +func (_EOStakeRegistry *EOStakeRegistrySession) RemoveStrategies(quorumNumber uint8, indicesToRemove []*big.Int) (*types.Transaction, error) { + return _EOStakeRegistry.Contract.RemoveStrategies(&_EOStakeRegistry.TransactOpts, quorumNumber, indicesToRemove) } // RemoveStrategies is a paid mutator transaction binding the contract method 0x5f1f2d77. // // Solidity: function removeStrategies(uint8 quorumNumber, uint256[] indicesToRemove) returns() -func (_ContractEOStakeRegistry *ContractEOStakeRegistryTransactorSession) RemoveStrategies(quorumNumber uint8, indicesToRemove []*big.Int) (*types.Transaction, error) { - return _ContractEOStakeRegistry.Contract.RemoveStrategies(&_ContractEOStakeRegistry.TransactOpts, quorumNumber, indicesToRemove) +func (_EOStakeRegistry *EOStakeRegistryTransactorSession) RemoveStrategies(quorumNumber uint8, indicesToRemove []*big.Int) (*types.Transaction, error) { + return _EOStakeRegistry.Contract.RemoveStrategies(&_EOStakeRegistry.TransactOpts, quorumNumber, indicesToRemove) +} + +// SetChainManager is a paid mutator transaction binding the contract method 0xd70cf0ed. +// +// Solidity: function setChainManager(address newChainManager) returns() +func (_EOStakeRegistry *EOStakeRegistryTransactor) SetChainManager(opts *bind.TransactOpts, newChainManager common.Address) (*types.Transaction, error) { + return _EOStakeRegistry.contract.Transact(opts, "setChainManager", newChainManager) +} + +// SetChainManager is a paid mutator transaction binding the contract method 0xd70cf0ed. +// +// Solidity: function setChainManager(address newChainManager) returns() +func (_EOStakeRegistry *EOStakeRegistrySession) SetChainManager(newChainManager common.Address) (*types.Transaction, error) { + return _EOStakeRegistry.Contract.SetChainManager(&_EOStakeRegistry.TransactOpts, newChainManager) +} + +// SetChainManager is a paid mutator transaction binding the contract method 0xd70cf0ed. +// +// Solidity: function setChainManager(address newChainManager) returns() +func (_EOStakeRegistry *EOStakeRegistryTransactorSession) SetChainManager(newChainManager common.Address) (*types.Transaction, error) { + return _EOStakeRegistry.Contract.SetChainManager(&_EOStakeRegistry.TransactOpts, newChainManager) } // SetMinimumStakeForQuorum is a paid mutator transaction binding the contract method 0xbc9a40c3. // // Solidity: function setMinimumStakeForQuorum(uint8 quorumNumber, uint96 minimumStake) returns() -func (_ContractEOStakeRegistry *ContractEOStakeRegistryTransactor) SetMinimumStakeForQuorum(opts *bind.TransactOpts, quorumNumber uint8, minimumStake *big.Int) (*types.Transaction, error) { - return _ContractEOStakeRegistry.contract.Transact(opts, "setMinimumStakeForQuorum", quorumNumber, minimumStake) +func (_EOStakeRegistry *EOStakeRegistryTransactor) SetMinimumStakeForQuorum(opts *bind.TransactOpts, quorumNumber uint8, minimumStake *big.Int) (*types.Transaction, error) { + return _EOStakeRegistry.contract.Transact(opts, "setMinimumStakeForQuorum", quorumNumber, minimumStake) } // SetMinimumStakeForQuorum is a paid mutator transaction binding the contract method 0xbc9a40c3. // // Solidity: function setMinimumStakeForQuorum(uint8 quorumNumber, uint96 minimumStake) returns() -func (_ContractEOStakeRegistry *ContractEOStakeRegistrySession) SetMinimumStakeForQuorum(quorumNumber uint8, minimumStake *big.Int) (*types.Transaction, error) { - return _ContractEOStakeRegistry.Contract.SetMinimumStakeForQuorum(&_ContractEOStakeRegistry.TransactOpts, quorumNumber, minimumStake) +func (_EOStakeRegistry *EOStakeRegistrySession) SetMinimumStakeForQuorum(quorumNumber uint8, minimumStake *big.Int) (*types.Transaction, error) { + return _EOStakeRegistry.Contract.SetMinimumStakeForQuorum(&_EOStakeRegistry.TransactOpts, quorumNumber, minimumStake) } // SetMinimumStakeForQuorum is a paid mutator transaction binding the contract method 0xbc9a40c3. // // Solidity: function setMinimumStakeForQuorum(uint8 quorumNumber, uint96 minimumStake) returns() -func (_ContractEOStakeRegistry *ContractEOStakeRegistryTransactorSession) SetMinimumStakeForQuorum(quorumNumber uint8, minimumStake *big.Int) (*types.Transaction, error) { - return _ContractEOStakeRegistry.Contract.SetMinimumStakeForQuorum(&_ContractEOStakeRegistry.TransactOpts, quorumNumber, minimumStake) +func (_EOStakeRegistry *EOStakeRegistryTransactorSession) SetMinimumStakeForQuorum(quorumNumber uint8, minimumStake *big.Int) (*types.Transaction, error) { + return _EOStakeRegistry.Contract.SetMinimumStakeForQuorum(&_EOStakeRegistry.TransactOpts, quorumNumber, minimumStake) +} + +// SetSlashableStakeLookahead is a paid mutator transaction binding the contract method 0xe086adb3. +// +// Solidity: function setSlashableStakeLookahead(uint8 quorumNumber, uint32 _lookAheadBlocks) returns() +func (_EOStakeRegistry *EOStakeRegistryTransactor) SetSlashableStakeLookahead(opts *bind.TransactOpts, quorumNumber uint8, _lookAheadBlocks uint32) (*types.Transaction, error) { + return _EOStakeRegistry.contract.Transact(opts, "setSlashableStakeLookahead", quorumNumber, _lookAheadBlocks) +} + +// SetSlashableStakeLookahead is a paid mutator transaction binding the contract method 0xe086adb3. +// +// Solidity: function setSlashableStakeLookahead(uint8 quorumNumber, uint32 _lookAheadBlocks) returns() +func (_EOStakeRegistry *EOStakeRegistrySession) SetSlashableStakeLookahead(quorumNumber uint8, _lookAheadBlocks uint32) (*types.Transaction, error) { + return _EOStakeRegistry.Contract.SetSlashableStakeLookahead(&_EOStakeRegistry.TransactOpts, quorumNumber, _lookAheadBlocks) } -// UpdateOperatorStake is a paid mutator transaction binding the contract method 0x66acfefe. +// SetSlashableStakeLookahead is a paid mutator transaction binding the contract method 0xe086adb3. // -// Solidity: function updateOperatorStake(address operator, bytes32 operatorId, bytes quorumNumbers) returns(uint192) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryTransactor) UpdateOperatorStake(opts *bind.TransactOpts, operator common.Address, operatorId [32]byte, quorumNumbers []byte) (*types.Transaction, error) { - return _ContractEOStakeRegistry.contract.Transact(opts, "updateOperatorStake", operator, operatorId, quorumNumbers) +// Solidity: function setSlashableStakeLookahead(uint8 quorumNumber, uint32 _lookAheadBlocks) returns() +func (_EOStakeRegistry *EOStakeRegistryTransactorSession) SetSlashableStakeLookahead(quorumNumber uint8, _lookAheadBlocks uint32) (*types.Transaction, error) { + return _EOStakeRegistry.Contract.SetSlashableStakeLookahead(&_EOStakeRegistry.TransactOpts, quorumNumber, _lookAheadBlocks) } -// UpdateOperatorStake is a paid mutator transaction binding the contract method 0x66acfefe. +// UpdateOperatorsStake is a paid mutator transaction binding the contract method 0x6c3fb4bf. // -// Solidity: function updateOperatorStake(address operator, bytes32 operatorId, bytes quorumNumbers) returns(uint192) -func (_ContractEOStakeRegistry *ContractEOStakeRegistrySession) UpdateOperatorStake(operator common.Address, operatorId [32]byte, quorumNumbers []byte) (*types.Transaction, error) { - return _ContractEOStakeRegistry.Contract.UpdateOperatorStake(&_ContractEOStakeRegistry.TransactOpts, operator, operatorId, quorumNumbers) +// Solidity: function updateOperatorsStake(address[] operators, bytes32[] operatorIds, uint8 quorumNumber) returns(bool[]) +func (_EOStakeRegistry *EOStakeRegistryTransactor) UpdateOperatorsStake(opts *bind.TransactOpts, operators []common.Address, operatorIds [][32]byte, quorumNumber uint8) (*types.Transaction, error) { + return _EOStakeRegistry.contract.Transact(opts, "updateOperatorsStake", operators, operatorIds, quorumNumber) } -// UpdateOperatorStake is a paid mutator transaction binding the contract method 0x66acfefe. +// UpdateOperatorsStake is a paid mutator transaction binding the contract method 0x6c3fb4bf. // -// Solidity: function updateOperatorStake(address operator, bytes32 operatorId, bytes quorumNumbers) returns(uint192) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryTransactorSession) UpdateOperatorStake(operator common.Address, operatorId [32]byte, quorumNumbers []byte) (*types.Transaction, error) { - return _ContractEOStakeRegistry.Contract.UpdateOperatorStake(&_ContractEOStakeRegistry.TransactOpts, operator, operatorId, quorumNumbers) +// Solidity: function updateOperatorsStake(address[] operators, bytes32[] operatorIds, uint8 quorumNumber) returns(bool[]) +func (_EOStakeRegistry *EOStakeRegistrySession) UpdateOperatorsStake(operators []common.Address, operatorIds [][32]byte, quorumNumber uint8) (*types.Transaction, error) { + return _EOStakeRegistry.Contract.UpdateOperatorsStake(&_EOStakeRegistry.TransactOpts, operators, operatorIds, quorumNumber) } -// ContractEOStakeRegistryMinimumStakeForQuorumUpdatedIterator is returned from FilterMinimumStakeForQuorumUpdated and is used to iterate over the raw logs and unpacked data for MinimumStakeForQuorumUpdated events raised by the ContractEOStakeRegistry contract. -type ContractEOStakeRegistryMinimumStakeForQuorumUpdatedIterator struct { - Event *ContractEOStakeRegistryMinimumStakeForQuorumUpdated // Event containing the contract specifics and raw log +// UpdateOperatorsStake is a paid mutator transaction binding the contract method 0x6c3fb4bf. +// +// Solidity: function updateOperatorsStake(address[] operators, bytes32[] operatorIds, uint8 quorumNumber) returns(bool[]) +func (_EOStakeRegistry *EOStakeRegistryTransactorSession) UpdateOperatorsStake(operators []common.Address, operatorIds [][32]byte, quorumNumber uint8) (*types.Transaction, error) { + return _EOStakeRegistry.Contract.UpdateOperatorsStake(&_EOStakeRegistry.TransactOpts, operators, operatorIds, quorumNumber) +} + +// UpdateOperatorsStake0 is a paid mutator transaction binding the contract method 0x7b0c1bb1. +// +// Solidity: function updateOperatorsStake(address[] operators, bytes32[] operatorIds, uint8 quorumNumber, uint32 operatorSetId) returns(bool[]) +func (_EOStakeRegistry *EOStakeRegistryTransactor) UpdateOperatorsStake0(opts *bind.TransactOpts, operators []common.Address, operatorIds [][32]byte, quorumNumber uint8, operatorSetId uint32) (*types.Transaction, error) { + return _EOStakeRegistry.contract.Transact(opts, "updateOperatorsStake0", operators, operatorIds, quorumNumber, operatorSetId) +} + +// UpdateOperatorsStake0 is a paid mutator transaction binding the contract method 0x7b0c1bb1. +// +// Solidity: function updateOperatorsStake(address[] operators, bytes32[] operatorIds, uint8 quorumNumber, uint32 operatorSetId) returns(bool[]) +func (_EOStakeRegistry *EOStakeRegistrySession) UpdateOperatorsStake0(operators []common.Address, operatorIds [][32]byte, quorumNumber uint8, operatorSetId uint32) (*types.Transaction, error) { + return _EOStakeRegistry.Contract.UpdateOperatorsStake0(&_EOStakeRegistry.TransactOpts, operators, operatorIds, quorumNumber, operatorSetId) +} + +// UpdateOperatorsStake0 is a paid mutator transaction binding the contract method 0x7b0c1bb1. +// +// Solidity: function updateOperatorsStake(address[] operators, bytes32[] operatorIds, uint8 quorumNumber, uint32 operatorSetId) returns(bool[]) +func (_EOStakeRegistry *EOStakeRegistryTransactorSession) UpdateOperatorsStake0(operators []common.Address, operatorIds [][32]byte, quorumNumber uint8, operatorSetId uint32) (*types.Transaction, error) { + return _EOStakeRegistry.Contract.UpdateOperatorsStake0(&_EOStakeRegistry.TransactOpts, operators, operatorIds, quorumNumber, operatorSetId) +} + +// EOStakeRegistryLookAheadPeriodChangedIterator is returned from FilterLookAheadPeriodChanged and is used to iterate over the raw logs and unpacked data for LookAheadPeriodChanged events raised by the EOStakeRegistry contract. +type EOStakeRegistryLookAheadPeriodChangedIterator struct { + Event *EOStakeRegistryLookAheadPeriodChanged // 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 @@ -1243,7 +1343,7 @@ type ContractEOStakeRegistryMinimumStakeForQuorumUpdatedIterator struct { // 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 *ContractEOStakeRegistryMinimumStakeForQuorumUpdatedIterator) Next() bool { +func (it *EOStakeRegistryLookAheadPeriodChangedIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -1252,7 +1352,7 @@ func (it *ContractEOStakeRegistryMinimumStakeForQuorumUpdatedIterator) Next() bo if it.done { select { case log := <-it.logs: - it.Event = new(ContractEOStakeRegistryMinimumStakeForQuorumUpdated) + it.Event = new(EOStakeRegistryLookAheadPeriodChanged) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1267,7 +1367,7 @@ func (it *ContractEOStakeRegistryMinimumStakeForQuorumUpdatedIterator) Next() bo // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(ContractEOStakeRegistryMinimumStakeForQuorumUpdated) + it.Event = new(EOStakeRegistryLookAheadPeriodChanged) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1283,19 +1383,154 @@ func (it *ContractEOStakeRegistryMinimumStakeForQuorumUpdatedIterator) Next() bo } // Error returns any retrieval or parsing error occurred during filtering. -func (it *ContractEOStakeRegistryMinimumStakeForQuorumUpdatedIterator) Error() error { +func (it *EOStakeRegistryLookAheadPeriodChangedIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *ContractEOStakeRegistryMinimumStakeForQuorumUpdatedIterator) Close() error { +func (it *EOStakeRegistryLookAheadPeriodChangedIterator) Close() error { it.sub.Unsubscribe() return nil } -// ContractEOStakeRegistryMinimumStakeForQuorumUpdated represents a MinimumStakeForQuorumUpdated event raised by the ContractEOStakeRegistry contract. -type ContractEOStakeRegistryMinimumStakeForQuorumUpdated struct { +// EOStakeRegistryLookAheadPeriodChanged represents a LookAheadPeriodChanged event raised by the EOStakeRegistry contract. +type EOStakeRegistryLookAheadPeriodChanged struct { + OldLookAheadBlocks uint32 + NewLookAheadBlocks uint32 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLookAheadPeriodChanged is a free log retrieval operation binding the contract event 0x28d7358b79f02d21b8b7e17aefc4185a64308aa37406fa5befc05b91932c39c7. +// +// Solidity: event LookAheadPeriodChanged(uint32 oldLookAheadBlocks, uint32 newLookAheadBlocks) +func (_EOStakeRegistry *EOStakeRegistryFilterer) FilterLookAheadPeriodChanged(opts *bind.FilterOpts) (*EOStakeRegistryLookAheadPeriodChangedIterator, error) { + + logs, sub, err := _EOStakeRegistry.contract.FilterLogs(opts, "LookAheadPeriodChanged") + if err != nil { + return nil, err + } + return &EOStakeRegistryLookAheadPeriodChangedIterator{contract: _EOStakeRegistry.contract, event: "LookAheadPeriodChanged", logs: logs, sub: sub}, nil +} + +// WatchLookAheadPeriodChanged is a free log subscription operation binding the contract event 0x28d7358b79f02d21b8b7e17aefc4185a64308aa37406fa5befc05b91932c39c7. +// +// Solidity: event LookAheadPeriodChanged(uint32 oldLookAheadBlocks, uint32 newLookAheadBlocks) +func (_EOStakeRegistry *EOStakeRegistryFilterer) WatchLookAheadPeriodChanged(opts *bind.WatchOpts, sink chan<- *EOStakeRegistryLookAheadPeriodChanged) (event.Subscription, error) { + + logs, sub, err := _EOStakeRegistry.contract.WatchLogs(opts, "LookAheadPeriodChanged") + 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(EOStakeRegistryLookAheadPeriodChanged) + if err := _EOStakeRegistry.contract.UnpackLog(event, "LookAheadPeriodChanged", 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 +} + +// ParseLookAheadPeriodChanged is a log parse operation binding the contract event 0x28d7358b79f02d21b8b7e17aefc4185a64308aa37406fa5befc05b91932c39c7. +// +// Solidity: event LookAheadPeriodChanged(uint32 oldLookAheadBlocks, uint32 newLookAheadBlocks) +func (_EOStakeRegistry *EOStakeRegistryFilterer) ParseLookAheadPeriodChanged(log types.Log) (*EOStakeRegistryLookAheadPeriodChanged, error) { + event := new(EOStakeRegistryLookAheadPeriodChanged) + if err := _EOStakeRegistry.contract.UnpackLog(event, "LookAheadPeriodChanged", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// EOStakeRegistryMinimumStakeForQuorumUpdatedIterator is returned from FilterMinimumStakeForQuorumUpdated and is used to iterate over the raw logs and unpacked data for MinimumStakeForQuorumUpdated events raised by the EOStakeRegistry contract. +type EOStakeRegistryMinimumStakeForQuorumUpdatedIterator struct { + Event *EOStakeRegistryMinimumStakeForQuorumUpdated // 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 *EOStakeRegistryMinimumStakeForQuorumUpdatedIterator) 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(EOStakeRegistryMinimumStakeForQuorumUpdated) + 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(EOStakeRegistryMinimumStakeForQuorumUpdated) + 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 *EOStakeRegistryMinimumStakeForQuorumUpdatedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *EOStakeRegistryMinimumStakeForQuorumUpdatedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// EOStakeRegistryMinimumStakeForQuorumUpdated represents a MinimumStakeForQuorumUpdated event raised by the EOStakeRegistry contract. +type EOStakeRegistryMinimumStakeForQuorumUpdated struct { QuorumNumber uint8 MinimumStake *big.Int Raw types.Log // Blockchain specific contextual infos @@ -1304,31 +1539,31 @@ type ContractEOStakeRegistryMinimumStakeForQuorumUpdated struct { // FilterMinimumStakeForQuorumUpdated is a free log retrieval operation binding the contract event 0x26eecff2b70b0a71104ff4d940ba7162d23a95c248771fc487a7be17a596b3cf. // // Solidity: event MinimumStakeForQuorumUpdated(uint8 indexed quorumNumber, uint96 minimumStake) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryFilterer) FilterMinimumStakeForQuorumUpdated(opts *bind.FilterOpts, quorumNumber []uint8) (*ContractEOStakeRegistryMinimumStakeForQuorumUpdatedIterator, error) { +func (_EOStakeRegistry *EOStakeRegistryFilterer) FilterMinimumStakeForQuorumUpdated(opts *bind.FilterOpts, quorumNumber []uint8) (*EOStakeRegistryMinimumStakeForQuorumUpdatedIterator, error) { var quorumNumberRule []interface{} for _, quorumNumberItem := range quorumNumber { quorumNumberRule = append(quorumNumberRule, quorumNumberItem) } - logs, sub, err := _ContractEOStakeRegistry.contract.FilterLogs(opts, "MinimumStakeForQuorumUpdated", quorumNumberRule) + logs, sub, err := _EOStakeRegistry.contract.FilterLogs(opts, "MinimumStakeForQuorumUpdated", quorumNumberRule) if err != nil { return nil, err } - return &ContractEOStakeRegistryMinimumStakeForQuorumUpdatedIterator{contract: _ContractEOStakeRegistry.contract, event: "MinimumStakeForQuorumUpdated", logs: logs, sub: sub}, nil + return &EOStakeRegistryMinimumStakeForQuorumUpdatedIterator{contract: _EOStakeRegistry.contract, event: "MinimumStakeForQuorumUpdated", logs: logs, sub: sub}, nil } // WatchMinimumStakeForQuorumUpdated is a free log subscription operation binding the contract event 0x26eecff2b70b0a71104ff4d940ba7162d23a95c248771fc487a7be17a596b3cf. // // Solidity: event MinimumStakeForQuorumUpdated(uint8 indexed quorumNumber, uint96 minimumStake) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryFilterer) WatchMinimumStakeForQuorumUpdated(opts *bind.WatchOpts, sink chan<- *ContractEOStakeRegistryMinimumStakeForQuorumUpdated, quorumNumber []uint8) (event.Subscription, error) { +func (_EOStakeRegistry *EOStakeRegistryFilterer) WatchMinimumStakeForQuorumUpdated(opts *bind.WatchOpts, sink chan<- *EOStakeRegistryMinimumStakeForQuorumUpdated, quorumNumber []uint8) (event.Subscription, error) { var quorumNumberRule []interface{} for _, quorumNumberItem := range quorumNumber { quorumNumberRule = append(quorumNumberRule, quorumNumberItem) } - logs, sub, err := _ContractEOStakeRegistry.contract.WatchLogs(opts, "MinimumStakeForQuorumUpdated", quorumNumberRule) + logs, sub, err := _EOStakeRegistry.contract.WatchLogs(opts, "MinimumStakeForQuorumUpdated", quorumNumberRule) if err != nil { return nil, err } @@ -1338,8 +1573,8 @@ func (_ContractEOStakeRegistry *ContractEOStakeRegistryFilterer) WatchMinimumSta select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(ContractEOStakeRegistryMinimumStakeForQuorumUpdated) - if err := _ContractEOStakeRegistry.contract.UnpackLog(event, "MinimumStakeForQuorumUpdated", log); err != nil { + event := new(EOStakeRegistryMinimumStakeForQuorumUpdated) + if err := _EOStakeRegistry.contract.UnpackLog(event, "MinimumStakeForQuorumUpdated", log); err != nil { return err } event.Raw = log @@ -1363,18 +1598,18 @@ func (_ContractEOStakeRegistry *ContractEOStakeRegistryFilterer) WatchMinimumSta // ParseMinimumStakeForQuorumUpdated is a log parse operation binding the contract event 0x26eecff2b70b0a71104ff4d940ba7162d23a95c248771fc487a7be17a596b3cf. // // Solidity: event MinimumStakeForQuorumUpdated(uint8 indexed quorumNumber, uint96 minimumStake) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryFilterer) ParseMinimumStakeForQuorumUpdated(log types.Log) (*ContractEOStakeRegistryMinimumStakeForQuorumUpdated, error) { - event := new(ContractEOStakeRegistryMinimumStakeForQuorumUpdated) - if err := _ContractEOStakeRegistry.contract.UnpackLog(event, "MinimumStakeForQuorumUpdated", log); err != nil { +func (_EOStakeRegistry *EOStakeRegistryFilterer) ParseMinimumStakeForQuorumUpdated(log types.Log) (*EOStakeRegistryMinimumStakeForQuorumUpdated, error) { + event := new(EOStakeRegistryMinimumStakeForQuorumUpdated) + if err := _EOStakeRegistry.contract.UnpackLog(event, "MinimumStakeForQuorumUpdated", log); err != nil { return nil, err } event.Raw = log return event, nil } -// ContractEOStakeRegistryOperatorStakeUpdateIterator is returned from FilterOperatorStakeUpdate and is used to iterate over the raw logs and unpacked data for OperatorStakeUpdate events raised by the ContractEOStakeRegistry contract. -type ContractEOStakeRegistryOperatorStakeUpdateIterator struct { - Event *ContractEOStakeRegistryOperatorStakeUpdate // Event containing the contract specifics and raw log +// EOStakeRegistryOperatorStakeUpdateIterator is returned from FilterOperatorStakeUpdate and is used to iterate over the raw logs and unpacked data for OperatorStakeUpdate events raised by the EOStakeRegistry contract. +type EOStakeRegistryOperatorStakeUpdateIterator struct { + Event *EOStakeRegistryOperatorStakeUpdate // 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 @@ -1388,7 +1623,7 @@ type ContractEOStakeRegistryOperatorStakeUpdateIterator struct { // 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 *ContractEOStakeRegistryOperatorStakeUpdateIterator) Next() bool { +func (it *EOStakeRegistryOperatorStakeUpdateIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -1397,7 +1632,7 @@ func (it *ContractEOStakeRegistryOperatorStakeUpdateIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(ContractEOStakeRegistryOperatorStakeUpdate) + it.Event = new(EOStakeRegistryOperatorStakeUpdate) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1412,7 +1647,7 @@ func (it *ContractEOStakeRegistryOperatorStakeUpdateIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(ContractEOStakeRegistryOperatorStakeUpdate) + it.Event = new(EOStakeRegistryOperatorStakeUpdate) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1428,19 +1663,19 @@ func (it *ContractEOStakeRegistryOperatorStakeUpdateIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *ContractEOStakeRegistryOperatorStakeUpdateIterator) Error() error { +func (it *EOStakeRegistryOperatorStakeUpdateIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *ContractEOStakeRegistryOperatorStakeUpdateIterator) Close() error { +func (it *EOStakeRegistryOperatorStakeUpdateIterator) Close() error { it.sub.Unsubscribe() return nil } -// ContractEOStakeRegistryOperatorStakeUpdate represents a OperatorStakeUpdate event raised by the ContractEOStakeRegistry contract. -type ContractEOStakeRegistryOperatorStakeUpdate struct { +// EOStakeRegistryOperatorStakeUpdate represents a OperatorStakeUpdate event raised by the EOStakeRegistry contract. +type EOStakeRegistryOperatorStakeUpdate struct { OperatorId [32]byte QuorumNumber uint8 Stake *big.Int @@ -1450,31 +1685,31 @@ type ContractEOStakeRegistryOperatorStakeUpdate struct { // FilterOperatorStakeUpdate is a free log retrieval operation binding the contract event 0x2f527d527e95d8fe40aec55377743bb779087da3f6d0d08f12e36444da62327d. // // Solidity: event OperatorStakeUpdate(bytes32 indexed operatorId, uint8 quorumNumber, uint96 stake) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryFilterer) FilterOperatorStakeUpdate(opts *bind.FilterOpts, operatorId [][32]byte) (*ContractEOStakeRegistryOperatorStakeUpdateIterator, error) { +func (_EOStakeRegistry *EOStakeRegistryFilterer) FilterOperatorStakeUpdate(opts *bind.FilterOpts, operatorId [][32]byte) (*EOStakeRegistryOperatorStakeUpdateIterator, error) { var operatorIdRule []interface{} for _, operatorIdItem := range operatorId { operatorIdRule = append(operatorIdRule, operatorIdItem) } - logs, sub, err := _ContractEOStakeRegistry.contract.FilterLogs(opts, "OperatorStakeUpdate", operatorIdRule) + logs, sub, err := _EOStakeRegistry.contract.FilterLogs(opts, "OperatorStakeUpdate", operatorIdRule) if err != nil { return nil, err } - return &ContractEOStakeRegistryOperatorStakeUpdateIterator{contract: _ContractEOStakeRegistry.contract, event: "OperatorStakeUpdate", logs: logs, sub: sub}, nil + return &EOStakeRegistryOperatorStakeUpdateIterator{contract: _EOStakeRegistry.contract, event: "OperatorStakeUpdate", logs: logs, sub: sub}, nil } // WatchOperatorStakeUpdate is a free log subscription operation binding the contract event 0x2f527d527e95d8fe40aec55377743bb779087da3f6d0d08f12e36444da62327d. // // Solidity: event OperatorStakeUpdate(bytes32 indexed operatorId, uint8 quorumNumber, uint96 stake) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryFilterer) WatchOperatorStakeUpdate(opts *bind.WatchOpts, sink chan<- *ContractEOStakeRegistryOperatorStakeUpdate, operatorId [][32]byte) (event.Subscription, error) { +func (_EOStakeRegistry *EOStakeRegistryFilterer) WatchOperatorStakeUpdate(opts *bind.WatchOpts, sink chan<- *EOStakeRegistryOperatorStakeUpdate, operatorId [][32]byte) (event.Subscription, error) { var operatorIdRule []interface{} for _, operatorIdItem := range operatorId { operatorIdRule = append(operatorIdRule, operatorIdItem) } - logs, sub, err := _ContractEOStakeRegistry.contract.WatchLogs(opts, "OperatorStakeUpdate", operatorIdRule) + logs, sub, err := _EOStakeRegistry.contract.WatchLogs(opts, "OperatorStakeUpdate", operatorIdRule) if err != nil { return nil, err } @@ -1484,8 +1719,8 @@ func (_ContractEOStakeRegistry *ContractEOStakeRegistryFilterer) WatchOperatorSt select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(ContractEOStakeRegistryOperatorStakeUpdate) - if err := _ContractEOStakeRegistry.contract.UnpackLog(event, "OperatorStakeUpdate", log); err != nil { + event := new(EOStakeRegistryOperatorStakeUpdate) + if err := _EOStakeRegistry.contract.UnpackLog(event, "OperatorStakeUpdate", log); err != nil { return err } event.Raw = log @@ -1509,18 +1744,18 @@ func (_ContractEOStakeRegistry *ContractEOStakeRegistryFilterer) WatchOperatorSt // ParseOperatorStakeUpdate is a log parse operation binding the contract event 0x2f527d527e95d8fe40aec55377743bb779087da3f6d0d08f12e36444da62327d. // // Solidity: event OperatorStakeUpdate(bytes32 indexed operatorId, uint8 quorumNumber, uint96 stake) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryFilterer) ParseOperatorStakeUpdate(log types.Log) (*ContractEOStakeRegistryOperatorStakeUpdate, error) { - event := new(ContractEOStakeRegistryOperatorStakeUpdate) - if err := _ContractEOStakeRegistry.contract.UnpackLog(event, "OperatorStakeUpdate", log); err != nil { +func (_EOStakeRegistry *EOStakeRegistryFilterer) ParseOperatorStakeUpdate(log types.Log) (*EOStakeRegistryOperatorStakeUpdate, error) { + event := new(EOStakeRegistryOperatorStakeUpdate) + if err := _EOStakeRegistry.contract.UnpackLog(event, "OperatorStakeUpdate", log); err != nil { return nil, err } event.Raw = log return event, nil } -// ContractEOStakeRegistryQuorumCreatedIterator is returned from FilterQuorumCreated and is used to iterate over the raw logs and unpacked data for QuorumCreated events raised by the ContractEOStakeRegistry contract. -type ContractEOStakeRegistryQuorumCreatedIterator struct { - Event *ContractEOStakeRegistryQuorumCreated // Event containing the contract specifics and raw log +// EOStakeRegistryQuorumCreatedIterator is returned from FilterQuorumCreated and is used to iterate over the raw logs and unpacked data for QuorumCreated events raised by the EOStakeRegistry contract. +type EOStakeRegistryQuorumCreatedIterator struct { + Event *EOStakeRegistryQuorumCreated // 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 @@ -1534,7 +1769,7 @@ type ContractEOStakeRegistryQuorumCreatedIterator struct { // 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 *ContractEOStakeRegistryQuorumCreatedIterator) Next() bool { +func (it *EOStakeRegistryQuorumCreatedIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -1543,7 +1778,7 @@ func (it *ContractEOStakeRegistryQuorumCreatedIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(ContractEOStakeRegistryQuorumCreated) + it.Event = new(EOStakeRegistryQuorumCreated) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1558,7 +1793,7 @@ func (it *ContractEOStakeRegistryQuorumCreatedIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(ContractEOStakeRegistryQuorumCreated) + it.Event = new(EOStakeRegistryQuorumCreated) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1574,19 +1809,19 @@ func (it *ContractEOStakeRegistryQuorumCreatedIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *ContractEOStakeRegistryQuorumCreatedIterator) Error() error { +func (it *EOStakeRegistryQuorumCreatedIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *ContractEOStakeRegistryQuorumCreatedIterator) Close() error { +func (it *EOStakeRegistryQuorumCreatedIterator) Close() error { it.sub.Unsubscribe() return nil } -// ContractEOStakeRegistryQuorumCreated represents a QuorumCreated event raised by the ContractEOStakeRegistry contract. -type ContractEOStakeRegistryQuorumCreated struct { +// EOStakeRegistryQuorumCreated represents a QuorumCreated event raised by the EOStakeRegistry contract. +type EOStakeRegistryQuorumCreated struct { QuorumNumber uint8 Raw types.Log // Blockchain specific contextual infos } @@ -1594,31 +1829,31 @@ type ContractEOStakeRegistryQuorumCreated struct { // FilterQuorumCreated is a free log retrieval operation binding the contract event 0x831a9c86c45bb303caf3f064be2bc2b9fd4ecf19e47c4ac02a61e75dabfe55b4. // // Solidity: event QuorumCreated(uint8 indexed quorumNumber) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryFilterer) FilterQuorumCreated(opts *bind.FilterOpts, quorumNumber []uint8) (*ContractEOStakeRegistryQuorumCreatedIterator, error) { +func (_EOStakeRegistry *EOStakeRegistryFilterer) FilterQuorumCreated(opts *bind.FilterOpts, quorumNumber []uint8) (*EOStakeRegistryQuorumCreatedIterator, error) { var quorumNumberRule []interface{} for _, quorumNumberItem := range quorumNumber { quorumNumberRule = append(quorumNumberRule, quorumNumberItem) } - logs, sub, err := _ContractEOStakeRegistry.contract.FilterLogs(opts, "QuorumCreated", quorumNumberRule) + logs, sub, err := _EOStakeRegistry.contract.FilterLogs(opts, "QuorumCreated", quorumNumberRule) if err != nil { return nil, err } - return &ContractEOStakeRegistryQuorumCreatedIterator{contract: _ContractEOStakeRegistry.contract, event: "QuorumCreated", logs: logs, sub: sub}, nil + return &EOStakeRegistryQuorumCreatedIterator{contract: _EOStakeRegistry.contract, event: "QuorumCreated", logs: logs, sub: sub}, nil } // WatchQuorumCreated is a free log subscription operation binding the contract event 0x831a9c86c45bb303caf3f064be2bc2b9fd4ecf19e47c4ac02a61e75dabfe55b4. // // Solidity: event QuorumCreated(uint8 indexed quorumNumber) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryFilterer) WatchQuorumCreated(opts *bind.WatchOpts, sink chan<- *ContractEOStakeRegistryQuorumCreated, quorumNumber []uint8) (event.Subscription, error) { +func (_EOStakeRegistry *EOStakeRegistryFilterer) WatchQuorumCreated(opts *bind.WatchOpts, sink chan<- *EOStakeRegistryQuorumCreated, quorumNumber []uint8) (event.Subscription, error) { var quorumNumberRule []interface{} for _, quorumNumberItem := range quorumNumber { quorumNumberRule = append(quorumNumberRule, quorumNumberItem) } - logs, sub, err := _ContractEOStakeRegistry.contract.WatchLogs(opts, "QuorumCreated", quorumNumberRule) + logs, sub, err := _EOStakeRegistry.contract.WatchLogs(opts, "QuorumCreated", quorumNumberRule) if err != nil { return nil, err } @@ -1628,8 +1863,8 @@ func (_ContractEOStakeRegistry *ContractEOStakeRegistryFilterer) WatchQuorumCrea select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(ContractEOStakeRegistryQuorumCreated) - if err := _ContractEOStakeRegistry.contract.UnpackLog(event, "QuorumCreated", log); err != nil { + event := new(EOStakeRegistryQuorumCreated) + if err := _EOStakeRegistry.contract.UnpackLog(event, "QuorumCreated", log); err != nil { return err } event.Raw = log @@ -1653,18 +1888,152 @@ func (_ContractEOStakeRegistry *ContractEOStakeRegistryFilterer) WatchQuorumCrea // ParseQuorumCreated is a log parse operation binding the contract event 0x831a9c86c45bb303caf3f064be2bc2b9fd4ecf19e47c4ac02a61e75dabfe55b4. // // Solidity: event QuorumCreated(uint8 indexed quorumNumber) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryFilterer) ParseQuorumCreated(log types.Log) (*ContractEOStakeRegistryQuorumCreated, error) { - event := new(ContractEOStakeRegistryQuorumCreated) - if err := _ContractEOStakeRegistry.contract.UnpackLog(event, "QuorumCreated", log); err != nil { +func (_EOStakeRegistry *EOStakeRegistryFilterer) ParseQuorumCreated(log types.Log) (*EOStakeRegistryQuorumCreated, error) { + event := new(EOStakeRegistryQuorumCreated) + if err := _EOStakeRegistry.contract.UnpackLog(event, "QuorumCreated", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// EOStakeRegistryStakeTypeSetIterator is returned from FilterStakeTypeSet and is used to iterate over the raw logs and unpacked data for StakeTypeSet events raised by the EOStakeRegistry contract. +type EOStakeRegistryStakeTypeSetIterator struct { + Event *EOStakeRegistryStakeTypeSet // 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 *EOStakeRegistryStakeTypeSetIterator) 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(EOStakeRegistryStakeTypeSet) + 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(EOStakeRegistryStakeTypeSet) + 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 *EOStakeRegistryStakeTypeSetIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *EOStakeRegistryStakeTypeSetIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// EOStakeRegistryStakeTypeSet represents a StakeTypeSet event raised by the EOStakeRegistry contract. +type EOStakeRegistryStakeTypeSet struct { + NewStakeType uint8 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterStakeTypeSet is a free log retrieval operation binding the contract event 0x7c112e863ccf007862e2c9e25819c933fedbc9350a6443423b4a8599c2e8a52d. +// +// Solidity: event StakeTypeSet(uint8 newStakeType) +func (_EOStakeRegistry *EOStakeRegistryFilterer) FilterStakeTypeSet(opts *bind.FilterOpts) (*EOStakeRegistryStakeTypeSetIterator, error) { + + logs, sub, err := _EOStakeRegistry.contract.FilterLogs(opts, "StakeTypeSet") + if err != nil { + return nil, err + } + return &EOStakeRegistryStakeTypeSetIterator{contract: _EOStakeRegistry.contract, event: "StakeTypeSet", logs: logs, sub: sub}, nil +} + +// WatchStakeTypeSet is a free log subscription operation binding the contract event 0x7c112e863ccf007862e2c9e25819c933fedbc9350a6443423b4a8599c2e8a52d. +// +// Solidity: event StakeTypeSet(uint8 newStakeType) +func (_EOStakeRegistry *EOStakeRegistryFilterer) WatchStakeTypeSet(opts *bind.WatchOpts, sink chan<- *EOStakeRegistryStakeTypeSet) (event.Subscription, error) { + + logs, sub, err := _EOStakeRegistry.contract.WatchLogs(opts, "StakeTypeSet") + 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(EOStakeRegistryStakeTypeSet) + if err := _EOStakeRegistry.contract.UnpackLog(event, "StakeTypeSet", 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 +} + +// ParseStakeTypeSet is a log parse operation binding the contract event 0x7c112e863ccf007862e2c9e25819c933fedbc9350a6443423b4a8599c2e8a52d. +// +// Solidity: event StakeTypeSet(uint8 newStakeType) +func (_EOStakeRegistry *EOStakeRegistryFilterer) ParseStakeTypeSet(log types.Log) (*EOStakeRegistryStakeTypeSet, error) { + event := new(EOStakeRegistryStakeTypeSet) + if err := _EOStakeRegistry.contract.UnpackLog(event, "StakeTypeSet", log); err != nil { return nil, err } event.Raw = log return event, nil } -// ContractEOStakeRegistryStrategyAddedToQuorumIterator is returned from FilterStrategyAddedToQuorum and is used to iterate over the raw logs and unpacked data for StrategyAddedToQuorum events raised by the ContractEOStakeRegistry contract. -type ContractEOStakeRegistryStrategyAddedToQuorumIterator struct { - Event *ContractEOStakeRegistryStrategyAddedToQuorum // Event containing the contract specifics and raw log +// EOStakeRegistryStrategyAddedToQuorumIterator is returned from FilterStrategyAddedToQuorum and is used to iterate over the raw logs and unpacked data for StrategyAddedToQuorum events raised by the EOStakeRegistry contract. +type EOStakeRegistryStrategyAddedToQuorumIterator struct { + Event *EOStakeRegistryStrategyAddedToQuorum // 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 @@ -1678,7 +2047,7 @@ type ContractEOStakeRegistryStrategyAddedToQuorumIterator struct { // 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 *ContractEOStakeRegistryStrategyAddedToQuorumIterator) Next() bool { +func (it *EOStakeRegistryStrategyAddedToQuorumIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -1687,7 +2056,7 @@ func (it *ContractEOStakeRegistryStrategyAddedToQuorumIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(ContractEOStakeRegistryStrategyAddedToQuorum) + it.Event = new(EOStakeRegistryStrategyAddedToQuorum) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1702,7 +2071,7 @@ func (it *ContractEOStakeRegistryStrategyAddedToQuorumIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(ContractEOStakeRegistryStrategyAddedToQuorum) + it.Event = new(EOStakeRegistryStrategyAddedToQuorum) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1718,19 +2087,19 @@ func (it *ContractEOStakeRegistryStrategyAddedToQuorumIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *ContractEOStakeRegistryStrategyAddedToQuorumIterator) Error() error { +func (it *EOStakeRegistryStrategyAddedToQuorumIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *ContractEOStakeRegistryStrategyAddedToQuorumIterator) Close() error { +func (it *EOStakeRegistryStrategyAddedToQuorumIterator) Close() error { it.sub.Unsubscribe() return nil } -// ContractEOStakeRegistryStrategyAddedToQuorum represents a StrategyAddedToQuorum event raised by the ContractEOStakeRegistry contract. -type ContractEOStakeRegistryStrategyAddedToQuorum struct { +// EOStakeRegistryStrategyAddedToQuorum represents a StrategyAddedToQuorum event raised by the EOStakeRegistry contract. +type EOStakeRegistryStrategyAddedToQuorum struct { QuorumNumber uint8 Strategy common.Address Raw types.Log // Blockchain specific contextual infos @@ -1739,31 +2108,31 @@ type ContractEOStakeRegistryStrategyAddedToQuorum struct { // FilterStrategyAddedToQuorum is a free log retrieval operation binding the contract event 0x10565e56cacbf32eca267945f054fec02e59750032d113d3302182ad967f5404. // // Solidity: event StrategyAddedToQuorum(uint8 indexed quorumNumber, address strategy) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryFilterer) FilterStrategyAddedToQuorum(opts *bind.FilterOpts, quorumNumber []uint8) (*ContractEOStakeRegistryStrategyAddedToQuorumIterator, error) { +func (_EOStakeRegistry *EOStakeRegistryFilterer) FilterStrategyAddedToQuorum(opts *bind.FilterOpts, quorumNumber []uint8) (*EOStakeRegistryStrategyAddedToQuorumIterator, error) { var quorumNumberRule []interface{} for _, quorumNumberItem := range quorumNumber { quorumNumberRule = append(quorumNumberRule, quorumNumberItem) } - logs, sub, err := _ContractEOStakeRegistry.contract.FilterLogs(opts, "StrategyAddedToQuorum", quorumNumberRule) + logs, sub, err := _EOStakeRegistry.contract.FilterLogs(opts, "StrategyAddedToQuorum", quorumNumberRule) if err != nil { return nil, err } - return &ContractEOStakeRegistryStrategyAddedToQuorumIterator{contract: _ContractEOStakeRegistry.contract, event: "StrategyAddedToQuorum", logs: logs, sub: sub}, nil + return &EOStakeRegistryStrategyAddedToQuorumIterator{contract: _EOStakeRegistry.contract, event: "StrategyAddedToQuorum", logs: logs, sub: sub}, nil } // WatchStrategyAddedToQuorum is a free log subscription operation binding the contract event 0x10565e56cacbf32eca267945f054fec02e59750032d113d3302182ad967f5404. // // Solidity: event StrategyAddedToQuorum(uint8 indexed quorumNumber, address strategy) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryFilterer) WatchStrategyAddedToQuorum(opts *bind.WatchOpts, sink chan<- *ContractEOStakeRegistryStrategyAddedToQuorum, quorumNumber []uint8) (event.Subscription, error) { +func (_EOStakeRegistry *EOStakeRegistryFilterer) WatchStrategyAddedToQuorum(opts *bind.WatchOpts, sink chan<- *EOStakeRegistryStrategyAddedToQuorum, quorumNumber []uint8) (event.Subscription, error) { var quorumNumberRule []interface{} for _, quorumNumberItem := range quorumNumber { quorumNumberRule = append(quorumNumberRule, quorumNumberItem) } - logs, sub, err := _ContractEOStakeRegistry.contract.WatchLogs(opts, "StrategyAddedToQuorum", quorumNumberRule) + logs, sub, err := _EOStakeRegistry.contract.WatchLogs(opts, "StrategyAddedToQuorum", quorumNumberRule) if err != nil { return nil, err } @@ -1773,8 +2142,8 @@ func (_ContractEOStakeRegistry *ContractEOStakeRegistryFilterer) WatchStrategyAd select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(ContractEOStakeRegistryStrategyAddedToQuorum) - if err := _ContractEOStakeRegistry.contract.UnpackLog(event, "StrategyAddedToQuorum", log); err != nil { + event := new(EOStakeRegistryStrategyAddedToQuorum) + if err := _EOStakeRegistry.contract.UnpackLog(event, "StrategyAddedToQuorum", log); err != nil { return err } event.Raw = log @@ -1798,18 +2167,18 @@ func (_ContractEOStakeRegistry *ContractEOStakeRegistryFilterer) WatchStrategyAd // ParseStrategyAddedToQuorum is a log parse operation binding the contract event 0x10565e56cacbf32eca267945f054fec02e59750032d113d3302182ad967f5404. // // Solidity: event StrategyAddedToQuorum(uint8 indexed quorumNumber, address strategy) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryFilterer) ParseStrategyAddedToQuorum(log types.Log) (*ContractEOStakeRegistryStrategyAddedToQuorum, error) { - event := new(ContractEOStakeRegistryStrategyAddedToQuorum) - if err := _ContractEOStakeRegistry.contract.UnpackLog(event, "StrategyAddedToQuorum", log); err != nil { +func (_EOStakeRegistry *EOStakeRegistryFilterer) ParseStrategyAddedToQuorum(log types.Log) (*EOStakeRegistryStrategyAddedToQuorum, error) { + event := new(EOStakeRegistryStrategyAddedToQuorum) + if err := _EOStakeRegistry.contract.UnpackLog(event, "StrategyAddedToQuorum", log); err != nil { return nil, err } event.Raw = log return event, nil } -// ContractEOStakeRegistryStrategyMultiplierUpdatedIterator is returned from FilterStrategyMultiplierUpdated and is used to iterate over the raw logs and unpacked data for StrategyMultiplierUpdated events raised by the ContractEOStakeRegistry contract. -type ContractEOStakeRegistryStrategyMultiplierUpdatedIterator struct { - Event *ContractEOStakeRegistryStrategyMultiplierUpdated // Event containing the contract specifics and raw log +// EOStakeRegistryStrategyMultiplierUpdatedIterator is returned from FilterStrategyMultiplierUpdated and is used to iterate over the raw logs and unpacked data for StrategyMultiplierUpdated events raised by the EOStakeRegistry contract. +type EOStakeRegistryStrategyMultiplierUpdatedIterator struct { + Event *EOStakeRegistryStrategyMultiplierUpdated // 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 @@ -1823,7 +2192,7 @@ type ContractEOStakeRegistryStrategyMultiplierUpdatedIterator struct { // 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 *ContractEOStakeRegistryStrategyMultiplierUpdatedIterator) Next() bool { +func (it *EOStakeRegistryStrategyMultiplierUpdatedIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -1832,7 +2201,7 @@ func (it *ContractEOStakeRegistryStrategyMultiplierUpdatedIterator) Next() bool if it.done { select { case log := <-it.logs: - it.Event = new(ContractEOStakeRegistryStrategyMultiplierUpdated) + it.Event = new(EOStakeRegistryStrategyMultiplierUpdated) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1847,7 +2216,7 @@ func (it *ContractEOStakeRegistryStrategyMultiplierUpdatedIterator) Next() bool // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(ContractEOStakeRegistryStrategyMultiplierUpdated) + it.Event = new(EOStakeRegistryStrategyMultiplierUpdated) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1863,19 +2232,19 @@ func (it *ContractEOStakeRegistryStrategyMultiplierUpdatedIterator) Next() bool } // Error returns any retrieval or parsing error occurred during filtering. -func (it *ContractEOStakeRegistryStrategyMultiplierUpdatedIterator) Error() error { +func (it *EOStakeRegistryStrategyMultiplierUpdatedIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *ContractEOStakeRegistryStrategyMultiplierUpdatedIterator) Close() error { +func (it *EOStakeRegistryStrategyMultiplierUpdatedIterator) Close() error { it.sub.Unsubscribe() return nil } -// ContractEOStakeRegistryStrategyMultiplierUpdated represents a StrategyMultiplierUpdated event raised by the ContractEOStakeRegistry contract. -type ContractEOStakeRegistryStrategyMultiplierUpdated struct { +// EOStakeRegistryStrategyMultiplierUpdated represents a StrategyMultiplierUpdated event raised by the EOStakeRegistry contract. +type EOStakeRegistryStrategyMultiplierUpdated struct { QuorumNumber uint8 Strategy common.Address Multiplier *big.Int @@ -1885,31 +2254,31 @@ type ContractEOStakeRegistryStrategyMultiplierUpdated struct { // FilterStrategyMultiplierUpdated is a free log retrieval operation binding the contract event 0x11a5641322da1dff56a4b66eaac31ffa465295ece907cd163437793b4d009a75. // // Solidity: event StrategyMultiplierUpdated(uint8 indexed quorumNumber, address strategy, uint256 multiplier) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryFilterer) FilterStrategyMultiplierUpdated(opts *bind.FilterOpts, quorumNumber []uint8) (*ContractEOStakeRegistryStrategyMultiplierUpdatedIterator, error) { +func (_EOStakeRegistry *EOStakeRegistryFilterer) FilterStrategyMultiplierUpdated(opts *bind.FilterOpts, quorumNumber []uint8) (*EOStakeRegistryStrategyMultiplierUpdatedIterator, error) { var quorumNumberRule []interface{} for _, quorumNumberItem := range quorumNumber { quorumNumberRule = append(quorumNumberRule, quorumNumberItem) } - logs, sub, err := _ContractEOStakeRegistry.contract.FilterLogs(opts, "StrategyMultiplierUpdated", quorumNumberRule) + logs, sub, err := _EOStakeRegistry.contract.FilterLogs(opts, "StrategyMultiplierUpdated", quorumNumberRule) if err != nil { return nil, err } - return &ContractEOStakeRegistryStrategyMultiplierUpdatedIterator{contract: _ContractEOStakeRegistry.contract, event: "StrategyMultiplierUpdated", logs: logs, sub: sub}, nil + return &EOStakeRegistryStrategyMultiplierUpdatedIterator{contract: _EOStakeRegistry.contract, event: "StrategyMultiplierUpdated", logs: logs, sub: sub}, nil } // WatchStrategyMultiplierUpdated is a free log subscription operation binding the contract event 0x11a5641322da1dff56a4b66eaac31ffa465295ece907cd163437793b4d009a75. // // Solidity: event StrategyMultiplierUpdated(uint8 indexed quorumNumber, address strategy, uint256 multiplier) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryFilterer) WatchStrategyMultiplierUpdated(opts *bind.WatchOpts, sink chan<- *ContractEOStakeRegistryStrategyMultiplierUpdated, quorumNumber []uint8) (event.Subscription, error) { +func (_EOStakeRegistry *EOStakeRegistryFilterer) WatchStrategyMultiplierUpdated(opts *bind.WatchOpts, sink chan<- *EOStakeRegistryStrategyMultiplierUpdated, quorumNumber []uint8) (event.Subscription, error) { var quorumNumberRule []interface{} for _, quorumNumberItem := range quorumNumber { quorumNumberRule = append(quorumNumberRule, quorumNumberItem) } - logs, sub, err := _ContractEOStakeRegistry.contract.WatchLogs(opts, "StrategyMultiplierUpdated", quorumNumberRule) + logs, sub, err := _EOStakeRegistry.contract.WatchLogs(opts, "StrategyMultiplierUpdated", quorumNumberRule) if err != nil { return nil, err } @@ -1919,8 +2288,8 @@ func (_ContractEOStakeRegistry *ContractEOStakeRegistryFilterer) WatchStrategyMu select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(ContractEOStakeRegistryStrategyMultiplierUpdated) - if err := _ContractEOStakeRegistry.contract.UnpackLog(event, "StrategyMultiplierUpdated", log); err != nil { + event := new(EOStakeRegistryStrategyMultiplierUpdated) + if err := _EOStakeRegistry.contract.UnpackLog(event, "StrategyMultiplierUpdated", log); err != nil { return err } event.Raw = log @@ -1944,18 +2313,18 @@ func (_ContractEOStakeRegistry *ContractEOStakeRegistryFilterer) WatchStrategyMu // ParseStrategyMultiplierUpdated is a log parse operation binding the contract event 0x11a5641322da1dff56a4b66eaac31ffa465295ece907cd163437793b4d009a75. // // Solidity: event StrategyMultiplierUpdated(uint8 indexed quorumNumber, address strategy, uint256 multiplier) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryFilterer) ParseStrategyMultiplierUpdated(log types.Log) (*ContractEOStakeRegistryStrategyMultiplierUpdated, error) { - event := new(ContractEOStakeRegistryStrategyMultiplierUpdated) - if err := _ContractEOStakeRegistry.contract.UnpackLog(event, "StrategyMultiplierUpdated", log); err != nil { +func (_EOStakeRegistry *EOStakeRegistryFilterer) ParseStrategyMultiplierUpdated(log types.Log) (*EOStakeRegistryStrategyMultiplierUpdated, error) { + event := new(EOStakeRegistryStrategyMultiplierUpdated) + if err := _EOStakeRegistry.contract.UnpackLog(event, "StrategyMultiplierUpdated", log); err != nil { return nil, err } event.Raw = log return event, nil } -// ContractEOStakeRegistryStrategyRemovedFromQuorumIterator is returned from FilterStrategyRemovedFromQuorum and is used to iterate over the raw logs and unpacked data for StrategyRemovedFromQuorum events raised by the ContractEOStakeRegistry contract. -type ContractEOStakeRegistryStrategyRemovedFromQuorumIterator struct { - Event *ContractEOStakeRegistryStrategyRemovedFromQuorum // Event containing the contract specifics and raw log +// EOStakeRegistryStrategyRemovedFromQuorumIterator is returned from FilterStrategyRemovedFromQuorum and is used to iterate over the raw logs and unpacked data for StrategyRemovedFromQuorum events raised by the EOStakeRegistry contract. +type EOStakeRegistryStrategyRemovedFromQuorumIterator struct { + Event *EOStakeRegistryStrategyRemovedFromQuorum // 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 @@ -1969,7 +2338,7 @@ type ContractEOStakeRegistryStrategyRemovedFromQuorumIterator struct { // 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 *ContractEOStakeRegistryStrategyRemovedFromQuorumIterator) Next() bool { +func (it *EOStakeRegistryStrategyRemovedFromQuorumIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -1978,7 +2347,7 @@ func (it *ContractEOStakeRegistryStrategyRemovedFromQuorumIterator) Next() bool if it.done { select { case log := <-it.logs: - it.Event = new(ContractEOStakeRegistryStrategyRemovedFromQuorum) + it.Event = new(EOStakeRegistryStrategyRemovedFromQuorum) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1993,7 +2362,7 @@ func (it *ContractEOStakeRegistryStrategyRemovedFromQuorumIterator) Next() bool // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(ContractEOStakeRegistryStrategyRemovedFromQuorum) + it.Event = new(EOStakeRegistryStrategyRemovedFromQuorum) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -2009,19 +2378,19 @@ func (it *ContractEOStakeRegistryStrategyRemovedFromQuorumIterator) Next() bool } // Error returns any retrieval or parsing error occurred during filtering. -func (it *ContractEOStakeRegistryStrategyRemovedFromQuorumIterator) Error() error { +func (it *EOStakeRegistryStrategyRemovedFromQuorumIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *ContractEOStakeRegistryStrategyRemovedFromQuorumIterator) Close() error { +func (it *EOStakeRegistryStrategyRemovedFromQuorumIterator) Close() error { it.sub.Unsubscribe() return nil } -// ContractEOStakeRegistryStrategyRemovedFromQuorum represents a StrategyRemovedFromQuorum event raised by the ContractEOStakeRegistry contract. -type ContractEOStakeRegistryStrategyRemovedFromQuorum struct { +// EOStakeRegistryStrategyRemovedFromQuorum represents a StrategyRemovedFromQuorum event raised by the EOStakeRegistry contract. +type EOStakeRegistryStrategyRemovedFromQuorum struct { QuorumNumber uint8 Strategy common.Address Raw types.Log // Blockchain specific contextual infos @@ -2030,31 +2399,31 @@ type ContractEOStakeRegistryStrategyRemovedFromQuorum struct { // FilterStrategyRemovedFromQuorum is a free log retrieval operation binding the contract event 0x31fa2e2cd280c9375e13ffcf3d81e2378100186e4058f8d3ddb690b82dcd31f7. // // Solidity: event StrategyRemovedFromQuorum(uint8 indexed quorumNumber, address strategy) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryFilterer) FilterStrategyRemovedFromQuorum(opts *bind.FilterOpts, quorumNumber []uint8) (*ContractEOStakeRegistryStrategyRemovedFromQuorumIterator, error) { +func (_EOStakeRegistry *EOStakeRegistryFilterer) FilterStrategyRemovedFromQuorum(opts *bind.FilterOpts, quorumNumber []uint8) (*EOStakeRegistryStrategyRemovedFromQuorumIterator, error) { var quorumNumberRule []interface{} for _, quorumNumberItem := range quorumNumber { quorumNumberRule = append(quorumNumberRule, quorumNumberItem) } - logs, sub, err := _ContractEOStakeRegistry.contract.FilterLogs(opts, "StrategyRemovedFromQuorum", quorumNumberRule) + logs, sub, err := _EOStakeRegistry.contract.FilterLogs(opts, "StrategyRemovedFromQuorum", quorumNumberRule) if err != nil { return nil, err } - return &ContractEOStakeRegistryStrategyRemovedFromQuorumIterator{contract: _ContractEOStakeRegistry.contract, event: "StrategyRemovedFromQuorum", logs: logs, sub: sub}, nil + return &EOStakeRegistryStrategyRemovedFromQuorumIterator{contract: _EOStakeRegistry.contract, event: "StrategyRemovedFromQuorum", logs: logs, sub: sub}, nil } // WatchStrategyRemovedFromQuorum is a free log subscription operation binding the contract event 0x31fa2e2cd280c9375e13ffcf3d81e2378100186e4058f8d3ddb690b82dcd31f7. // // Solidity: event StrategyRemovedFromQuorum(uint8 indexed quorumNumber, address strategy) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryFilterer) WatchStrategyRemovedFromQuorum(opts *bind.WatchOpts, sink chan<- *ContractEOStakeRegistryStrategyRemovedFromQuorum, quorumNumber []uint8) (event.Subscription, error) { +func (_EOStakeRegistry *EOStakeRegistryFilterer) WatchStrategyRemovedFromQuorum(opts *bind.WatchOpts, sink chan<- *EOStakeRegistryStrategyRemovedFromQuorum, quorumNumber []uint8) (event.Subscription, error) { var quorumNumberRule []interface{} for _, quorumNumberItem := range quorumNumber { quorumNumberRule = append(quorumNumberRule, quorumNumberItem) } - logs, sub, err := _ContractEOStakeRegistry.contract.WatchLogs(opts, "StrategyRemovedFromQuorum", quorumNumberRule) + logs, sub, err := _EOStakeRegistry.contract.WatchLogs(opts, "StrategyRemovedFromQuorum", quorumNumberRule) if err != nil { return nil, err } @@ -2064,8 +2433,8 @@ func (_ContractEOStakeRegistry *ContractEOStakeRegistryFilterer) WatchStrategyRe select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(ContractEOStakeRegistryStrategyRemovedFromQuorum) - if err := _ContractEOStakeRegistry.contract.UnpackLog(event, "StrategyRemovedFromQuorum", log); err != nil { + event := new(EOStakeRegistryStrategyRemovedFromQuorum) + if err := _EOStakeRegistry.contract.UnpackLog(event, "StrategyRemovedFromQuorum", log); err != nil { return err } event.Raw = log @@ -2089,9 +2458,9 @@ func (_ContractEOStakeRegistry *ContractEOStakeRegistryFilterer) WatchStrategyRe // ParseStrategyRemovedFromQuorum is a log parse operation binding the contract event 0x31fa2e2cd280c9375e13ffcf3d81e2378100186e4058f8d3ddb690b82dcd31f7. // // Solidity: event StrategyRemovedFromQuorum(uint8 indexed quorumNumber, address strategy) -func (_ContractEOStakeRegistry *ContractEOStakeRegistryFilterer) ParseStrategyRemovedFromQuorum(log types.Log) (*ContractEOStakeRegistryStrategyRemovedFromQuorum, error) { - event := new(ContractEOStakeRegistryStrategyRemovedFromQuorum) - if err := _ContractEOStakeRegistry.contract.UnpackLog(event, "StrategyRemovedFromQuorum", log); err != nil { +func (_EOStakeRegistry *EOStakeRegistryFilterer) ParseStrategyRemovedFromQuorum(log types.Log) (*EOStakeRegistryStrategyRemovedFromQuorum, error) { + event := new(EOStakeRegistryStrategyRemovedFromQuorum) + if err := _EOStakeRegistry.contract.UnpackLog(event, "StrategyRemovedFromQuorum", log); err != nil { return nil, err } event.Raw = log diff --git a/contracts/bindings/IBLSSignatureChecker/binding.go b/contracts/bindings/IBLSSignatureChecker/binding.go deleted file mode 100644 index 4ca37b6..0000000 --- a/contracts/bindings/IBLSSignatureChecker/binding.go +++ /dev/null @@ -1,544 +0,0 @@ -// Code generated - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package contractIBLSSignatureChecker - -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 -) - -// BN254G1Point is an auto generated low-level Go binding around an user-defined struct. -type BN254G1Point struct { - X *big.Int - Y *big.Int -} - -// BN254G2Point is an auto generated low-level Go binding around an user-defined struct. -type BN254G2Point struct { - X [2]*big.Int - Y [2]*big.Int -} - -// IBLSSignatureCheckerNonSignerStakesAndSignature is an auto generated low-level Go binding around an user-defined struct. -type IBLSSignatureCheckerNonSignerStakesAndSignature struct { - NonSignerQuorumBitmapIndices []uint32 - NonSignerPubkeys []BN254G1Point - QuorumApks []BN254G1Point - ApkG2 BN254G2Point - Sigma BN254G1Point - QuorumApkIndices []uint32 - TotalStakeIndices []uint32 - NonSignerStakeIndices [][]uint32 -} - -// IBLSSignatureCheckerQuorumStakeTotals is an auto generated low-level Go binding around an user-defined struct. -type IBLSSignatureCheckerQuorumStakeTotals struct { - SignedStakeForQuorum []*big.Int - TotalStakeForQuorum []*big.Int -} - -// ContractIBLSSignatureCheckerMetaData contains all meta data concerning the ContractIBLSSignatureChecker contract. -var ContractIBLSSignatureCheckerMetaData = &bind.MetaData{ - ABI: "[{\"type\":\"function\",\"name\":\"blsApkRegistry\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIEOBLSApkRegistry\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"checkSignatures\",\"inputs\":[{\"name\":\"msgHash\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"quorumNumbers\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"referenceBlockNumber\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"nonSignerStakesAndSignature\",\"type\":\"tuple\",\"internalType\":\"structIBLSSignatureChecker.NonSignerStakesAndSignature\",\"components\":[{\"name\":\"nonSignerQuorumBitmapIndices\",\"type\":\"uint32[]\",\"internalType\":\"uint32[]\"},{\"name\":\"nonSignerPubkeys\",\"type\":\"tuple[]\",\"internalType\":\"structBN254.G1Point[]\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"quorumApks\",\"type\":\"tuple[]\",\"internalType\":\"structBN254.G1Point[]\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"apkG2\",\"type\":\"tuple\",\"internalType\":\"structBN254.G2Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256[2]\",\"internalType\":\"uint256[2]\"},{\"name\":\"Y\",\"type\":\"uint256[2]\",\"internalType\":\"uint256[2]\"}]},{\"name\":\"sigma\",\"type\":\"tuple\",\"internalType\":\"structBN254.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"quorumApkIndices\",\"type\":\"uint32[]\",\"internalType\":\"uint32[]\"},{\"name\":\"totalStakeIndices\",\"type\":\"uint32[]\",\"internalType\":\"uint32[]\"},{\"name\":\"nonSignerStakeIndices\",\"type\":\"uint32[][]\",\"internalType\":\"uint32[][]\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structIBLSSignatureChecker.QuorumStakeTotals\",\"components\":[{\"name\":\"signedStakeForQuorum\",\"type\":\"uint96[]\",\"internalType\":\"uint96[]\"},{\"name\":\"totalStakeForQuorum\",\"type\":\"uint96[]\",\"internalType\":\"uint96[]\"}]},{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"delegation\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIDelegationManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"registryCoordinator\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIEORegistryCoordinator\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"stakeRegistry\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIEOStakeRegistry\"}],\"stateMutability\":\"view\"},{\"type\":\"event\",\"name\":\"StaleStakesForbiddenUpdate\",\"inputs\":[{\"name\":\"value\",\"type\":\"bool\",\"indexed\":false,\"internalType\":\"bool\"}],\"anonymous\":false}]", -} - -// ContractIBLSSignatureCheckerABI is the input ABI used to generate the binding from. -// Deprecated: Use ContractIBLSSignatureCheckerMetaData.ABI instead. -var ContractIBLSSignatureCheckerABI = ContractIBLSSignatureCheckerMetaData.ABI - -// ContractIBLSSignatureCheckerMethods is an auto generated interface around an Ethereum contract. -type ContractIBLSSignatureCheckerMethods interface { - ContractIBLSSignatureCheckerCalls - ContractIBLSSignatureCheckerTransacts - ContractIBLSSignatureCheckerFilters -} - -// ContractIBLSSignatureCheckerCalls is an auto generated interface that defines the call methods available for an Ethereum contract. -type ContractIBLSSignatureCheckerCalls interface { - BlsApkRegistry(opts *bind.CallOpts) (common.Address, error) - - CheckSignatures(opts *bind.CallOpts, msgHash [32]byte, quorumNumbers []byte, referenceBlockNumber uint32, nonSignerStakesAndSignature IBLSSignatureCheckerNonSignerStakesAndSignature) (IBLSSignatureCheckerQuorumStakeTotals, [32]byte, error) - - Delegation(opts *bind.CallOpts) (common.Address, error) - - RegistryCoordinator(opts *bind.CallOpts) (common.Address, error) - - StakeRegistry(opts *bind.CallOpts) (common.Address, error) -} - -// ContractIBLSSignatureCheckerTransacts is an auto generated interface that defines the transact methods available for an Ethereum contract. -type ContractIBLSSignatureCheckerTransacts interface { -} - -// ContractIBLSSignatureCheckerFilterer is an auto generated interface that defines the log filtering methods available for an Ethereum contract. -type ContractIBLSSignatureCheckerFilters interface { - FilterStaleStakesForbiddenUpdate(opts *bind.FilterOpts) (*ContractIBLSSignatureCheckerStaleStakesForbiddenUpdateIterator, error) - WatchStaleStakesForbiddenUpdate(opts *bind.WatchOpts, sink chan<- *ContractIBLSSignatureCheckerStaleStakesForbiddenUpdate) (event.Subscription, error) - ParseStaleStakesForbiddenUpdate(log types.Log) (*ContractIBLSSignatureCheckerStaleStakesForbiddenUpdate, error) -} - -// ContractIBLSSignatureChecker is an auto generated Go binding around an Ethereum contract. -type ContractIBLSSignatureChecker struct { - ContractIBLSSignatureCheckerCaller // Read-only binding to the contract - ContractIBLSSignatureCheckerTransactor // Write-only binding to the contract - ContractIBLSSignatureCheckerFilterer // Log filterer for contract events -} - -// ContractIBLSSignatureChecker implements the ContractIBLSSignatureCheckerMethods interface. -var _ ContractIBLSSignatureCheckerMethods = (*ContractIBLSSignatureChecker)(nil) - -// ContractIBLSSignatureCheckerCaller is an auto generated read-only Go binding around an Ethereum contract. -type ContractIBLSSignatureCheckerCaller struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// ContractIBLSSignatureCheckerCaller implements the ContractIBLSSignatureCheckerCalls interface. -var _ ContractIBLSSignatureCheckerCalls = (*ContractIBLSSignatureCheckerCaller)(nil) - -// ContractIBLSSignatureCheckerTransactor is an auto generated write-only Go binding around an Ethereum contract. -type ContractIBLSSignatureCheckerTransactor struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// ContractIBLSSignatureCheckerTransactor implements the ContractIBLSSignatureCheckerTransacts interface. -var _ ContractIBLSSignatureCheckerTransacts = (*ContractIBLSSignatureCheckerTransactor)(nil) - -// ContractIBLSSignatureCheckerFilterer is an auto generated log filtering Go binding around an Ethereum contract events. -type ContractIBLSSignatureCheckerFilterer struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// ContractIBLSSignatureCheckerFilterer implements the ContractIBLSSignatureCheckerFilters interface. -var _ ContractIBLSSignatureCheckerFilters = (*ContractIBLSSignatureCheckerFilterer)(nil) - -// ContractIBLSSignatureCheckerSession is an auto generated Go binding around an Ethereum contract, -// with pre-set call and transact options. -type ContractIBLSSignatureCheckerSession struct { - Contract *ContractIBLSSignatureChecker // 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 -} - -// ContractIBLSSignatureCheckerCallerSession is an auto generated read-only Go binding around an Ethereum contract, -// with pre-set call options. -type ContractIBLSSignatureCheckerCallerSession struct { - Contract *ContractIBLSSignatureCheckerCaller // Generic contract caller binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session -} - -// ContractIBLSSignatureCheckerTransactorSession is an auto generated write-only Go binding around an Ethereum contract, -// with pre-set transact options. -type ContractIBLSSignatureCheckerTransactorSession struct { - Contract *ContractIBLSSignatureCheckerTransactor // Generic contract transactor binding to set the session for - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session -} - -// ContractIBLSSignatureCheckerRaw is an auto generated low-level Go binding around an Ethereum contract. -type ContractIBLSSignatureCheckerRaw struct { - Contract *ContractIBLSSignatureChecker // Generic contract binding to access the raw methods on -} - -// ContractIBLSSignatureCheckerCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. -type ContractIBLSSignatureCheckerCallerRaw struct { - Contract *ContractIBLSSignatureCheckerCaller // Generic read-only contract binding to access the raw methods on -} - -// ContractIBLSSignatureCheckerTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. -type ContractIBLSSignatureCheckerTransactorRaw struct { - Contract *ContractIBLSSignatureCheckerTransactor // Generic write-only contract binding to access the raw methods on -} - -// NewContractIBLSSignatureChecker creates a new instance of ContractIBLSSignatureChecker, bound to a specific deployed contract. -func NewContractIBLSSignatureChecker(address common.Address, backend bind.ContractBackend) (*ContractIBLSSignatureChecker, error) { - contract, err := bindContractIBLSSignatureChecker(address, backend, backend, backend) - if err != nil { - return nil, err - } - return &ContractIBLSSignatureChecker{ContractIBLSSignatureCheckerCaller: ContractIBLSSignatureCheckerCaller{contract: contract}, ContractIBLSSignatureCheckerTransactor: ContractIBLSSignatureCheckerTransactor{contract: contract}, ContractIBLSSignatureCheckerFilterer: ContractIBLSSignatureCheckerFilterer{contract: contract}}, nil -} - -// NewContractIBLSSignatureCheckerCaller creates a new read-only instance of ContractIBLSSignatureChecker, bound to a specific deployed contract. -func NewContractIBLSSignatureCheckerCaller(address common.Address, caller bind.ContractCaller) (*ContractIBLSSignatureCheckerCaller, error) { - contract, err := bindContractIBLSSignatureChecker(address, caller, nil, nil) - if err != nil { - return nil, err - } - return &ContractIBLSSignatureCheckerCaller{contract: contract}, nil -} - -// NewContractIBLSSignatureCheckerTransactor creates a new write-only instance of ContractIBLSSignatureChecker, bound to a specific deployed contract. -func NewContractIBLSSignatureCheckerTransactor(address common.Address, transactor bind.ContractTransactor) (*ContractIBLSSignatureCheckerTransactor, error) { - contract, err := bindContractIBLSSignatureChecker(address, nil, transactor, nil) - if err != nil { - return nil, err - } - return &ContractIBLSSignatureCheckerTransactor{contract: contract}, nil -} - -// NewContractIBLSSignatureCheckerFilterer creates a new log filterer instance of ContractIBLSSignatureChecker, bound to a specific deployed contract. -func NewContractIBLSSignatureCheckerFilterer(address common.Address, filterer bind.ContractFilterer) (*ContractIBLSSignatureCheckerFilterer, error) { - contract, err := bindContractIBLSSignatureChecker(address, nil, nil, filterer) - if err != nil { - return nil, err - } - return &ContractIBLSSignatureCheckerFilterer{contract: contract}, nil -} - -// bindContractIBLSSignatureChecker binds a generic wrapper to an already deployed contract. -func bindContractIBLSSignatureChecker(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { - parsed, err := ContractIBLSSignatureCheckerMetaData.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 (_ContractIBLSSignatureChecker *ContractIBLSSignatureCheckerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _ContractIBLSSignatureChecker.Contract.ContractIBLSSignatureCheckerCaller.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 (_ContractIBLSSignatureChecker *ContractIBLSSignatureCheckerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _ContractIBLSSignatureChecker.Contract.ContractIBLSSignatureCheckerTransactor.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_ContractIBLSSignatureChecker *ContractIBLSSignatureCheckerRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _ContractIBLSSignatureChecker.Contract.ContractIBLSSignatureCheckerTransactor.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 (_ContractIBLSSignatureChecker *ContractIBLSSignatureCheckerCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _ContractIBLSSignatureChecker.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 (_ContractIBLSSignatureChecker *ContractIBLSSignatureCheckerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _ContractIBLSSignatureChecker.Contract.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_ContractIBLSSignatureChecker *ContractIBLSSignatureCheckerTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _ContractIBLSSignatureChecker.Contract.contract.Transact(opts, method, params...) -} - -// BlsApkRegistry is a free data retrieval call binding the contract method 0x5df45946. -// -// Solidity: function blsApkRegistry() view returns(address) -func (_ContractIBLSSignatureChecker *ContractIBLSSignatureCheckerCaller) BlsApkRegistry(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _ContractIBLSSignatureChecker.contract.Call(opts, &out, "blsApkRegistry") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// BlsApkRegistry is a free data retrieval call binding the contract method 0x5df45946. -// -// Solidity: function blsApkRegistry() view returns(address) -func (_ContractIBLSSignatureChecker *ContractIBLSSignatureCheckerSession) BlsApkRegistry() (common.Address, error) { - return _ContractIBLSSignatureChecker.Contract.BlsApkRegistry(&_ContractIBLSSignatureChecker.CallOpts) -} - -// BlsApkRegistry is a free data retrieval call binding the contract method 0x5df45946. -// -// Solidity: function blsApkRegistry() view returns(address) -func (_ContractIBLSSignatureChecker *ContractIBLSSignatureCheckerCallerSession) BlsApkRegistry() (common.Address, error) { - return _ContractIBLSSignatureChecker.Contract.BlsApkRegistry(&_ContractIBLSSignatureChecker.CallOpts) -} - -// CheckSignatures is a free data retrieval call binding the contract method 0x6efb4636. -// -// Solidity: function checkSignatures(bytes32 msgHash, bytes quorumNumbers, uint32 referenceBlockNumber, (uint32[],(uint256,uint256)[],(uint256,uint256)[],(uint256[2],uint256[2]),(uint256,uint256),uint32[],uint32[],uint32[][]) nonSignerStakesAndSignature) view returns((uint96[],uint96[]), bytes32) -func (_ContractIBLSSignatureChecker *ContractIBLSSignatureCheckerCaller) CheckSignatures(opts *bind.CallOpts, msgHash [32]byte, quorumNumbers []byte, referenceBlockNumber uint32, nonSignerStakesAndSignature IBLSSignatureCheckerNonSignerStakesAndSignature) (IBLSSignatureCheckerQuorumStakeTotals, [32]byte, error) { - var out []interface{} - err := _ContractIBLSSignatureChecker.contract.Call(opts, &out, "checkSignatures", msgHash, quorumNumbers, referenceBlockNumber, nonSignerStakesAndSignature) - - if err != nil { - return *new(IBLSSignatureCheckerQuorumStakeTotals), *new([32]byte), err - } - - out0 := *abi.ConvertType(out[0], new(IBLSSignatureCheckerQuorumStakeTotals)).(*IBLSSignatureCheckerQuorumStakeTotals) - out1 := *abi.ConvertType(out[1], new([32]byte)).(*[32]byte) - - return out0, out1, err - -} - -// CheckSignatures is a free data retrieval call binding the contract method 0x6efb4636. -// -// Solidity: function checkSignatures(bytes32 msgHash, bytes quorumNumbers, uint32 referenceBlockNumber, (uint32[],(uint256,uint256)[],(uint256,uint256)[],(uint256[2],uint256[2]),(uint256,uint256),uint32[],uint32[],uint32[][]) nonSignerStakesAndSignature) view returns((uint96[],uint96[]), bytes32) -func (_ContractIBLSSignatureChecker *ContractIBLSSignatureCheckerSession) CheckSignatures(msgHash [32]byte, quorumNumbers []byte, referenceBlockNumber uint32, nonSignerStakesAndSignature IBLSSignatureCheckerNonSignerStakesAndSignature) (IBLSSignatureCheckerQuorumStakeTotals, [32]byte, error) { - return _ContractIBLSSignatureChecker.Contract.CheckSignatures(&_ContractIBLSSignatureChecker.CallOpts, msgHash, quorumNumbers, referenceBlockNumber, nonSignerStakesAndSignature) -} - -// CheckSignatures is a free data retrieval call binding the contract method 0x6efb4636. -// -// Solidity: function checkSignatures(bytes32 msgHash, bytes quorumNumbers, uint32 referenceBlockNumber, (uint32[],(uint256,uint256)[],(uint256,uint256)[],(uint256[2],uint256[2]),(uint256,uint256),uint32[],uint32[],uint32[][]) nonSignerStakesAndSignature) view returns((uint96[],uint96[]), bytes32) -func (_ContractIBLSSignatureChecker *ContractIBLSSignatureCheckerCallerSession) CheckSignatures(msgHash [32]byte, quorumNumbers []byte, referenceBlockNumber uint32, nonSignerStakesAndSignature IBLSSignatureCheckerNonSignerStakesAndSignature) (IBLSSignatureCheckerQuorumStakeTotals, [32]byte, error) { - return _ContractIBLSSignatureChecker.Contract.CheckSignatures(&_ContractIBLSSignatureChecker.CallOpts, msgHash, quorumNumbers, referenceBlockNumber, nonSignerStakesAndSignature) -} - -// Delegation is a free data retrieval call binding the contract method 0xdf5cf723. -// -// Solidity: function delegation() view returns(address) -func (_ContractIBLSSignatureChecker *ContractIBLSSignatureCheckerCaller) Delegation(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _ContractIBLSSignatureChecker.contract.Call(opts, &out, "delegation") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// Delegation is a free data retrieval call binding the contract method 0xdf5cf723. -// -// Solidity: function delegation() view returns(address) -func (_ContractIBLSSignatureChecker *ContractIBLSSignatureCheckerSession) Delegation() (common.Address, error) { - return _ContractIBLSSignatureChecker.Contract.Delegation(&_ContractIBLSSignatureChecker.CallOpts) -} - -// Delegation is a free data retrieval call binding the contract method 0xdf5cf723. -// -// Solidity: function delegation() view returns(address) -func (_ContractIBLSSignatureChecker *ContractIBLSSignatureCheckerCallerSession) Delegation() (common.Address, error) { - return _ContractIBLSSignatureChecker.Contract.Delegation(&_ContractIBLSSignatureChecker.CallOpts) -} - -// RegistryCoordinator is a free data retrieval call binding the contract method 0x6d14a987. -// -// Solidity: function registryCoordinator() view returns(address) -func (_ContractIBLSSignatureChecker *ContractIBLSSignatureCheckerCaller) RegistryCoordinator(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _ContractIBLSSignatureChecker.contract.Call(opts, &out, "registryCoordinator") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// RegistryCoordinator is a free data retrieval call binding the contract method 0x6d14a987. -// -// Solidity: function registryCoordinator() view returns(address) -func (_ContractIBLSSignatureChecker *ContractIBLSSignatureCheckerSession) RegistryCoordinator() (common.Address, error) { - return _ContractIBLSSignatureChecker.Contract.RegistryCoordinator(&_ContractIBLSSignatureChecker.CallOpts) -} - -// RegistryCoordinator is a free data retrieval call binding the contract method 0x6d14a987. -// -// Solidity: function registryCoordinator() view returns(address) -func (_ContractIBLSSignatureChecker *ContractIBLSSignatureCheckerCallerSession) RegistryCoordinator() (common.Address, error) { - return _ContractIBLSSignatureChecker.Contract.RegistryCoordinator(&_ContractIBLSSignatureChecker.CallOpts) -} - -// StakeRegistry is a free data retrieval call binding the contract method 0x68304835. -// -// Solidity: function stakeRegistry() view returns(address) -func (_ContractIBLSSignatureChecker *ContractIBLSSignatureCheckerCaller) StakeRegistry(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _ContractIBLSSignatureChecker.contract.Call(opts, &out, "stakeRegistry") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// StakeRegistry is a free data retrieval call binding the contract method 0x68304835. -// -// Solidity: function stakeRegistry() view returns(address) -func (_ContractIBLSSignatureChecker *ContractIBLSSignatureCheckerSession) StakeRegistry() (common.Address, error) { - return _ContractIBLSSignatureChecker.Contract.StakeRegistry(&_ContractIBLSSignatureChecker.CallOpts) -} - -// StakeRegistry is a free data retrieval call binding the contract method 0x68304835. -// -// Solidity: function stakeRegistry() view returns(address) -func (_ContractIBLSSignatureChecker *ContractIBLSSignatureCheckerCallerSession) StakeRegistry() (common.Address, error) { - return _ContractIBLSSignatureChecker.Contract.StakeRegistry(&_ContractIBLSSignatureChecker.CallOpts) -} - -// ContractIBLSSignatureCheckerStaleStakesForbiddenUpdateIterator is returned from FilterStaleStakesForbiddenUpdate and is used to iterate over the raw logs and unpacked data for StaleStakesForbiddenUpdate events raised by the ContractIBLSSignatureChecker contract. -type ContractIBLSSignatureCheckerStaleStakesForbiddenUpdateIterator struct { - Event *ContractIBLSSignatureCheckerStaleStakesForbiddenUpdate // 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 *ContractIBLSSignatureCheckerStaleStakesForbiddenUpdateIterator) 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(ContractIBLSSignatureCheckerStaleStakesForbiddenUpdate) - 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(ContractIBLSSignatureCheckerStaleStakesForbiddenUpdate) - 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 *ContractIBLSSignatureCheckerStaleStakesForbiddenUpdateIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ContractIBLSSignatureCheckerStaleStakesForbiddenUpdateIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ContractIBLSSignatureCheckerStaleStakesForbiddenUpdate represents a StaleStakesForbiddenUpdate event raised by the ContractIBLSSignatureChecker contract. -type ContractIBLSSignatureCheckerStaleStakesForbiddenUpdate struct { - Value bool - Raw types.Log // Blockchain specific contextual infos -} - -// FilterStaleStakesForbiddenUpdate is a free log retrieval operation binding the contract event 0x40e4ed880a29e0f6ddce307457fb75cddf4feef7d3ecb0301bfdf4976a0e2dfc. -// -// Solidity: event StaleStakesForbiddenUpdate(bool value) -func (_ContractIBLSSignatureChecker *ContractIBLSSignatureCheckerFilterer) FilterStaleStakesForbiddenUpdate(opts *bind.FilterOpts) (*ContractIBLSSignatureCheckerStaleStakesForbiddenUpdateIterator, error) { - - logs, sub, err := _ContractIBLSSignatureChecker.contract.FilterLogs(opts, "StaleStakesForbiddenUpdate") - if err != nil { - return nil, err - } - return &ContractIBLSSignatureCheckerStaleStakesForbiddenUpdateIterator{contract: _ContractIBLSSignatureChecker.contract, event: "StaleStakesForbiddenUpdate", logs: logs, sub: sub}, nil -} - -// WatchStaleStakesForbiddenUpdate is a free log subscription operation binding the contract event 0x40e4ed880a29e0f6ddce307457fb75cddf4feef7d3ecb0301bfdf4976a0e2dfc. -// -// Solidity: event StaleStakesForbiddenUpdate(bool value) -func (_ContractIBLSSignatureChecker *ContractIBLSSignatureCheckerFilterer) WatchStaleStakesForbiddenUpdate(opts *bind.WatchOpts, sink chan<- *ContractIBLSSignatureCheckerStaleStakesForbiddenUpdate) (event.Subscription, error) { - - logs, sub, err := _ContractIBLSSignatureChecker.contract.WatchLogs(opts, "StaleStakesForbiddenUpdate") - 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(ContractIBLSSignatureCheckerStaleStakesForbiddenUpdate) - if err := _ContractIBLSSignatureChecker.contract.UnpackLog(event, "StaleStakesForbiddenUpdate", 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 -} - -// ParseStaleStakesForbiddenUpdate is a log parse operation binding the contract event 0x40e4ed880a29e0f6ddce307457fb75cddf4feef7d3ecb0301bfdf4976a0e2dfc. -// -// Solidity: event StaleStakesForbiddenUpdate(bool value) -func (_ContractIBLSSignatureChecker *ContractIBLSSignatureCheckerFilterer) ParseStaleStakesForbiddenUpdate(log types.Log) (*ContractIBLSSignatureCheckerStaleStakesForbiddenUpdate, error) { - event := new(ContractIBLSSignatureCheckerStaleStakesForbiddenUpdate) - if err := _ContractIBLSSignatureChecker.contract.UnpackLog(event, "StaleStakesForbiddenUpdate", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} diff --git a/contracts/bindings/IERC20/binding.go b/contracts/bindings/IERC20/binding.go deleted file mode 100644 index 1a7e9da..0000000 --- a/contracts/bindings/IERC20/binding.go +++ /dev/null @@ -1,693 +0,0 @@ -// Code generated - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package contractIERC20 - -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 -) - -// ContractIERC20MetaData contains all meta data concerning the ContractIERC20 contract. -var ContractIERC20MetaData = &bind.MetaData{ - ABI: "[{\"type\":\"function\",\"name\":\"allowance\",\"inputs\":[{\"name\":\"owner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"spender\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"approve\",\"inputs\":[{\"name\":\"spender\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"balanceOf\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"totalSupply\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"transfer\",\"inputs\":[{\"name\":\"to\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"transferFrom\",\"inputs\":[{\"name\":\"from\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"to\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"Approval\",\"inputs\":[{\"name\":\"owner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"spender\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"value\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Transfer\",\"inputs\":[{\"name\":\"from\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"to\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"value\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false}]", -} - -// ContractIERC20ABI is the input ABI used to generate the binding from. -// Deprecated: Use ContractIERC20MetaData.ABI instead. -var ContractIERC20ABI = ContractIERC20MetaData.ABI - -// ContractIERC20Methods is an auto generated interface around an Ethereum contract. -type ContractIERC20Methods interface { - ContractIERC20Calls - ContractIERC20Transacts - ContractIERC20Filters -} - -// ContractIERC20Calls is an auto generated interface that defines the call methods available for an Ethereum contract. -type ContractIERC20Calls interface { - Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) - - BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) - - TotalSupply(opts *bind.CallOpts) (*big.Int, error) -} - -// ContractIERC20Transacts is an auto generated interface that defines the transact methods available for an Ethereum contract. -type ContractIERC20Transacts interface { - Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) - - Transfer(opts *bind.TransactOpts, to common.Address, amount *big.Int) (*types.Transaction, error) - - TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) -} - -// ContractIERC20Filterer is an auto generated interface that defines the log filtering methods available for an Ethereum contract. -type ContractIERC20Filters interface { - FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*ContractIERC20ApprovalIterator, error) - WatchApproval(opts *bind.WatchOpts, sink chan<- *ContractIERC20Approval, owner []common.Address, spender []common.Address) (event.Subscription, error) - ParseApproval(log types.Log) (*ContractIERC20Approval, error) - - FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*ContractIERC20TransferIterator, error) - WatchTransfer(opts *bind.WatchOpts, sink chan<- *ContractIERC20Transfer, from []common.Address, to []common.Address) (event.Subscription, error) - ParseTransfer(log types.Log) (*ContractIERC20Transfer, error) -} - -// ContractIERC20 is an auto generated Go binding around an Ethereum contract. -type ContractIERC20 struct { - ContractIERC20Caller // Read-only binding to the contract - ContractIERC20Transactor // Write-only binding to the contract - ContractIERC20Filterer // Log filterer for contract events -} - -// ContractIERC20 implements the ContractIERC20Methods interface. -var _ ContractIERC20Methods = (*ContractIERC20)(nil) - -// ContractIERC20Caller is an auto generated read-only Go binding around an Ethereum contract. -type ContractIERC20Caller struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// ContractIERC20Caller implements the ContractIERC20Calls interface. -var _ ContractIERC20Calls = (*ContractIERC20Caller)(nil) - -// ContractIERC20Transactor is an auto generated write-only Go binding around an Ethereum contract. -type ContractIERC20Transactor struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// ContractIERC20Transactor implements the ContractIERC20Transacts interface. -var _ ContractIERC20Transacts = (*ContractIERC20Transactor)(nil) - -// ContractIERC20Filterer is an auto generated log filtering Go binding around an Ethereum contract events. -type ContractIERC20Filterer struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// ContractIERC20Filterer implements the ContractIERC20Filters interface. -var _ ContractIERC20Filters = (*ContractIERC20Filterer)(nil) - -// ContractIERC20Session is an auto generated Go binding around an Ethereum contract, -// with pre-set call and transact options. -type ContractIERC20Session struct { - Contract *ContractIERC20 // 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 -} - -// ContractIERC20CallerSession is an auto generated read-only Go binding around an Ethereum contract, -// with pre-set call options. -type ContractIERC20CallerSession struct { - Contract *ContractIERC20Caller // Generic contract caller binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session -} - -// ContractIERC20TransactorSession is an auto generated write-only Go binding around an Ethereum contract, -// with pre-set transact options. -type ContractIERC20TransactorSession struct { - Contract *ContractIERC20Transactor // Generic contract transactor binding to set the session for - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session -} - -// ContractIERC20Raw is an auto generated low-level Go binding around an Ethereum contract. -type ContractIERC20Raw struct { - Contract *ContractIERC20 // Generic contract binding to access the raw methods on -} - -// ContractIERC20CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. -type ContractIERC20CallerRaw struct { - Contract *ContractIERC20Caller // Generic read-only contract binding to access the raw methods on -} - -// ContractIERC20TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. -type ContractIERC20TransactorRaw struct { - Contract *ContractIERC20Transactor // Generic write-only contract binding to access the raw methods on -} - -// NewContractIERC20 creates a new instance of ContractIERC20, bound to a specific deployed contract. -func NewContractIERC20(address common.Address, backend bind.ContractBackend) (*ContractIERC20, error) { - contract, err := bindContractIERC20(address, backend, backend, backend) - if err != nil { - return nil, err - } - return &ContractIERC20{ContractIERC20Caller: ContractIERC20Caller{contract: contract}, ContractIERC20Transactor: ContractIERC20Transactor{contract: contract}, ContractIERC20Filterer: ContractIERC20Filterer{contract: contract}}, nil -} - -// NewContractIERC20Caller creates a new read-only instance of ContractIERC20, bound to a specific deployed contract. -func NewContractIERC20Caller(address common.Address, caller bind.ContractCaller) (*ContractIERC20Caller, error) { - contract, err := bindContractIERC20(address, caller, nil, nil) - if err != nil { - return nil, err - } - return &ContractIERC20Caller{contract: contract}, nil -} - -// NewContractIERC20Transactor creates a new write-only instance of ContractIERC20, bound to a specific deployed contract. -func NewContractIERC20Transactor(address common.Address, transactor bind.ContractTransactor) (*ContractIERC20Transactor, error) { - contract, err := bindContractIERC20(address, nil, transactor, nil) - if err != nil { - return nil, err - } - return &ContractIERC20Transactor{contract: contract}, nil -} - -// NewContractIERC20Filterer creates a new log filterer instance of ContractIERC20, bound to a specific deployed contract. -func NewContractIERC20Filterer(address common.Address, filterer bind.ContractFilterer) (*ContractIERC20Filterer, error) { - contract, err := bindContractIERC20(address, nil, nil, filterer) - if err != nil { - return nil, err - } - return &ContractIERC20Filterer{contract: contract}, nil -} - -// bindContractIERC20 binds a generic wrapper to an already deployed contract. -func bindContractIERC20(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { - parsed, err := ContractIERC20MetaData.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 (_ContractIERC20 *ContractIERC20Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _ContractIERC20.Contract.ContractIERC20Caller.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 (_ContractIERC20 *ContractIERC20Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _ContractIERC20.Contract.ContractIERC20Transactor.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_ContractIERC20 *ContractIERC20Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _ContractIERC20.Contract.ContractIERC20Transactor.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 (_ContractIERC20 *ContractIERC20CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _ContractIERC20.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 (_ContractIERC20 *ContractIERC20TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _ContractIERC20.Contract.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_ContractIERC20 *ContractIERC20TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _ContractIERC20.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 (_ContractIERC20 *ContractIERC20Caller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) { - var out []interface{} - err := _ContractIERC20.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 (_ContractIERC20 *ContractIERC20Session) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { - return _ContractIERC20.Contract.Allowance(&_ContractIERC20.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 (_ContractIERC20 *ContractIERC20CallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { - return _ContractIERC20.Contract.Allowance(&_ContractIERC20.CallOpts, owner, spender) -} - -// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. -// -// Solidity: function balanceOf(address account) view returns(uint256) -func (_ContractIERC20 *ContractIERC20Caller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) { - var out []interface{} - err := _ContractIERC20.contract.Call(opts, &out, "balanceOf", account) - - 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 account) view returns(uint256) -func (_ContractIERC20 *ContractIERC20Session) BalanceOf(account common.Address) (*big.Int, error) { - return _ContractIERC20.Contract.BalanceOf(&_ContractIERC20.CallOpts, account) -} - -// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. -// -// Solidity: function balanceOf(address account) view returns(uint256) -func (_ContractIERC20 *ContractIERC20CallerSession) BalanceOf(account common.Address) (*big.Int, error) { - return _ContractIERC20.Contract.BalanceOf(&_ContractIERC20.CallOpts, account) -} - -// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. -// -// Solidity: function totalSupply() view returns(uint256) -func (_ContractIERC20 *ContractIERC20Caller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { - var out []interface{} - err := _ContractIERC20.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 (_ContractIERC20 *ContractIERC20Session) TotalSupply() (*big.Int, error) { - return _ContractIERC20.Contract.TotalSupply(&_ContractIERC20.CallOpts) -} - -// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. -// -// Solidity: function totalSupply() view returns(uint256) -func (_ContractIERC20 *ContractIERC20CallerSession) TotalSupply() (*big.Int, error) { - return _ContractIERC20.Contract.TotalSupply(&_ContractIERC20.CallOpts) -} - -// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. -// -// Solidity: function approve(address spender, uint256 amount) returns(bool) -func (_ContractIERC20 *ContractIERC20Transactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) { - return _ContractIERC20.contract.Transact(opts, "approve", spender, amount) -} - -// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. -// -// Solidity: function approve(address spender, uint256 amount) returns(bool) -func (_ContractIERC20 *ContractIERC20Session) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { - return _ContractIERC20.Contract.Approve(&_ContractIERC20.TransactOpts, spender, amount) -} - -// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. -// -// Solidity: function approve(address spender, uint256 amount) returns(bool) -func (_ContractIERC20 *ContractIERC20TransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { - return _ContractIERC20.Contract.Approve(&_ContractIERC20.TransactOpts, spender, amount) -} - -// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. -// -// Solidity: function transfer(address to, uint256 amount) returns(bool) -func (_ContractIERC20 *ContractIERC20Transactor) Transfer(opts *bind.TransactOpts, to common.Address, amount *big.Int) (*types.Transaction, error) { - return _ContractIERC20.contract.Transact(opts, "transfer", to, amount) -} - -// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. -// -// Solidity: function transfer(address to, uint256 amount) returns(bool) -func (_ContractIERC20 *ContractIERC20Session) Transfer(to common.Address, amount *big.Int) (*types.Transaction, error) { - return _ContractIERC20.Contract.Transfer(&_ContractIERC20.TransactOpts, to, amount) -} - -// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. -// -// Solidity: function transfer(address to, uint256 amount) returns(bool) -func (_ContractIERC20 *ContractIERC20TransactorSession) Transfer(to common.Address, amount *big.Int) (*types.Transaction, error) { - return _ContractIERC20.Contract.Transfer(&_ContractIERC20.TransactOpts, to, amount) -} - -// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. -// -// Solidity: function transferFrom(address from, address to, uint256 amount) returns(bool) -func (_ContractIERC20 *ContractIERC20Transactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) { - return _ContractIERC20.contract.Transact(opts, "transferFrom", from, to, amount) -} - -// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. -// -// Solidity: function transferFrom(address from, address to, uint256 amount) returns(bool) -func (_ContractIERC20 *ContractIERC20Session) TransferFrom(from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) { - return _ContractIERC20.Contract.TransferFrom(&_ContractIERC20.TransactOpts, from, to, amount) -} - -// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. -// -// Solidity: function transferFrom(address from, address to, uint256 amount) returns(bool) -func (_ContractIERC20 *ContractIERC20TransactorSession) TransferFrom(from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) { - return _ContractIERC20.Contract.TransferFrom(&_ContractIERC20.TransactOpts, from, to, amount) -} - -// ContractIERC20ApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the ContractIERC20 contract. -type ContractIERC20ApprovalIterator struct { - Event *ContractIERC20Approval // 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 *ContractIERC20ApprovalIterator) 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(ContractIERC20Approval) - 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(ContractIERC20Approval) - 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 *ContractIERC20ApprovalIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ContractIERC20ApprovalIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ContractIERC20Approval represents a Approval event raised by the ContractIERC20 contract. -type ContractIERC20Approval 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 (_ContractIERC20 *ContractIERC20Filterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*ContractIERC20ApprovalIterator, 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 := _ContractIERC20.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule) - if err != nil { - return nil, err - } - return &ContractIERC20ApprovalIterator{contract: _ContractIERC20.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 (_ContractIERC20 *ContractIERC20Filterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ContractIERC20Approval, 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 := _ContractIERC20.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(ContractIERC20Approval) - if err := _ContractIERC20.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 (_ContractIERC20 *ContractIERC20Filterer) ParseApproval(log types.Log) (*ContractIERC20Approval, error) { - event := new(ContractIERC20Approval) - if err := _ContractIERC20.contract.UnpackLog(event, "Approval", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ContractIERC20TransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the ContractIERC20 contract. -type ContractIERC20TransferIterator struct { - Event *ContractIERC20Transfer // 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 *ContractIERC20TransferIterator) 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(ContractIERC20Transfer) - 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(ContractIERC20Transfer) - 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 *ContractIERC20TransferIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ContractIERC20TransferIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ContractIERC20Transfer represents a Transfer event raised by the ContractIERC20 contract. -type ContractIERC20Transfer 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 (_ContractIERC20 *ContractIERC20Filterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*ContractIERC20TransferIterator, 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 := _ContractIERC20.contract.FilterLogs(opts, "Transfer", fromRule, toRule) - if err != nil { - return nil, err - } - return &ContractIERC20TransferIterator{contract: _ContractIERC20.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 (_ContractIERC20 *ContractIERC20Filterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ContractIERC20Transfer, 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 := _ContractIERC20.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(ContractIERC20Transfer) - if err := _ContractIERC20.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 (_ContractIERC20 *ContractIERC20Filterer) ParseTransfer(log types.Log) (*ContractIERC20Transfer, error) { - event := new(ContractIERC20Transfer) - if err := _ContractIERC20.contract.UnpackLog(event, "Transfer", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} diff --git a/contracts/bindings/ISlasher/binding.go b/contracts/bindings/ISlasher/binding.go deleted file mode 100644 index 153a5d4..0000000 --- a/contracts/bindings/ISlasher/binding.go +++ /dev/null @@ -1,1568 +0,0 @@ -// Code generated - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package contractISlasher - -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 -) - -// ISlasherMiddlewareTimes is an auto generated low-level Go binding around an user-defined struct. -type ISlasherMiddlewareTimes struct { - StalestUpdateBlock uint32 - LatestServeUntilBlock uint32 -} - -// ContractISlasherMetaData contains all meta data concerning the ContractISlasher contract. -var ContractISlasherMetaData = &bind.MetaData{ - ABI: "[{\"type\":\"function\",\"name\":\"canSlash\",\"inputs\":[{\"name\":\"toBeSlashed\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"slashingContract\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"canWithdraw\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"withdrawalStartBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"middlewareTimesIndex\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"contractCanSlashOperatorUntilBlock\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"serviceContract\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"delegation\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIDelegationManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"freezeOperator\",\"inputs\":[{\"name\":\"toBeFrozen\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"getCorrectValueForInsertAfter\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"updateBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getMiddlewareTimesIndexServeUntilBlock\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"index\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getMiddlewareTimesIndexStalestUpdateBlock\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"index\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"isFrozen\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"latestUpdateBlock\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"serviceContract\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"middlewareTimesLength\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"operatorToMiddlewareTimes\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"arrayIndex\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structISlasher.MiddlewareTimes\",\"components\":[{\"name\":\"stalestUpdateBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"latestServeUntilBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"operatorWhitelistedContractsLinkedListEntry\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"node\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"},{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"operatorWhitelistedContractsLinkedListSize\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"optIntoSlashing\",\"inputs\":[{\"name\":\"contractAddress\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"recordFirstStakeUpdate\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"serveUntilBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"recordLastStakeUpdateAndRevokeSlashingAbility\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"serveUntilBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"recordStakeUpdate\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"updateBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"serveUntilBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"insertAfter\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"resetFrozenStatus\",\"inputs\":[{\"name\":\"frozenAddresses\",\"type\":\"address[]\",\"internalType\":\"address[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"strategyManager\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIStrategyManager\"}],\"stateMutability\":\"view\"},{\"type\":\"event\",\"name\":\"FrozenStatusReset\",\"inputs\":[{\"name\":\"previouslySlashedAddress\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"MiddlewareTimesAdded\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"index\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"},{\"name\":\"stalestUpdateBlock\",\"type\":\"uint32\",\"indexed\":false,\"internalType\":\"uint32\"},{\"name\":\"latestServeUntilBlock\",\"type\":\"uint32\",\"indexed\":false,\"internalType\":\"uint32\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorFrozen\",\"inputs\":[{\"name\":\"slashedOperator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"slashingContract\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OptedIntoSlashing\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"contractAddress\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"SlashingAbilityRevoked\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"contractAddress\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"contractCanSlashOperatorUntilBlock\",\"type\":\"uint32\",\"indexed\":false,\"internalType\":\"uint32\"}],\"anonymous\":false}]", -} - -// ContractISlasherABI is the input ABI used to generate the binding from. -// Deprecated: Use ContractISlasherMetaData.ABI instead. -var ContractISlasherABI = ContractISlasherMetaData.ABI - -// ContractISlasherMethods is an auto generated interface around an Ethereum contract. -type ContractISlasherMethods interface { - ContractISlasherCalls - ContractISlasherTransacts - ContractISlasherFilters -} - -// ContractISlasherCalls is an auto generated interface that defines the call methods available for an Ethereum contract. -type ContractISlasherCalls interface { - CanSlash(opts *bind.CallOpts, toBeSlashed common.Address, slashingContract common.Address) (bool, error) - - ContractCanSlashOperatorUntilBlock(opts *bind.CallOpts, operator common.Address, serviceContract common.Address) (uint32, error) - - Delegation(opts *bind.CallOpts) (common.Address, error) - - GetCorrectValueForInsertAfter(opts *bind.CallOpts, operator common.Address, updateBlock uint32) (*big.Int, error) - - GetMiddlewareTimesIndexServeUntilBlock(opts *bind.CallOpts, operator common.Address, index uint32) (uint32, error) - - GetMiddlewareTimesIndexStalestUpdateBlock(opts *bind.CallOpts, operator common.Address, index uint32) (uint32, error) - - IsFrozen(opts *bind.CallOpts, staker common.Address) (bool, error) - - LatestUpdateBlock(opts *bind.CallOpts, operator common.Address, serviceContract common.Address) (uint32, error) - - MiddlewareTimesLength(opts *bind.CallOpts, operator common.Address) (*big.Int, error) - - OperatorToMiddlewareTimes(opts *bind.CallOpts, operator common.Address, arrayIndex *big.Int) (ISlasherMiddlewareTimes, error) - - OperatorWhitelistedContractsLinkedListEntry(opts *bind.CallOpts, operator common.Address, node common.Address) (bool, *big.Int, *big.Int, error) - - OperatorWhitelistedContractsLinkedListSize(opts *bind.CallOpts, operator common.Address) (*big.Int, error) - - StrategyManager(opts *bind.CallOpts) (common.Address, error) -} - -// ContractISlasherTransacts is an auto generated interface that defines the transact methods available for an Ethereum contract. -type ContractISlasherTransacts interface { - CanWithdraw(opts *bind.TransactOpts, operator common.Address, withdrawalStartBlock uint32, middlewareTimesIndex *big.Int) (*types.Transaction, error) - - FreezeOperator(opts *bind.TransactOpts, toBeFrozen common.Address) (*types.Transaction, error) - - OptIntoSlashing(opts *bind.TransactOpts, contractAddress common.Address) (*types.Transaction, error) - - RecordFirstStakeUpdate(opts *bind.TransactOpts, operator common.Address, serveUntilBlock uint32) (*types.Transaction, error) - - RecordLastStakeUpdateAndRevokeSlashingAbility(opts *bind.TransactOpts, operator common.Address, serveUntilBlock uint32) (*types.Transaction, error) - - RecordStakeUpdate(opts *bind.TransactOpts, operator common.Address, updateBlock uint32, serveUntilBlock uint32, insertAfter *big.Int) (*types.Transaction, error) - - ResetFrozenStatus(opts *bind.TransactOpts, frozenAddresses []common.Address) (*types.Transaction, error) -} - -// ContractISlasherFilterer is an auto generated interface that defines the log filtering methods available for an Ethereum contract. -type ContractISlasherFilters interface { - FilterFrozenStatusReset(opts *bind.FilterOpts, previouslySlashedAddress []common.Address) (*ContractISlasherFrozenStatusResetIterator, error) - WatchFrozenStatusReset(opts *bind.WatchOpts, sink chan<- *ContractISlasherFrozenStatusReset, previouslySlashedAddress []common.Address) (event.Subscription, error) - ParseFrozenStatusReset(log types.Log) (*ContractISlasherFrozenStatusReset, error) - - FilterMiddlewareTimesAdded(opts *bind.FilterOpts) (*ContractISlasherMiddlewareTimesAddedIterator, error) - WatchMiddlewareTimesAdded(opts *bind.WatchOpts, sink chan<- *ContractISlasherMiddlewareTimesAdded) (event.Subscription, error) - ParseMiddlewareTimesAdded(log types.Log) (*ContractISlasherMiddlewareTimesAdded, error) - - FilterOperatorFrozen(opts *bind.FilterOpts, slashedOperator []common.Address, slashingContract []common.Address) (*ContractISlasherOperatorFrozenIterator, error) - WatchOperatorFrozen(opts *bind.WatchOpts, sink chan<- *ContractISlasherOperatorFrozen, slashedOperator []common.Address, slashingContract []common.Address) (event.Subscription, error) - ParseOperatorFrozen(log types.Log) (*ContractISlasherOperatorFrozen, error) - - FilterOptedIntoSlashing(opts *bind.FilterOpts, operator []common.Address, contractAddress []common.Address) (*ContractISlasherOptedIntoSlashingIterator, error) - WatchOptedIntoSlashing(opts *bind.WatchOpts, sink chan<- *ContractISlasherOptedIntoSlashing, operator []common.Address, contractAddress []common.Address) (event.Subscription, error) - ParseOptedIntoSlashing(log types.Log) (*ContractISlasherOptedIntoSlashing, error) - - FilterSlashingAbilityRevoked(opts *bind.FilterOpts, operator []common.Address, contractAddress []common.Address) (*ContractISlasherSlashingAbilityRevokedIterator, error) - WatchSlashingAbilityRevoked(opts *bind.WatchOpts, sink chan<- *ContractISlasherSlashingAbilityRevoked, operator []common.Address, contractAddress []common.Address) (event.Subscription, error) - ParseSlashingAbilityRevoked(log types.Log) (*ContractISlasherSlashingAbilityRevoked, error) -} - -// ContractISlasher is an auto generated Go binding around an Ethereum contract. -type ContractISlasher struct { - ContractISlasherCaller // Read-only binding to the contract - ContractISlasherTransactor // Write-only binding to the contract - ContractISlasherFilterer // Log filterer for contract events -} - -// ContractISlasher implements the ContractISlasherMethods interface. -var _ ContractISlasherMethods = (*ContractISlasher)(nil) - -// ContractISlasherCaller is an auto generated read-only Go binding around an Ethereum contract. -type ContractISlasherCaller struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// ContractISlasherCaller implements the ContractISlasherCalls interface. -var _ ContractISlasherCalls = (*ContractISlasherCaller)(nil) - -// ContractISlasherTransactor is an auto generated write-only Go binding around an Ethereum contract. -type ContractISlasherTransactor struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// ContractISlasherTransactor implements the ContractISlasherTransacts interface. -var _ ContractISlasherTransacts = (*ContractISlasherTransactor)(nil) - -// ContractISlasherFilterer is an auto generated log filtering Go binding around an Ethereum contract events. -type ContractISlasherFilterer struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// ContractISlasherFilterer implements the ContractISlasherFilters interface. -var _ ContractISlasherFilters = (*ContractISlasherFilterer)(nil) - -// ContractISlasherSession is an auto generated Go binding around an Ethereum contract, -// with pre-set call and transact options. -type ContractISlasherSession struct { - Contract *ContractISlasher // 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 -} - -// ContractISlasherCallerSession is an auto generated read-only Go binding around an Ethereum contract, -// with pre-set call options. -type ContractISlasherCallerSession struct { - Contract *ContractISlasherCaller // Generic contract caller binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session -} - -// ContractISlasherTransactorSession is an auto generated write-only Go binding around an Ethereum contract, -// with pre-set transact options. -type ContractISlasherTransactorSession struct { - Contract *ContractISlasherTransactor // Generic contract transactor binding to set the session for - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session -} - -// ContractISlasherRaw is an auto generated low-level Go binding around an Ethereum contract. -type ContractISlasherRaw struct { - Contract *ContractISlasher // Generic contract binding to access the raw methods on -} - -// ContractISlasherCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. -type ContractISlasherCallerRaw struct { - Contract *ContractISlasherCaller // Generic read-only contract binding to access the raw methods on -} - -// ContractISlasherTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. -type ContractISlasherTransactorRaw struct { - Contract *ContractISlasherTransactor // Generic write-only contract binding to access the raw methods on -} - -// NewContractISlasher creates a new instance of ContractISlasher, bound to a specific deployed contract. -func NewContractISlasher(address common.Address, backend bind.ContractBackend) (*ContractISlasher, error) { - contract, err := bindContractISlasher(address, backend, backend, backend) - if err != nil { - return nil, err - } - return &ContractISlasher{ContractISlasherCaller: ContractISlasherCaller{contract: contract}, ContractISlasherTransactor: ContractISlasherTransactor{contract: contract}, ContractISlasherFilterer: ContractISlasherFilterer{contract: contract}}, nil -} - -// NewContractISlasherCaller creates a new read-only instance of ContractISlasher, bound to a specific deployed contract. -func NewContractISlasherCaller(address common.Address, caller bind.ContractCaller) (*ContractISlasherCaller, error) { - contract, err := bindContractISlasher(address, caller, nil, nil) - if err != nil { - return nil, err - } - return &ContractISlasherCaller{contract: contract}, nil -} - -// NewContractISlasherTransactor creates a new write-only instance of ContractISlasher, bound to a specific deployed contract. -func NewContractISlasherTransactor(address common.Address, transactor bind.ContractTransactor) (*ContractISlasherTransactor, error) { - contract, err := bindContractISlasher(address, nil, transactor, nil) - if err != nil { - return nil, err - } - return &ContractISlasherTransactor{contract: contract}, nil -} - -// NewContractISlasherFilterer creates a new log filterer instance of ContractISlasher, bound to a specific deployed contract. -func NewContractISlasherFilterer(address common.Address, filterer bind.ContractFilterer) (*ContractISlasherFilterer, error) { - contract, err := bindContractISlasher(address, nil, nil, filterer) - if err != nil { - return nil, err - } - return &ContractISlasherFilterer{contract: contract}, nil -} - -// bindContractISlasher binds a generic wrapper to an already deployed contract. -func bindContractISlasher(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { - parsed, err := ContractISlasherMetaData.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 (_ContractISlasher *ContractISlasherRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _ContractISlasher.Contract.ContractISlasherCaller.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 (_ContractISlasher *ContractISlasherRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _ContractISlasher.Contract.ContractISlasherTransactor.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_ContractISlasher *ContractISlasherRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _ContractISlasher.Contract.ContractISlasherTransactor.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 (_ContractISlasher *ContractISlasherCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _ContractISlasher.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 (_ContractISlasher *ContractISlasherTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _ContractISlasher.Contract.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_ContractISlasher *ContractISlasherTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _ContractISlasher.Contract.contract.Transact(opts, method, params...) -} - -// CanSlash is a free data retrieval call binding the contract method 0xd98128c0. -// -// Solidity: function canSlash(address toBeSlashed, address slashingContract) view returns(bool) -func (_ContractISlasher *ContractISlasherCaller) CanSlash(opts *bind.CallOpts, toBeSlashed common.Address, slashingContract common.Address) (bool, error) { - var out []interface{} - err := _ContractISlasher.contract.Call(opts, &out, "canSlash", toBeSlashed, slashingContract) - - if err != nil { - return *new(bool), err - } - - out0 := *abi.ConvertType(out[0], new(bool)).(*bool) - - return out0, err - -} - -// CanSlash is a free data retrieval call binding the contract method 0xd98128c0. -// -// Solidity: function canSlash(address toBeSlashed, address slashingContract) view returns(bool) -func (_ContractISlasher *ContractISlasherSession) CanSlash(toBeSlashed common.Address, slashingContract common.Address) (bool, error) { - return _ContractISlasher.Contract.CanSlash(&_ContractISlasher.CallOpts, toBeSlashed, slashingContract) -} - -// CanSlash is a free data retrieval call binding the contract method 0xd98128c0. -// -// Solidity: function canSlash(address toBeSlashed, address slashingContract) view returns(bool) -func (_ContractISlasher *ContractISlasherCallerSession) CanSlash(toBeSlashed common.Address, slashingContract common.Address) (bool, error) { - return _ContractISlasher.Contract.CanSlash(&_ContractISlasher.CallOpts, toBeSlashed, slashingContract) -} - -// ContractCanSlashOperatorUntilBlock is a free data retrieval call binding the contract method 0x6f0c2f74. -// -// Solidity: function contractCanSlashOperatorUntilBlock(address operator, address serviceContract) view returns(uint32) -func (_ContractISlasher *ContractISlasherCaller) ContractCanSlashOperatorUntilBlock(opts *bind.CallOpts, operator common.Address, serviceContract common.Address) (uint32, error) { - var out []interface{} - err := _ContractISlasher.contract.Call(opts, &out, "contractCanSlashOperatorUntilBlock", operator, serviceContract) - - if err != nil { - return *new(uint32), err - } - - out0 := *abi.ConvertType(out[0], new(uint32)).(*uint32) - - return out0, err - -} - -// ContractCanSlashOperatorUntilBlock is a free data retrieval call binding the contract method 0x6f0c2f74. -// -// Solidity: function contractCanSlashOperatorUntilBlock(address operator, address serviceContract) view returns(uint32) -func (_ContractISlasher *ContractISlasherSession) ContractCanSlashOperatorUntilBlock(operator common.Address, serviceContract common.Address) (uint32, error) { - return _ContractISlasher.Contract.ContractCanSlashOperatorUntilBlock(&_ContractISlasher.CallOpts, operator, serviceContract) -} - -// ContractCanSlashOperatorUntilBlock is a free data retrieval call binding the contract method 0x6f0c2f74. -// -// Solidity: function contractCanSlashOperatorUntilBlock(address operator, address serviceContract) view returns(uint32) -func (_ContractISlasher *ContractISlasherCallerSession) ContractCanSlashOperatorUntilBlock(operator common.Address, serviceContract common.Address) (uint32, error) { - return _ContractISlasher.Contract.ContractCanSlashOperatorUntilBlock(&_ContractISlasher.CallOpts, operator, serviceContract) -} - -// Delegation is a free data retrieval call binding the contract method 0xdf5cf723. -// -// Solidity: function delegation() view returns(address) -func (_ContractISlasher *ContractISlasherCaller) Delegation(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _ContractISlasher.contract.Call(opts, &out, "delegation") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// Delegation is a free data retrieval call binding the contract method 0xdf5cf723. -// -// Solidity: function delegation() view returns(address) -func (_ContractISlasher *ContractISlasherSession) Delegation() (common.Address, error) { - return _ContractISlasher.Contract.Delegation(&_ContractISlasher.CallOpts) -} - -// Delegation is a free data retrieval call binding the contract method 0xdf5cf723. -// -// Solidity: function delegation() view returns(address) -func (_ContractISlasher *ContractISlasherCallerSession) Delegation() (common.Address, error) { - return _ContractISlasher.Contract.Delegation(&_ContractISlasher.CallOpts) -} - -// GetCorrectValueForInsertAfter is a free data retrieval call binding the contract method 0x723e59c7. -// -// Solidity: function getCorrectValueForInsertAfter(address operator, uint32 updateBlock) view returns(uint256) -func (_ContractISlasher *ContractISlasherCaller) GetCorrectValueForInsertAfter(opts *bind.CallOpts, operator common.Address, updateBlock uint32) (*big.Int, error) { - var out []interface{} - err := _ContractISlasher.contract.Call(opts, &out, "getCorrectValueForInsertAfter", operator, updateBlock) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// GetCorrectValueForInsertAfter is a free data retrieval call binding the contract method 0x723e59c7. -// -// Solidity: function getCorrectValueForInsertAfter(address operator, uint32 updateBlock) view returns(uint256) -func (_ContractISlasher *ContractISlasherSession) GetCorrectValueForInsertAfter(operator common.Address, updateBlock uint32) (*big.Int, error) { - return _ContractISlasher.Contract.GetCorrectValueForInsertAfter(&_ContractISlasher.CallOpts, operator, updateBlock) -} - -// GetCorrectValueForInsertAfter is a free data retrieval call binding the contract method 0x723e59c7. -// -// Solidity: function getCorrectValueForInsertAfter(address operator, uint32 updateBlock) view returns(uint256) -func (_ContractISlasher *ContractISlasherCallerSession) GetCorrectValueForInsertAfter(operator common.Address, updateBlock uint32) (*big.Int, error) { - return _ContractISlasher.Contract.GetCorrectValueForInsertAfter(&_ContractISlasher.CallOpts, operator, updateBlock) -} - -// GetMiddlewareTimesIndexServeUntilBlock is a free data retrieval call binding the contract method 0x7259a45c. -// -// Solidity: function getMiddlewareTimesIndexServeUntilBlock(address operator, uint32 index) view returns(uint32) -func (_ContractISlasher *ContractISlasherCaller) GetMiddlewareTimesIndexServeUntilBlock(opts *bind.CallOpts, operator common.Address, index uint32) (uint32, error) { - var out []interface{} - err := _ContractISlasher.contract.Call(opts, &out, "getMiddlewareTimesIndexServeUntilBlock", operator, index) - - if err != nil { - return *new(uint32), err - } - - out0 := *abi.ConvertType(out[0], new(uint32)).(*uint32) - - return out0, err - -} - -// GetMiddlewareTimesIndexServeUntilBlock is a free data retrieval call binding the contract method 0x7259a45c. -// -// Solidity: function getMiddlewareTimesIndexServeUntilBlock(address operator, uint32 index) view returns(uint32) -func (_ContractISlasher *ContractISlasherSession) GetMiddlewareTimesIndexServeUntilBlock(operator common.Address, index uint32) (uint32, error) { - return _ContractISlasher.Contract.GetMiddlewareTimesIndexServeUntilBlock(&_ContractISlasher.CallOpts, operator, index) -} - -// GetMiddlewareTimesIndexServeUntilBlock is a free data retrieval call binding the contract method 0x7259a45c. -// -// Solidity: function getMiddlewareTimesIndexServeUntilBlock(address operator, uint32 index) view returns(uint32) -func (_ContractISlasher *ContractISlasherCallerSession) GetMiddlewareTimesIndexServeUntilBlock(operator common.Address, index uint32) (uint32, error) { - return _ContractISlasher.Contract.GetMiddlewareTimesIndexServeUntilBlock(&_ContractISlasher.CallOpts, operator, index) -} - -// GetMiddlewareTimesIndexStalestUpdateBlock is a free data retrieval call binding the contract method 0x1874e5ae. -// -// Solidity: function getMiddlewareTimesIndexStalestUpdateBlock(address operator, uint32 index) view returns(uint32) -func (_ContractISlasher *ContractISlasherCaller) GetMiddlewareTimesIndexStalestUpdateBlock(opts *bind.CallOpts, operator common.Address, index uint32) (uint32, error) { - var out []interface{} - err := _ContractISlasher.contract.Call(opts, &out, "getMiddlewareTimesIndexStalestUpdateBlock", operator, index) - - if err != nil { - return *new(uint32), err - } - - out0 := *abi.ConvertType(out[0], new(uint32)).(*uint32) - - return out0, err - -} - -// GetMiddlewareTimesIndexStalestUpdateBlock is a free data retrieval call binding the contract method 0x1874e5ae. -// -// Solidity: function getMiddlewareTimesIndexStalestUpdateBlock(address operator, uint32 index) view returns(uint32) -func (_ContractISlasher *ContractISlasherSession) GetMiddlewareTimesIndexStalestUpdateBlock(operator common.Address, index uint32) (uint32, error) { - return _ContractISlasher.Contract.GetMiddlewareTimesIndexStalestUpdateBlock(&_ContractISlasher.CallOpts, operator, index) -} - -// GetMiddlewareTimesIndexStalestUpdateBlock is a free data retrieval call binding the contract method 0x1874e5ae. -// -// Solidity: function getMiddlewareTimesIndexStalestUpdateBlock(address operator, uint32 index) view returns(uint32) -func (_ContractISlasher *ContractISlasherCallerSession) GetMiddlewareTimesIndexStalestUpdateBlock(operator common.Address, index uint32) (uint32, error) { - return _ContractISlasher.Contract.GetMiddlewareTimesIndexStalestUpdateBlock(&_ContractISlasher.CallOpts, operator, index) -} - -// IsFrozen is a free data retrieval call binding the contract method 0xe5839836. -// -// Solidity: function isFrozen(address staker) view returns(bool) -func (_ContractISlasher *ContractISlasherCaller) IsFrozen(opts *bind.CallOpts, staker common.Address) (bool, error) { - var out []interface{} - err := _ContractISlasher.contract.Call(opts, &out, "isFrozen", staker) - - if err != nil { - return *new(bool), err - } - - out0 := *abi.ConvertType(out[0], new(bool)).(*bool) - - return out0, err - -} - -// IsFrozen is a free data retrieval call binding the contract method 0xe5839836. -// -// Solidity: function isFrozen(address staker) view returns(bool) -func (_ContractISlasher *ContractISlasherSession) IsFrozen(staker common.Address) (bool, error) { - return _ContractISlasher.Contract.IsFrozen(&_ContractISlasher.CallOpts, staker) -} - -// IsFrozen is a free data retrieval call binding the contract method 0xe5839836. -// -// Solidity: function isFrozen(address staker) view returns(bool) -func (_ContractISlasher *ContractISlasherCallerSession) IsFrozen(staker common.Address) (bool, error) { - return _ContractISlasher.Contract.IsFrozen(&_ContractISlasher.CallOpts, staker) -} - -// LatestUpdateBlock is a free data retrieval call binding the contract method 0xda16e29b. -// -// Solidity: function latestUpdateBlock(address operator, address serviceContract) view returns(uint32) -func (_ContractISlasher *ContractISlasherCaller) LatestUpdateBlock(opts *bind.CallOpts, operator common.Address, serviceContract common.Address) (uint32, error) { - var out []interface{} - err := _ContractISlasher.contract.Call(opts, &out, "latestUpdateBlock", operator, serviceContract) - - if err != nil { - return *new(uint32), err - } - - out0 := *abi.ConvertType(out[0], new(uint32)).(*uint32) - - return out0, err - -} - -// LatestUpdateBlock is a free data retrieval call binding the contract method 0xda16e29b. -// -// Solidity: function latestUpdateBlock(address operator, address serviceContract) view returns(uint32) -func (_ContractISlasher *ContractISlasherSession) LatestUpdateBlock(operator common.Address, serviceContract common.Address) (uint32, error) { - return _ContractISlasher.Contract.LatestUpdateBlock(&_ContractISlasher.CallOpts, operator, serviceContract) -} - -// LatestUpdateBlock is a free data retrieval call binding the contract method 0xda16e29b. -// -// Solidity: function latestUpdateBlock(address operator, address serviceContract) view returns(uint32) -func (_ContractISlasher *ContractISlasherCallerSession) LatestUpdateBlock(operator common.Address, serviceContract common.Address) (uint32, error) { - return _ContractISlasher.Contract.LatestUpdateBlock(&_ContractISlasher.CallOpts, operator, serviceContract) -} - -// MiddlewareTimesLength is a free data retrieval call binding the contract method 0xa49db732. -// -// Solidity: function middlewareTimesLength(address operator) view returns(uint256) -func (_ContractISlasher *ContractISlasherCaller) MiddlewareTimesLength(opts *bind.CallOpts, operator common.Address) (*big.Int, error) { - var out []interface{} - err := _ContractISlasher.contract.Call(opts, &out, "middlewareTimesLength", operator) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// MiddlewareTimesLength is a free data retrieval call binding the contract method 0xa49db732. -// -// Solidity: function middlewareTimesLength(address operator) view returns(uint256) -func (_ContractISlasher *ContractISlasherSession) MiddlewareTimesLength(operator common.Address) (*big.Int, error) { - return _ContractISlasher.Contract.MiddlewareTimesLength(&_ContractISlasher.CallOpts, operator) -} - -// MiddlewareTimesLength is a free data retrieval call binding the contract method 0xa49db732. -// -// Solidity: function middlewareTimesLength(address operator) view returns(uint256) -func (_ContractISlasher *ContractISlasherCallerSession) MiddlewareTimesLength(operator common.Address) (*big.Int, error) { - return _ContractISlasher.Contract.MiddlewareTimesLength(&_ContractISlasher.CallOpts, operator) -} - -// OperatorToMiddlewareTimes is a free data retrieval call binding the contract method 0x282670fc. -// -// Solidity: function operatorToMiddlewareTimes(address operator, uint256 arrayIndex) view returns((uint32,uint32)) -func (_ContractISlasher *ContractISlasherCaller) OperatorToMiddlewareTimes(opts *bind.CallOpts, operator common.Address, arrayIndex *big.Int) (ISlasherMiddlewareTimes, error) { - var out []interface{} - err := _ContractISlasher.contract.Call(opts, &out, "operatorToMiddlewareTimes", operator, arrayIndex) - - if err != nil { - return *new(ISlasherMiddlewareTimes), err - } - - out0 := *abi.ConvertType(out[0], new(ISlasherMiddlewareTimes)).(*ISlasherMiddlewareTimes) - - return out0, err - -} - -// OperatorToMiddlewareTimes is a free data retrieval call binding the contract method 0x282670fc. -// -// Solidity: function operatorToMiddlewareTimes(address operator, uint256 arrayIndex) view returns((uint32,uint32)) -func (_ContractISlasher *ContractISlasherSession) OperatorToMiddlewareTimes(operator common.Address, arrayIndex *big.Int) (ISlasherMiddlewareTimes, error) { - return _ContractISlasher.Contract.OperatorToMiddlewareTimes(&_ContractISlasher.CallOpts, operator, arrayIndex) -} - -// OperatorToMiddlewareTimes is a free data retrieval call binding the contract method 0x282670fc. -// -// Solidity: function operatorToMiddlewareTimes(address operator, uint256 arrayIndex) view returns((uint32,uint32)) -func (_ContractISlasher *ContractISlasherCallerSession) OperatorToMiddlewareTimes(operator common.Address, arrayIndex *big.Int) (ISlasherMiddlewareTimes, error) { - return _ContractISlasher.Contract.OperatorToMiddlewareTimes(&_ContractISlasher.CallOpts, operator, arrayIndex) -} - -// OperatorWhitelistedContractsLinkedListEntry is a free data retrieval call binding the contract method 0x855fcc4a. -// -// Solidity: function operatorWhitelistedContractsLinkedListEntry(address operator, address node) view returns(bool, uint256, uint256) -func (_ContractISlasher *ContractISlasherCaller) OperatorWhitelistedContractsLinkedListEntry(opts *bind.CallOpts, operator common.Address, node common.Address) (bool, *big.Int, *big.Int, error) { - var out []interface{} - err := _ContractISlasher.contract.Call(opts, &out, "operatorWhitelistedContractsLinkedListEntry", operator, node) - - if err != nil { - return *new(bool), *new(*big.Int), *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(bool)).(*bool) - out1 := *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) - out2 := *abi.ConvertType(out[2], new(*big.Int)).(**big.Int) - - return out0, out1, out2, err - -} - -// OperatorWhitelistedContractsLinkedListEntry is a free data retrieval call binding the contract method 0x855fcc4a. -// -// Solidity: function operatorWhitelistedContractsLinkedListEntry(address operator, address node) view returns(bool, uint256, uint256) -func (_ContractISlasher *ContractISlasherSession) OperatorWhitelistedContractsLinkedListEntry(operator common.Address, node common.Address) (bool, *big.Int, *big.Int, error) { - return _ContractISlasher.Contract.OperatorWhitelistedContractsLinkedListEntry(&_ContractISlasher.CallOpts, operator, node) -} - -// OperatorWhitelistedContractsLinkedListEntry is a free data retrieval call binding the contract method 0x855fcc4a. -// -// Solidity: function operatorWhitelistedContractsLinkedListEntry(address operator, address node) view returns(bool, uint256, uint256) -func (_ContractISlasher *ContractISlasherCallerSession) OperatorWhitelistedContractsLinkedListEntry(operator common.Address, node common.Address) (bool, *big.Int, *big.Int, error) { - return _ContractISlasher.Contract.OperatorWhitelistedContractsLinkedListEntry(&_ContractISlasher.CallOpts, operator, node) -} - -// OperatorWhitelistedContractsLinkedListSize is a free data retrieval call binding the contract method 0xe921d4fa. -// -// Solidity: function operatorWhitelistedContractsLinkedListSize(address operator) view returns(uint256) -func (_ContractISlasher *ContractISlasherCaller) OperatorWhitelistedContractsLinkedListSize(opts *bind.CallOpts, operator common.Address) (*big.Int, error) { - var out []interface{} - err := _ContractISlasher.contract.Call(opts, &out, "operatorWhitelistedContractsLinkedListSize", operator) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// OperatorWhitelistedContractsLinkedListSize is a free data retrieval call binding the contract method 0xe921d4fa. -// -// Solidity: function operatorWhitelistedContractsLinkedListSize(address operator) view returns(uint256) -func (_ContractISlasher *ContractISlasherSession) OperatorWhitelistedContractsLinkedListSize(operator common.Address) (*big.Int, error) { - return _ContractISlasher.Contract.OperatorWhitelistedContractsLinkedListSize(&_ContractISlasher.CallOpts, operator) -} - -// OperatorWhitelistedContractsLinkedListSize is a free data retrieval call binding the contract method 0xe921d4fa. -// -// Solidity: function operatorWhitelistedContractsLinkedListSize(address operator) view returns(uint256) -func (_ContractISlasher *ContractISlasherCallerSession) OperatorWhitelistedContractsLinkedListSize(operator common.Address) (*big.Int, error) { - return _ContractISlasher.Contract.OperatorWhitelistedContractsLinkedListSize(&_ContractISlasher.CallOpts, operator) -} - -// StrategyManager is a free data retrieval call binding the contract method 0x39b70e38. -// -// Solidity: function strategyManager() view returns(address) -func (_ContractISlasher *ContractISlasherCaller) StrategyManager(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _ContractISlasher.contract.Call(opts, &out, "strategyManager") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// StrategyManager is a free data retrieval call binding the contract method 0x39b70e38. -// -// Solidity: function strategyManager() view returns(address) -func (_ContractISlasher *ContractISlasherSession) StrategyManager() (common.Address, error) { - return _ContractISlasher.Contract.StrategyManager(&_ContractISlasher.CallOpts) -} - -// StrategyManager is a free data retrieval call binding the contract method 0x39b70e38. -// -// Solidity: function strategyManager() view returns(address) -func (_ContractISlasher *ContractISlasherCallerSession) StrategyManager() (common.Address, error) { - return _ContractISlasher.Contract.StrategyManager(&_ContractISlasher.CallOpts) -} - -// CanWithdraw is a paid mutator transaction binding the contract method 0x8105e043. -// -// Solidity: function canWithdraw(address operator, uint32 withdrawalStartBlock, uint256 middlewareTimesIndex) returns(bool) -func (_ContractISlasher *ContractISlasherTransactor) CanWithdraw(opts *bind.TransactOpts, operator common.Address, withdrawalStartBlock uint32, middlewareTimesIndex *big.Int) (*types.Transaction, error) { - return _ContractISlasher.contract.Transact(opts, "canWithdraw", operator, withdrawalStartBlock, middlewareTimesIndex) -} - -// CanWithdraw is a paid mutator transaction binding the contract method 0x8105e043. -// -// Solidity: function canWithdraw(address operator, uint32 withdrawalStartBlock, uint256 middlewareTimesIndex) returns(bool) -func (_ContractISlasher *ContractISlasherSession) CanWithdraw(operator common.Address, withdrawalStartBlock uint32, middlewareTimesIndex *big.Int) (*types.Transaction, error) { - return _ContractISlasher.Contract.CanWithdraw(&_ContractISlasher.TransactOpts, operator, withdrawalStartBlock, middlewareTimesIndex) -} - -// CanWithdraw is a paid mutator transaction binding the contract method 0x8105e043. -// -// Solidity: function canWithdraw(address operator, uint32 withdrawalStartBlock, uint256 middlewareTimesIndex) returns(bool) -func (_ContractISlasher *ContractISlasherTransactorSession) CanWithdraw(operator common.Address, withdrawalStartBlock uint32, middlewareTimesIndex *big.Int) (*types.Transaction, error) { - return _ContractISlasher.Contract.CanWithdraw(&_ContractISlasher.TransactOpts, operator, withdrawalStartBlock, middlewareTimesIndex) -} - -// FreezeOperator is a paid mutator transaction binding the contract method 0x38c8ee64. -// -// Solidity: function freezeOperator(address toBeFrozen) returns() -func (_ContractISlasher *ContractISlasherTransactor) FreezeOperator(opts *bind.TransactOpts, toBeFrozen common.Address) (*types.Transaction, error) { - return _ContractISlasher.contract.Transact(opts, "freezeOperator", toBeFrozen) -} - -// FreezeOperator is a paid mutator transaction binding the contract method 0x38c8ee64. -// -// Solidity: function freezeOperator(address toBeFrozen) returns() -func (_ContractISlasher *ContractISlasherSession) FreezeOperator(toBeFrozen common.Address) (*types.Transaction, error) { - return _ContractISlasher.Contract.FreezeOperator(&_ContractISlasher.TransactOpts, toBeFrozen) -} - -// FreezeOperator is a paid mutator transaction binding the contract method 0x38c8ee64. -// -// Solidity: function freezeOperator(address toBeFrozen) returns() -func (_ContractISlasher *ContractISlasherTransactorSession) FreezeOperator(toBeFrozen common.Address) (*types.Transaction, error) { - return _ContractISlasher.Contract.FreezeOperator(&_ContractISlasher.TransactOpts, toBeFrozen) -} - -// OptIntoSlashing is a paid mutator transaction binding the contract method 0xf73b7519. -// -// Solidity: function optIntoSlashing(address contractAddress) returns() -func (_ContractISlasher *ContractISlasherTransactor) OptIntoSlashing(opts *bind.TransactOpts, contractAddress common.Address) (*types.Transaction, error) { - return _ContractISlasher.contract.Transact(opts, "optIntoSlashing", contractAddress) -} - -// OptIntoSlashing is a paid mutator transaction binding the contract method 0xf73b7519. -// -// Solidity: function optIntoSlashing(address contractAddress) returns() -func (_ContractISlasher *ContractISlasherSession) OptIntoSlashing(contractAddress common.Address) (*types.Transaction, error) { - return _ContractISlasher.Contract.OptIntoSlashing(&_ContractISlasher.TransactOpts, contractAddress) -} - -// OptIntoSlashing is a paid mutator transaction binding the contract method 0xf73b7519. -// -// Solidity: function optIntoSlashing(address contractAddress) returns() -func (_ContractISlasher *ContractISlasherTransactorSession) OptIntoSlashing(contractAddress common.Address) (*types.Transaction, error) { - return _ContractISlasher.Contract.OptIntoSlashing(&_ContractISlasher.TransactOpts, contractAddress) -} - -// RecordFirstStakeUpdate is a paid mutator transaction binding the contract method 0x175d3205. -// -// Solidity: function recordFirstStakeUpdate(address operator, uint32 serveUntilBlock) returns() -func (_ContractISlasher *ContractISlasherTransactor) RecordFirstStakeUpdate(opts *bind.TransactOpts, operator common.Address, serveUntilBlock uint32) (*types.Transaction, error) { - return _ContractISlasher.contract.Transact(opts, "recordFirstStakeUpdate", operator, serveUntilBlock) -} - -// RecordFirstStakeUpdate is a paid mutator transaction binding the contract method 0x175d3205. -// -// Solidity: function recordFirstStakeUpdate(address operator, uint32 serveUntilBlock) returns() -func (_ContractISlasher *ContractISlasherSession) RecordFirstStakeUpdate(operator common.Address, serveUntilBlock uint32) (*types.Transaction, error) { - return _ContractISlasher.Contract.RecordFirstStakeUpdate(&_ContractISlasher.TransactOpts, operator, serveUntilBlock) -} - -// RecordFirstStakeUpdate is a paid mutator transaction binding the contract method 0x175d3205. -// -// Solidity: function recordFirstStakeUpdate(address operator, uint32 serveUntilBlock) returns() -func (_ContractISlasher *ContractISlasherTransactorSession) RecordFirstStakeUpdate(operator common.Address, serveUntilBlock uint32) (*types.Transaction, error) { - return _ContractISlasher.Contract.RecordFirstStakeUpdate(&_ContractISlasher.TransactOpts, operator, serveUntilBlock) -} - -// RecordLastStakeUpdateAndRevokeSlashingAbility is a paid mutator transaction binding the contract method 0x0ffabbce. -// -// Solidity: function recordLastStakeUpdateAndRevokeSlashingAbility(address operator, uint32 serveUntilBlock) returns() -func (_ContractISlasher *ContractISlasherTransactor) RecordLastStakeUpdateAndRevokeSlashingAbility(opts *bind.TransactOpts, operator common.Address, serveUntilBlock uint32) (*types.Transaction, error) { - return _ContractISlasher.contract.Transact(opts, "recordLastStakeUpdateAndRevokeSlashingAbility", operator, serveUntilBlock) -} - -// RecordLastStakeUpdateAndRevokeSlashingAbility is a paid mutator transaction binding the contract method 0x0ffabbce. -// -// Solidity: function recordLastStakeUpdateAndRevokeSlashingAbility(address operator, uint32 serveUntilBlock) returns() -func (_ContractISlasher *ContractISlasherSession) RecordLastStakeUpdateAndRevokeSlashingAbility(operator common.Address, serveUntilBlock uint32) (*types.Transaction, error) { - return _ContractISlasher.Contract.RecordLastStakeUpdateAndRevokeSlashingAbility(&_ContractISlasher.TransactOpts, operator, serveUntilBlock) -} - -// RecordLastStakeUpdateAndRevokeSlashingAbility is a paid mutator transaction binding the contract method 0x0ffabbce. -// -// Solidity: function recordLastStakeUpdateAndRevokeSlashingAbility(address operator, uint32 serveUntilBlock) returns() -func (_ContractISlasher *ContractISlasherTransactorSession) RecordLastStakeUpdateAndRevokeSlashingAbility(operator common.Address, serveUntilBlock uint32) (*types.Transaction, error) { - return _ContractISlasher.Contract.RecordLastStakeUpdateAndRevokeSlashingAbility(&_ContractISlasher.TransactOpts, operator, serveUntilBlock) -} - -// RecordStakeUpdate is a paid mutator transaction binding the contract method 0xc747075b. -// -// Solidity: function recordStakeUpdate(address operator, uint32 updateBlock, uint32 serveUntilBlock, uint256 insertAfter) returns() -func (_ContractISlasher *ContractISlasherTransactor) RecordStakeUpdate(opts *bind.TransactOpts, operator common.Address, updateBlock uint32, serveUntilBlock uint32, insertAfter *big.Int) (*types.Transaction, error) { - return _ContractISlasher.contract.Transact(opts, "recordStakeUpdate", operator, updateBlock, serveUntilBlock, insertAfter) -} - -// RecordStakeUpdate is a paid mutator transaction binding the contract method 0xc747075b. -// -// Solidity: function recordStakeUpdate(address operator, uint32 updateBlock, uint32 serveUntilBlock, uint256 insertAfter) returns() -func (_ContractISlasher *ContractISlasherSession) RecordStakeUpdate(operator common.Address, updateBlock uint32, serveUntilBlock uint32, insertAfter *big.Int) (*types.Transaction, error) { - return _ContractISlasher.Contract.RecordStakeUpdate(&_ContractISlasher.TransactOpts, operator, updateBlock, serveUntilBlock, insertAfter) -} - -// RecordStakeUpdate is a paid mutator transaction binding the contract method 0xc747075b. -// -// Solidity: function recordStakeUpdate(address operator, uint32 updateBlock, uint32 serveUntilBlock, uint256 insertAfter) returns() -func (_ContractISlasher *ContractISlasherTransactorSession) RecordStakeUpdate(operator common.Address, updateBlock uint32, serveUntilBlock uint32, insertAfter *big.Int) (*types.Transaction, error) { - return _ContractISlasher.Contract.RecordStakeUpdate(&_ContractISlasher.TransactOpts, operator, updateBlock, serveUntilBlock, insertAfter) -} - -// ResetFrozenStatus is a paid mutator transaction binding the contract method 0x7cf72bba. -// -// Solidity: function resetFrozenStatus(address[] frozenAddresses) returns() -func (_ContractISlasher *ContractISlasherTransactor) ResetFrozenStatus(opts *bind.TransactOpts, frozenAddresses []common.Address) (*types.Transaction, error) { - return _ContractISlasher.contract.Transact(opts, "resetFrozenStatus", frozenAddresses) -} - -// ResetFrozenStatus is a paid mutator transaction binding the contract method 0x7cf72bba. -// -// Solidity: function resetFrozenStatus(address[] frozenAddresses) returns() -func (_ContractISlasher *ContractISlasherSession) ResetFrozenStatus(frozenAddresses []common.Address) (*types.Transaction, error) { - return _ContractISlasher.Contract.ResetFrozenStatus(&_ContractISlasher.TransactOpts, frozenAddresses) -} - -// ResetFrozenStatus is a paid mutator transaction binding the contract method 0x7cf72bba. -// -// Solidity: function resetFrozenStatus(address[] frozenAddresses) returns() -func (_ContractISlasher *ContractISlasherTransactorSession) ResetFrozenStatus(frozenAddresses []common.Address) (*types.Transaction, error) { - return _ContractISlasher.Contract.ResetFrozenStatus(&_ContractISlasher.TransactOpts, frozenAddresses) -} - -// ContractISlasherFrozenStatusResetIterator is returned from FilterFrozenStatusReset and is used to iterate over the raw logs and unpacked data for FrozenStatusReset events raised by the ContractISlasher contract. -type ContractISlasherFrozenStatusResetIterator struct { - Event *ContractISlasherFrozenStatusReset // 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 *ContractISlasherFrozenStatusResetIterator) 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(ContractISlasherFrozenStatusReset) - 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(ContractISlasherFrozenStatusReset) - 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 *ContractISlasherFrozenStatusResetIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ContractISlasherFrozenStatusResetIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ContractISlasherFrozenStatusReset represents a FrozenStatusReset event raised by the ContractISlasher contract. -type ContractISlasherFrozenStatusReset struct { - PreviouslySlashedAddress common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterFrozenStatusReset is a free log retrieval operation binding the contract event 0xd4cef0af27800d466fcacd85779857378b85cb61569005ff1464fa6e5ced69d8. -// -// Solidity: event FrozenStatusReset(address indexed previouslySlashedAddress) -func (_ContractISlasher *ContractISlasherFilterer) FilterFrozenStatusReset(opts *bind.FilterOpts, previouslySlashedAddress []common.Address) (*ContractISlasherFrozenStatusResetIterator, error) { - - var previouslySlashedAddressRule []interface{} - for _, previouslySlashedAddressItem := range previouslySlashedAddress { - previouslySlashedAddressRule = append(previouslySlashedAddressRule, previouslySlashedAddressItem) - } - - logs, sub, err := _ContractISlasher.contract.FilterLogs(opts, "FrozenStatusReset", previouslySlashedAddressRule) - if err != nil { - return nil, err - } - return &ContractISlasherFrozenStatusResetIterator{contract: _ContractISlasher.contract, event: "FrozenStatusReset", logs: logs, sub: sub}, nil -} - -// WatchFrozenStatusReset is a free log subscription operation binding the contract event 0xd4cef0af27800d466fcacd85779857378b85cb61569005ff1464fa6e5ced69d8. -// -// Solidity: event FrozenStatusReset(address indexed previouslySlashedAddress) -func (_ContractISlasher *ContractISlasherFilterer) WatchFrozenStatusReset(opts *bind.WatchOpts, sink chan<- *ContractISlasherFrozenStatusReset, previouslySlashedAddress []common.Address) (event.Subscription, error) { - - var previouslySlashedAddressRule []interface{} - for _, previouslySlashedAddressItem := range previouslySlashedAddress { - previouslySlashedAddressRule = append(previouslySlashedAddressRule, previouslySlashedAddressItem) - } - - logs, sub, err := _ContractISlasher.contract.WatchLogs(opts, "FrozenStatusReset", previouslySlashedAddressRule) - 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(ContractISlasherFrozenStatusReset) - if err := _ContractISlasher.contract.UnpackLog(event, "FrozenStatusReset", 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 -} - -// ParseFrozenStatusReset is a log parse operation binding the contract event 0xd4cef0af27800d466fcacd85779857378b85cb61569005ff1464fa6e5ced69d8. -// -// Solidity: event FrozenStatusReset(address indexed previouslySlashedAddress) -func (_ContractISlasher *ContractISlasherFilterer) ParseFrozenStatusReset(log types.Log) (*ContractISlasherFrozenStatusReset, error) { - event := new(ContractISlasherFrozenStatusReset) - if err := _ContractISlasher.contract.UnpackLog(event, "FrozenStatusReset", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ContractISlasherMiddlewareTimesAddedIterator is returned from FilterMiddlewareTimesAdded and is used to iterate over the raw logs and unpacked data for MiddlewareTimesAdded events raised by the ContractISlasher contract. -type ContractISlasherMiddlewareTimesAddedIterator struct { - Event *ContractISlasherMiddlewareTimesAdded // 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 *ContractISlasherMiddlewareTimesAddedIterator) 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(ContractISlasherMiddlewareTimesAdded) - 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(ContractISlasherMiddlewareTimesAdded) - 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 *ContractISlasherMiddlewareTimesAddedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ContractISlasherMiddlewareTimesAddedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ContractISlasherMiddlewareTimesAdded represents a MiddlewareTimesAdded event raised by the ContractISlasher contract. -type ContractISlasherMiddlewareTimesAdded struct { - Operator common.Address - Index *big.Int - StalestUpdateBlock uint32 - LatestServeUntilBlock uint32 - Raw types.Log // Blockchain specific contextual infos -} - -// FilterMiddlewareTimesAdded is a free log retrieval operation binding the contract event 0x1b62ba64c72d01e41a2b8c46e6aeeff728ef3a4438cf1cac3d92ee12189d5649. -// -// Solidity: event MiddlewareTimesAdded(address operator, uint256 index, uint32 stalestUpdateBlock, uint32 latestServeUntilBlock) -func (_ContractISlasher *ContractISlasherFilterer) FilterMiddlewareTimesAdded(opts *bind.FilterOpts) (*ContractISlasherMiddlewareTimesAddedIterator, error) { - - logs, sub, err := _ContractISlasher.contract.FilterLogs(opts, "MiddlewareTimesAdded") - if err != nil { - return nil, err - } - return &ContractISlasherMiddlewareTimesAddedIterator{contract: _ContractISlasher.contract, event: "MiddlewareTimesAdded", logs: logs, sub: sub}, nil -} - -// WatchMiddlewareTimesAdded is a free log subscription operation binding the contract event 0x1b62ba64c72d01e41a2b8c46e6aeeff728ef3a4438cf1cac3d92ee12189d5649. -// -// Solidity: event MiddlewareTimesAdded(address operator, uint256 index, uint32 stalestUpdateBlock, uint32 latestServeUntilBlock) -func (_ContractISlasher *ContractISlasherFilterer) WatchMiddlewareTimesAdded(opts *bind.WatchOpts, sink chan<- *ContractISlasherMiddlewareTimesAdded) (event.Subscription, error) { - - logs, sub, err := _ContractISlasher.contract.WatchLogs(opts, "MiddlewareTimesAdded") - 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(ContractISlasherMiddlewareTimesAdded) - if err := _ContractISlasher.contract.UnpackLog(event, "MiddlewareTimesAdded", 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 -} - -// ParseMiddlewareTimesAdded is a log parse operation binding the contract event 0x1b62ba64c72d01e41a2b8c46e6aeeff728ef3a4438cf1cac3d92ee12189d5649. -// -// Solidity: event MiddlewareTimesAdded(address operator, uint256 index, uint32 stalestUpdateBlock, uint32 latestServeUntilBlock) -func (_ContractISlasher *ContractISlasherFilterer) ParseMiddlewareTimesAdded(log types.Log) (*ContractISlasherMiddlewareTimesAdded, error) { - event := new(ContractISlasherMiddlewareTimesAdded) - if err := _ContractISlasher.contract.UnpackLog(event, "MiddlewareTimesAdded", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ContractISlasherOperatorFrozenIterator is returned from FilterOperatorFrozen and is used to iterate over the raw logs and unpacked data for OperatorFrozen events raised by the ContractISlasher contract. -type ContractISlasherOperatorFrozenIterator struct { - Event *ContractISlasherOperatorFrozen // 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 *ContractISlasherOperatorFrozenIterator) 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(ContractISlasherOperatorFrozen) - 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(ContractISlasherOperatorFrozen) - 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 *ContractISlasherOperatorFrozenIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ContractISlasherOperatorFrozenIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ContractISlasherOperatorFrozen represents a OperatorFrozen event raised by the ContractISlasher contract. -type ContractISlasherOperatorFrozen struct { - SlashedOperator common.Address - SlashingContract common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterOperatorFrozen is a free log retrieval operation binding the contract event 0x444a84f512816ae7be8ed8a66aa88e362eb54d0988e83acc9d81746622b3ba51. -// -// Solidity: event OperatorFrozen(address indexed slashedOperator, address indexed slashingContract) -func (_ContractISlasher *ContractISlasherFilterer) FilterOperatorFrozen(opts *bind.FilterOpts, slashedOperator []common.Address, slashingContract []common.Address) (*ContractISlasherOperatorFrozenIterator, error) { - - var slashedOperatorRule []interface{} - for _, slashedOperatorItem := range slashedOperator { - slashedOperatorRule = append(slashedOperatorRule, slashedOperatorItem) - } - var slashingContractRule []interface{} - for _, slashingContractItem := range slashingContract { - slashingContractRule = append(slashingContractRule, slashingContractItem) - } - - logs, sub, err := _ContractISlasher.contract.FilterLogs(opts, "OperatorFrozen", slashedOperatorRule, slashingContractRule) - if err != nil { - return nil, err - } - return &ContractISlasherOperatorFrozenIterator{contract: _ContractISlasher.contract, event: "OperatorFrozen", logs: logs, sub: sub}, nil -} - -// WatchOperatorFrozen is a free log subscription operation binding the contract event 0x444a84f512816ae7be8ed8a66aa88e362eb54d0988e83acc9d81746622b3ba51. -// -// Solidity: event OperatorFrozen(address indexed slashedOperator, address indexed slashingContract) -func (_ContractISlasher *ContractISlasherFilterer) WatchOperatorFrozen(opts *bind.WatchOpts, sink chan<- *ContractISlasherOperatorFrozen, slashedOperator []common.Address, slashingContract []common.Address) (event.Subscription, error) { - - var slashedOperatorRule []interface{} - for _, slashedOperatorItem := range slashedOperator { - slashedOperatorRule = append(slashedOperatorRule, slashedOperatorItem) - } - var slashingContractRule []interface{} - for _, slashingContractItem := range slashingContract { - slashingContractRule = append(slashingContractRule, slashingContractItem) - } - - logs, sub, err := _ContractISlasher.contract.WatchLogs(opts, "OperatorFrozen", slashedOperatorRule, slashingContractRule) - 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(ContractISlasherOperatorFrozen) - if err := _ContractISlasher.contract.UnpackLog(event, "OperatorFrozen", 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 -} - -// ParseOperatorFrozen is a log parse operation binding the contract event 0x444a84f512816ae7be8ed8a66aa88e362eb54d0988e83acc9d81746622b3ba51. -// -// Solidity: event OperatorFrozen(address indexed slashedOperator, address indexed slashingContract) -func (_ContractISlasher *ContractISlasherFilterer) ParseOperatorFrozen(log types.Log) (*ContractISlasherOperatorFrozen, error) { - event := new(ContractISlasherOperatorFrozen) - if err := _ContractISlasher.contract.UnpackLog(event, "OperatorFrozen", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ContractISlasherOptedIntoSlashingIterator is returned from FilterOptedIntoSlashing and is used to iterate over the raw logs and unpacked data for OptedIntoSlashing events raised by the ContractISlasher contract. -type ContractISlasherOptedIntoSlashingIterator struct { - Event *ContractISlasherOptedIntoSlashing // 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 *ContractISlasherOptedIntoSlashingIterator) 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(ContractISlasherOptedIntoSlashing) - 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(ContractISlasherOptedIntoSlashing) - 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 *ContractISlasherOptedIntoSlashingIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ContractISlasherOptedIntoSlashingIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ContractISlasherOptedIntoSlashing represents a OptedIntoSlashing event raised by the ContractISlasher contract. -type ContractISlasherOptedIntoSlashing struct { - Operator common.Address - ContractAddress common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterOptedIntoSlashing is a free log retrieval operation binding the contract event 0xefa9fb38e813d53c15edf501e03852843a3fed691960523391d71a092b3627d8. -// -// Solidity: event OptedIntoSlashing(address indexed operator, address indexed contractAddress) -func (_ContractISlasher *ContractISlasherFilterer) FilterOptedIntoSlashing(opts *bind.FilterOpts, operator []common.Address, contractAddress []common.Address) (*ContractISlasherOptedIntoSlashingIterator, error) { - - var operatorRule []interface{} - for _, operatorItem := range operator { - operatorRule = append(operatorRule, operatorItem) - } - var contractAddressRule []interface{} - for _, contractAddressItem := range contractAddress { - contractAddressRule = append(contractAddressRule, contractAddressItem) - } - - logs, sub, err := _ContractISlasher.contract.FilterLogs(opts, "OptedIntoSlashing", operatorRule, contractAddressRule) - if err != nil { - return nil, err - } - return &ContractISlasherOptedIntoSlashingIterator{contract: _ContractISlasher.contract, event: "OptedIntoSlashing", logs: logs, sub: sub}, nil -} - -// WatchOptedIntoSlashing is a free log subscription operation binding the contract event 0xefa9fb38e813d53c15edf501e03852843a3fed691960523391d71a092b3627d8. -// -// Solidity: event OptedIntoSlashing(address indexed operator, address indexed contractAddress) -func (_ContractISlasher *ContractISlasherFilterer) WatchOptedIntoSlashing(opts *bind.WatchOpts, sink chan<- *ContractISlasherOptedIntoSlashing, operator []common.Address, contractAddress []common.Address) (event.Subscription, error) { - - var operatorRule []interface{} - for _, operatorItem := range operator { - operatorRule = append(operatorRule, operatorItem) - } - var contractAddressRule []interface{} - for _, contractAddressItem := range contractAddress { - contractAddressRule = append(contractAddressRule, contractAddressItem) - } - - logs, sub, err := _ContractISlasher.contract.WatchLogs(opts, "OptedIntoSlashing", operatorRule, contractAddressRule) - 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(ContractISlasherOptedIntoSlashing) - if err := _ContractISlasher.contract.UnpackLog(event, "OptedIntoSlashing", 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 -} - -// ParseOptedIntoSlashing is a log parse operation binding the contract event 0xefa9fb38e813d53c15edf501e03852843a3fed691960523391d71a092b3627d8. -// -// Solidity: event OptedIntoSlashing(address indexed operator, address indexed contractAddress) -func (_ContractISlasher *ContractISlasherFilterer) ParseOptedIntoSlashing(log types.Log) (*ContractISlasherOptedIntoSlashing, error) { - event := new(ContractISlasherOptedIntoSlashing) - if err := _ContractISlasher.contract.UnpackLog(event, "OptedIntoSlashing", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ContractISlasherSlashingAbilityRevokedIterator is returned from FilterSlashingAbilityRevoked and is used to iterate over the raw logs and unpacked data for SlashingAbilityRevoked events raised by the ContractISlasher contract. -type ContractISlasherSlashingAbilityRevokedIterator struct { - Event *ContractISlasherSlashingAbilityRevoked // 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 *ContractISlasherSlashingAbilityRevokedIterator) 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(ContractISlasherSlashingAbilityRevoked) - 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(ContractISlasherSlashingAbilityRevoked) - 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 *ContractISlasherSlashingAbilityRevokedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ContractISlasherSlashingAbilityRevokedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ContractISlasherSlashingAbilityRevoked represents a SlashingAbilityRevoked event raised by the ContractISlasher contract. -type ContractISlasherSlashingAbilityRevoked struct { - Operator common.Address - ContractAddress common.Address - ContractCanSlashOperatorUntilBlock uint32 - Raw types.Log // Blockchain specific contextual infos -} - -// FilterSlashingAbilityRevoked is a free log retrieval operation binding the contract event 0x9aa1b1391f35c672ed1f3b7ece632f4513e618366bef7a2f67b7c6bc1f2d2b14. -// -// Solidity: event SlashingAbilityRevoked(address indexed operator, address indexed contractAddress, uint32 contractCanSlashOperatorUntilBlock) -func (_ContractISlasher *ContractISlasherFilterer) FilterSlashingAbilityRevoked(opts *bind.FilterOpts, operator []common.Address, contractAddress []common.Address) (*ContractISlasherSlashingAbilityRevokedIterator, error) { - - var operatorRule []interface{} - for _, operatorItem := range operator { - operatorRule = append(operatorRule, operatorItem) - } - var contractAddressRule []interface{} - for _, contractAddressItem := range contractAddress { - contractAddressRule = append(contractAddressRule, contractAddressItem) - } - - logs, sub, err := _ContractISlasher.contract.FilterLogs(opts, "SlashingAbilityRevoked", operatorRule, contractAddressRule) - if err != nil { - return nil, err - } - return &ContractISlasherSlashingAbilityRevokedIterator{contract: _ContractISlasher.contract, event: "SlashingAbilityRevoked", logs: logs, sub: sub}, nil -} - -// WatchSlashingAbilityRevoked is a free log subscription operation binding the contract event 0x9aa1b1391f35c672ed1f3b7ece632f4513e618366bef7a2f67b7c6bc1f2d2b14. -// -// Solidity: event SlashingAbilityRevoked(address indexed operator, address indexed contractAddress, uint32 contractCanSlashOperatorUntilBlock) -func (_ContractISlasher *ContractISlasherFilterer) WatchSlashingAbilityRevoked(opts *bind.WatchOpts, sink chan<- *ContractISlasherSlashingAbilityRevoked, operator []common.Address, contractAddress []common.Address) (event.Subscription, error) { - - var operatorRule []interface{} - for _, operatorItem := range operator { - operatorRule = append(operatorRule, operatorItem) - } - var contractAddressRule []interface{} - for _, contractAddressItem := range contractAddress { - contractAddressRule = append(contractAddressRule, contractAddressItem) - } - - logs, sub, err := _ContractISlasher.contract.WatchLogs(opts, "SlashingAbilityRevoked", operatorRule, contractAddressRule) - 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(ContractISlasherSlashingAbilityRevoked) - if err := _ContractISlasher.contract.UnpackLog(event, "SlashingAbilityRevoked", 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 -} - -// ParseSlashingAbilityRevoked is a log parse operation binding the contract event 0x9aa1b1391f35c672ed1f3b7ece632f4513e618366bef7a2f67b7c6bc1f2d2b14. -// -// Solidity: event SlashingAbilityRevoked(address indexed operator, address indexed contractAddress, uint32 contractCanSlashOperatorUntilBlock) -func (_ContractISlasher *ContractISlasherFilterer) ParseSlashingAbilityRevoked(log types.Log) (*ContractISlasherSlashingAbilityRevoked, error) { - event := new(ContractISlasherSlashingAbilityRevoked) - if err := _ContractISlasher.contract.UnpackLog(event, "SlashingAbilityRevoked", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} diff --git a/contracts/bindings/IStrategy/binding.go b/contracts/bindings/IStrategy/binding.go deleted file mode 100644 index 0cf3875..0000000 --- a/contracts/bindings/IStrategy/binding.go +++ /dev/null @@ -1,556 +0,0 @@ -// Code generated - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package contractIStrategy - -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 -) - -// ContractIStrategyMetaData contains all meta data concerning the ContractIStrategy contract. -var ContractIStrategyMetaData = &bind.MetaData{ - ABI: "[{\"type\":\"function\",\"name\":\"deposit\",\"inputs\":[{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"explanation\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"string\",\"internalType\":\"string\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"shares\",\"inputs\":[{\"name\":\"user\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"sharesToUnderlying\",\"inputs\":[{\"name\":\"amountShares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"sharesToUnderlyingView\",\"inputs\":[{\"name\":\"amountShares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"totalShares\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"underlyingToShares\",\"inputs\":[{\"name\":\"amountUnderlying\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"underlyingToSharesView\",\"inputs\":[{\"name\":\"amountUnderlying\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"underlyingToken\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIERC20\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"userUnderlying\",\"inputs\":[{\"name\":\"user\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"userUnderlyingView\",\"inputs\":[{\"name\":\"user\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"withdraw\",\"inputs\":[{\"name\":\"recipient\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"amountShares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"}]", -} - -// ContractIStrategyABI is the input ABI used to generate the binding from. -// Deprecated: Use ContractIStrategyMetaData.ABI instead. -var ContractIStrategyABI = ContractIStrategyMetaData.ABI - -// ContractIStrategyMethods is an auto generated interface around an Ethereum contract. -type ContractIStrategyMethods interface { - ContractIStrategyCalls - ContractIStrategyTransacts - ContractIStrategyFilters -} - -// ContractIStrategyCalls is an auto generated interface that defines the call methods available for an Ethereum contract. -type ContractIStrategyCalls interface { - Explanation(opts *bind.CallOpts) (string, error) - - Shares(opts *bind.CallOpts, user common.Address) (*big.Int, error) - - SharesToUnderlyingView(opts *bind.CallOpts, amountShares *big.Int) (*big.Int, error) - - TotalShares(opts *bind.CallOpts) (*big.Int, error) - - UnderlyingToSharesView(opts *bind.CallOpts, amountUnderlying *big.Int) (*big.Int, error) - - UnderlyingToken(opts *bind.CallOpts) (common.Address, error) - - UserUnderlyingView(opts *bind.CallOpts, user common.Address) (*big.Int, error) -} - -// ContractIStrategyTransacts is an auto generated interface that defines the transact methods available for an Ethereum contract. -type ContractIStrategyTransacts interface { - Deposit(opts *bind.TransactOpts, token common.Address, amount *big.Int) (*types.Transaction, error) - - SharesToUnderlying(opts *bind.TransactOpts, amountShares *big.Int) (*types.Transaction, error) - - UnderlyingToShares(opts *bind.TransactOpts, amountUnderlying *big.Int) (*types.Transaction, error) - - UserUnderlying(opts *bind.TransactOpts, user common.Address) (*types.Transaction, error) - - Withdraw(opts *bind.TransactOpts, recipient common.Address, token common.Address, amountShares *big.Int) (*types.Transaction, error) -} - -// ContractIStrategyFilterer is an auto generated interface that defines the log filtering methods available for an Ethereum contract. -type ContractIStrategyFilters interface { -} - -// ContractIStrategy is an auto generated Go binding around an Ethereum contract. -type ContractIStrategy struct { - ContractIStrategyCaller // Read-only binding to the contract - ContractIStrategyTransactor // Write-only binding to the contract - ContractIStrategyFilterer // Log filterer for contract events -} - -// ContractIStrategy implements the ContractIStrategyMethods interface. -var _ ContractIStrategyMethods = (*ContractIStrategy)(nil) - -// ContractIStrategyCaller is an auto generated read-only Go binding around an Ethereum contract. -type ContractIStrategyCaller struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// ContractIStrategyCaller implements the ContractIStrategyCalls interface. -var _ ContractIStrategyCalls = (*ContractIStrategyCaller)(nil) - -// ContractIStrategyTransactor is an auto generated write-only Go binding around an Ethereum contract. -type ContractIStrategyTransactor struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// ContractIStrategyTransactor implements the ContractIStrategyTransacts interface. -var _ ContractIStrategyTransacts = (*ContractIStrategyTransactor)(nil) - -// ContractIStrategyFilterer is an auto generated log filtering Go binding around an Ethereum contract events. -type ContractIStrategyFilterer struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// ContractIStrategyFilterer implements the ContractIStrategyFilters interface. -var _ ContractIStrategyFilters = (*ContractIStrategyFilterer)(nil) - -// ContractIStrategySession is an auto generated Go binding around an Ethereum contract, -// with pre-set call and transact options. -type ContractIStrategySession struct { - Contract *ContractIStrategy // 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 -} - -// ContractIStrategyCallerSession is an auto generated read-only Go binding around an Ethereum contract, -// with pre-set call options. -type ContractIStrategyCallerSession struct { - Contract *ContractIStrategyCaller // Generic contract caller binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session -} - -// ContractIStrategyTransactorSession is an auto generated write-only Go binding around an Ethereum contract, -// with pre-set transact options. -type ContractIStrategyTransactorSession struct { - Contract *ContractIStrategyTransactor // Generic contract transactor binding to set the session for - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session -} - -// ContractIStrategyRaw is an auto generated low-level Go binding around an Ethereum contract. -type ContractIStrategyRaw struct { - Contract *ContractIStrategy // Generic contract binding to access the raw methods on -} - -// ContractIStrategyCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. -type ContractIStrategyCallerRaw struct { - Contract *ContractIStrategyCaller // Generic read-only contract binding to access the raw methods on -} - -// ContractIStrategyTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. -type ContractIStrategyTransactorRaw struct { - Contract *ContractIStrategyTransactor // Generic write-only contract binding to access the raw methods on -} - -// NewContractIStrategy creates a new instance of ContractIStrategy, bound to a specific deployed contract. -func NewContractIStrategy(address common.Address, backend bind.ContractBackend) (*ContractIStrategy, error) { - contract, err := bindContractIStrategy(address, backend, backend, backend) - if err != nil { - return nil, err - } - return &ContractIStrategy{ContractIStrategyCaller: ContractIStrategyCaller{contract: contract}, ContractIStrategyTransactor: ContractIStrategyTransactor{contract: contract}, ContractIStrategyFilterer: ContractIStrategyFilterer{contract: contract}}, nil -} - -// NewContractIStrategyCaller creates a new read-only instance of ContractIStrategy, bound to a specific deployed contract. -func NewContractIStrategyCaller(address common.Address, caller bind.ContractCaller) (*ContractIStrategyCaller, error) { - contract, err := bindContractIStrategy(address, caller, nil, nil) - if err != nil { - return nil, err - } - return &ContractIStrategyCaller{contract: contract}, nil -} - -// NewContractIStrategyTransactor creates a new write-only instance of ContractIStrategy, bound to a specific deployed contract. -func NewContractIStrategyTransactor(address common.Address, transactor bind.ContractTransactor) (*ContractIStrategyTransactor, error) { - contract, err := bindContractIStrategy(address, nil, transactor, nil) - if err != nil { - return nil, err - } - return &ContractIStrategyTransactor{contract: contract}, nil -} - -// NewContractIStrategyFilterer creates a new log filterer instance of ContractIStrategy, bound to a specific deployed contract. -func NewContractIStrategyFilterer(address common.Address, filterer bind.ContractFilterer) (*ContractIStrategyFilterer, error) { - contract, err := bindContractIStrategy(address, nil, nil, filterer) - if err != nil { - return nil, err - } - return &ContractIStrategyFilterer{contract: contract}, nil -} - -// bindContractIStrategy binds a generic wrapper to an already deployed contract. -func bindContractIStrategy(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { - parsed, err := ContractIStrategyMetaData.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 (_ContractIStrategy *ContractIStrategyRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _ContractIStrategy.Contract.ContractIStrategyCaller.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 (_ContractIStrategy *ContractIStrategyRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _ContractIStrategy.Contract.ContractIStrategyTransactor.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_ContractIStrategy *ContractIStrategyRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _ContractIStrategy.Contract.ContractIStrategyTransactor.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 (_ContractIStrategy *ContractIStrategyCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _ContractIStrategy.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 (_ContractIStrategy *ContractIStrategyTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _ContractIStrategy.Contract.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_ContractIStrategy *ContractIStrategyTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _ContractIStrategy.Contract.contract.Transact(opts, method, params...) -} - -// Explanation is a free data retrieval call binding the contract method 0xab5921e1. -// -// Solidity: function explanation() view returns(string) -func (_ContractIStrategy *ContractIStrategyCaller) Explanation(opts *bind.CallOpts) (string, error) { - var out []interface{} - err := _ContractIStrategy.contract.Call(opts, &out, "explanation") - - if err != nil { - return *new(string), err - } - - out0 := *abi.ConvertType(out[0], new(string)).(*string) - - return out0, err - -} - -// Explanation is a free data retrieval call binding the contract method 0xab5921e1. -// -// Solidity: function explanation() view returns(string) -func (_ContractIStrategy *ContractIStrategySession) Explanation() (string, error) { - return _ContractIStrategy.Contract.Explanation(&_ContractIStrategy.CallOpts) -} - -// Explanation is a free data retrieval call binding the contract method 0xab5921e1. -// -// Solidity: function explanation() view returns(string) -func (_ContractIStrategy *ContractIStrategyCallerSession) Explanation() (string, error) { - return _ContractIStrategy.Contract.Explanation(&_ContractIStrategy.CallOpts) -} - -// Shares is a free data retrieval call binding the contract method 0xce7c2ac2. -// -// Solidity: function shares(address user) view returns(uint256) -func (_ContractIStrategy *ContractIStrategyCaller) Shares(opts *bind.CallOpts, user common.Address) (*big.Int, error) { - var out []interface{} - err := _ContractIStrategy.contract.Call(opts, &out, "shares", user) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// Shares is a free data retrieval call binding the contract method 0xce7c2ac2. -// -// Solidity: function shares(address user) view returns(uint256) -func (_ContractIStrategy *ContractIStrategySession) Shares(user common.Address) (*big.Int, error) { - return _ContractIStrategy.Contract.Shares(&_ContractIStrategy.CallOpts, user) -} - -// Shares is a free data retrieval call binding the contract method 0xce7c2ac2. -// -// Solidity: function shares(address user) view returns(uint256) -func (_ContractIStrategy *ContractIStrategyCallerSession) Shares(user common.Address) (*big.Int, error) { - return _ContractIStrategy.Contract.Shares(&_ContractIStrategy.CallOpts, user) -} - -// SharesToUnderlyingView is a free data retrieval call binding the contract method 0x7a8b2637. -// -// Solidity: function sharesToUnderlyingView(uint256 amountShares) view returns(uint256) -func (_ContractIStrategy *ContractIStrategyCaller) SharesToUnderlyingView(opts *bind.CallOpts, amountShares *big.Int) (*big.Int, error) { - var out []interface{} - err := _ContractIStrategy.contract.Call(opts, &out, "sharesToUnderlyingView", amountShares) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// SharesToUnderlyingView is a free data retrieval call binding the contract method 0x7a8b2637. -// -// Solidity: function sharesToUnderlyingView(uint256 amountShares) view returns(uint256) -func (_ContractIStrategy *ContractIStrategySession) SharesToUnderlyingView(amountShares *big.Int) (*big.Int, error) { - return _ContractIStrategy.Contract.SharesToUnderlyingView(&_ContractIStrategy.CallOpts, amountShares) -} - -// SharesToUnderlyingView is a free data retrieval call binding the contract method 0x7a8b2637. -// -// Solidity: function sharesToUnderlyingView(uint256 amountShares) view returns(uint256) -func (_ContractIStrategy *ContractIStrategyCallerSession) SharesToUnderlyingView(amountShares *big.Int) (*big.Int, error) { - return _ContractIStrategy.Contract.SharesToUnderlyingView(&_ContractIStrategy.CallOpts, amountShares) -} - -// TotalShares is a free data retrieval call binding the contract method 0x3a98ef39. -// -// Solidity: function totalShares() view returns(uint256) -func (_ContractIStrategy *ContractIStrategyCaller) TotalShares(opts *bind.CallOpts) (*big.Int, error) { - var out []interface{} - err := _ContractIStrategy.contract.Call(opts, &out, "totalShares") - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// TotalShares is a free data retrieval call binding the contract method 0x3a98ef39. -// -// Solidity: function totalShares() view returns(uint256) -func (_ContractIStrategy *ContractIStrategySession) TotalShares() (*big.Int, error) { - return _ContractIStrategy.Contract.TotalShares(&_ContractIStrategy.CallOpts) -} - -// TotalShares is a free data retrieval call binding the contract method 0x3a98ef39. -// -// Solidity: function totalShares() view returns(uint256) -func (_ContractIStrategy *ContractIStrategyCallerSession) TotalShares() (*big.Int, error) { - return _ContractIStrategy.Contract.TotalShares(&_ContractIStrategy.CallOpts) -} - -// UnderlyingToSharesView is a free data retrieval call binding the contract method 0xe3dae51c. -// -// Solidity: function underlyingToSharesView(uint256 amountUnderlying) view returns(uint256) -func (_ContractIStrategy *ContractIStrategyCaller) UnderlyingToSharesView(opts *bind.CallOpts, amountUnderlying *big.Int) (*big.Int, error) { - var out []interface{} - err := _ContractIStrategy.contract.Call(opts, &out, "underlyingToSharesView", amountUnderlying) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// UnderlyingToSharesView is a free data retrieval call binding the contract method 0xe3dae51c. -// -// Solidity: function underlyingToSharesView(uint256 amountUnderlying) view returns(uint256) -func (_ContractIStrategy *ContractIStrategySession) UnderlyingToSharesView(amountUnderlying *big.Int) (*big.Int, error) { - return _ContractIStrategy.Contract.UnderlyingToSharesView(&_ContractIStrategy.CallOpts, amountUnderlying) -} - -// UnderlyingToSharesView is a free data retrieval call binding the contract method 0xe3dae51c. -// -// Solidity: function underlyingToSharesView(uint256 amountUnderlying) view returns(uint256) -func (_ContractIStrategy *ContractIStrategyCallerSession) UnderlyingToSharesView(amountUnderlying *big.Int) (*big.Int, error) { - return _ContractIStrategy.Contract.UnderlyingToSharesView(&_ContractIStrategy.CallOpts, amountUnderlying) -} - -// UnderlyingToken is a free data retrieval call binding the contract method 0x2495a599. -// -// Solidity: function underlyingToken() view returns(address) -func (_ContractIStrategy *ContractIStrategyCaller) UnderlyingToken(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _ContractIStrategy.contract.Call(opts, &out, "underlyingToken") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// UnderlyingToken is a free data retrieval call binding the contract method 0x2495a599. -// -// Solidity: function underlyingToken() view returns(address) -func (_ContractIStrategy *ContractIStrategySession) UnderlyingToken() (common.Address, error) { - return _ContractIStrategy.Contract.UnderlyingToken(&_ContractIStrategy.CallOpts) -} - -// UnderlyingToken is a free data retrieval call binding the contract method 0x2495a599. -// -// Solidity: function underlyingToken() view returns(address) -func (_ContractIStrategy *ContractIStrategyCallerSession) UnderlyingToken() (common.Address, error) { - return _ContractIStrategy.Contract.UnderlyingToken(&_ContractIStrategy.CallOpts) -} - -// UserUnderlyingView is a free data retrieval call binding the contract method 0x553ca5f8. -// -// Solidity: function userUnderlyingView(address user) view returns(uint256) -func (_ContractIStrategy *ContractIStrategyCaller) UserUnderlyingView(opts *bind.CallOpts, user common.Address) (*big.Int, error) { - var out []interface{} - err := _ContractIStrategy.contract.Call(opts, &out, "userUnderlyingView", user) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// UserUnderlyingView is a free data retrieval call binding the contract method 0x553ca5f8. -// -// Solidity: function userUnderlyingView(address user) view returns(uint256) -func (_ContractIStrategy *ContractIStrategySession) UserUnderlyingView(user common.Address) (*big.Int, error) { - return _ContractIStrategy.Contract.UserUnderlyingView(&_ContractIStrategy.CallOpts, user) -} - -// UserUnderlyingView is a free data retrieval call binding the contract method 0x553ca5f8. -// -// Solidity: function userUnderlyingView(address user) view returns(uint256) -func (_ContractIStrategy *ContractIStrategyCallerSession) UserUnderlyingView(user common.Address) (*big.Int, error) { - return _ContractIStrategy.Contract.UserUnderlyingView(&_ContractIStrategy.CallOpts, user) -} - -// Deposit is a paid mutator transaction binding the contract method 0x47e7ef24. -// -// Solidity: function deposit(address token, uint256 amount) returns(uint256) -func (_ContractIStrategy *ContractIStrategyTransactor) Deposit(opts *bind.TransactOpts, token common.Address, amount *big.Int) (*types.Transaction, error) { - return _ContractIStrategy.contract.Transact(opts, "deposit", token, amount) -} - -// Deposit is a paid mutator transaction binding the contract method 0x47e7ef24. -// -// Solidity: function deposit(address token, uint256 amount) returns(uint256) -func (_ContractIStrategy *ContractIStrategySession) Deposit(token common.Address, amount *big.Int) (*types.Transaction, error) { - return _ContractIStrategy.Contract.Deposit(&_ContractIStrategy.TransactOpts, token, amount) -} - -// Deposit is a paid mutator transaction binding the contract method 0x47e7ef24. -// -// Solidity: function deposit(address token, uint256 amount) returns(uint256) -func (_ContractIStrategy *ContractIStrategyTransactorSession) Deposit(token common.Address, amount *big.Int) (*types.Transaction, error) { - return _ContractIStrategy.Contract.Deposit(&_ContractIStrategy.TransactOpts, token, amount) -} - -// SharesToUnderlying is a paid mutator transaction binding the contract method 0xf3e73875. -// -// Solidity: function sharesToUnderlying(uint256 amountShares) returns(uint256) -func (_ContractIStrategy *ContractIStrategyTransactor) SharesToUnderlying(opts *bind.TransactOpts, amountShares *big.Int) (*types.Transaction, error) { - return _ContractIStrategy.contract.Transact(opts, "sharesToUnderlying", amountShares) -} - -// SharesToUnderlying is a paid mutator transaction binding the contract method 0xf3e73875. -// -// Solidity: function sharesToUnderlying(uint256 amountShares) returns(uint256) -func (_ContractIStrategy *ContractIStrategySession) SharesToUnderlying(amountShares *big.Int) (*types.Transaction, error) { - return _ContractIStrategy.Contract.SharesToUnderlying(&_ContractIStrategy.TransactOpts, amountShares) -} - -// SharesToUnderlying is a paid mutator transaction binding the contract method 0xf3e73875. -// -// Solidity: function sharesToUnderlying(uint256 amountShares) returns(uint256) -func (_ContractIStrategy *ContractIStrategyTransactorSession) SharesToUnderlying(amountShares *big.Int) (*types.Transaction, error) { - return _ContractIStrategy.Contract.SharesToUnderlying(&_ContractIStrategy.TransactOpts, amountShares) -} - -// UnderlyingToShares is a paid mutator transaction binding the contract method 0x8c871019. -// -// Solidity: function underlyingToShares(uint256 amountUnderlying) returns(uint256) -func (_ContractIStrategy *ContractIStrategyTransactor) UnderlyingToShares(opts *bind.TransactOpts, amountUnderlying *big.Int) (*types.Transaction, error) { - return _ContractIStrategy.contract.Transact(opts, "underlyingToShares", amountUnderlying) -} - -// UnderlyingToShares is a paid mutator transaction binding the contract method 0x8c871019. -// -// Solidity: function underlyingToShares(uint256 amountUnderlying) returns(uint256) -func (_ContractIStrategy *ContractIStrategySession) UnderlyingToShares(amountUnderlying *big.Int) (*types.Transaction, error) { - return _ContractIStrategy.Contract.UnderlyingToShares(&_ContractIStrategy.TransactOpts, amountUnderlying) -} - -// UnderlyingToShares is a paid mutator transaction binding the contract method 0x8c871019. -// -// Solidity: function underlyingToShares(uint256 amountUnderlying) returns(uint256) -func (_ContractIStrategy *ContractIStrategyTransactorSession) UnderlyingToShares(amountUnderlying *big.Int) (*types.Transaction, error) { - return _ContractIStrategy.Contract.UnderlyingToShares(&_ContractIStrategy.TransactOpts, amountUnderlying) -} - -// UserUnderlying is a paid mutator transaction binding the contract method 0x8f6a6240. -// -// Solidity: function userUnderlying(address user) returns(uint256) -func (_ContractIStrategy *ContractIStrategyTransactor) UserUnderlying(opts *bind.TransactOpts, user common.Address) (*types.Transaction, error) { - return _ContractIStrategy.contract.Transact(opts, "userUnderlying", user) -} - -// UserUnderlying is a paid mutator transaction binding the contract method 0x8f6a6240. -// -// Solidity: function userUnderlying(address user) returns(uint256) -func (_ContractIStrategy *ContractIStrategySession) UserUnderlying(user common.Address) (*types.Transaction, error) { - return _ContractIStrategy.Contract.UserUnderlying(&_ContractIStrategy.TransactOpts, user) -} - -// UserUnderlying is a paid mutator transaction binding the contract method 0x8f6a6240. -// -// Solidity: function userUnderlying(address user) returns(uint256) -func (_ContractIStrategy *ContractIStrategyTransactorSession) UserUnderlying(user common.Address) (*types.Transaction, error) { - return _ContractIStrategy.Contract.UserUnderlying(&_ContractIStrategy.TransactOpts, user) -} - -// Withdraw is a paid mutator transaction binding the contract method 0xd9caed12. -// -// Solidity: function withdraw(address recipient, address token, uint256 amountShares) returns() -func (_ContractIStrategy *ContractIStrategyTransactor) Withdraw(opts *bind.TransactOpts, recipient common.Address, token common.Address, amountShares *big.Int) (*types.Transaction, error) { - return _ContractIStrategy.contract.Transact(opts, "withdraw", recipient, token, amountShares) -} - -// Withdraw is a paid mutator transaction binding the contract method 0xd9caed12. -// -// Solidity: function withdraw(address recipient, address token, uint256 amountShares) returns() -func (_ContractIStrategy *ContractIStrategySession) Withdraw(recipient common.Address, token common.Address, amountShares *big.Int) (*types.Transaction, error) { - return _ContractIStrategy.Contract.Withdraw(&_ContractIStrategy.TransactOpts, recipient, token, amountShares) -} - -// Withdraw is a paid mutator transaction binding the contract method 0xd9caed12. -// -// Solidity: function withdraw(address recipient, address token, uint256 amountShares) returns() -func (_ContractIStrategy *ContractIStrategyTransactorSession) Withdraw(recipient common.Address, token common.Address, amountShares *big.Int) (*types.Transaction, error) { - return _ContractIStrategy.Contract.Withdraw(&_ContractIStrategy.TransactOpts, recipient, token, amountShares) -} diff --git a/contracts/bindings/OperatorStateRetriever/binding.go b/contracts/bindings/OperatorStateRetriever/binding.go deleted file mode 100644 index 1868105..0000000 --- a/contracts/bindings/OperatorStateRetriever/binding.go +++ /dev/null @@ -1,348 +0,0 @@ -// Code generated - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package contractOperatorStateRetriever - -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 -) - -// OperatorStateRetrieverCheckSignaturesIndices is an auto generated low-level Go binding around an user-defined struct. -type OperatorStateRetrieverCheckSignaturesIndices struct { - NonSignerQuorumBitmapIndices []uint32 - QuorumApkIndices []uint32 - TotalStakeIndices []uint32 - NonSignerStakeIndices [][]uint32 -} - -// OperatorStateRetrieverOperator is an auto generated low-level Go binding around an user-defined struct. -type OperatorStateRetrieverOperator struct { - Operator common.Address - OperatorId [32]byte - Stake *big.Int -} - -// ContractOperatorStateRetrieverMetaData contains all meta data concerning the ContractOperatorStateRetriever contract. -var ContractOperatorStateRetrieverMetaData = &bind.MetaData{ - ABI: "[{\"type\":\"function\",\"name\":\"getCheckSignaturesIndices\",\"inputs\":[{\"name\":\"registryCoordinator\",\"type\":\"address\",\"internalType\":\"contractIEORegistryCoordinator\"},{\"name\":\"referenceBlockNumber\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"quorumNumbers\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"nonSignerOperatorIds\",\"type\":\"bytes32[]\",\"internalType\":\"bytes32[]\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structOperatorStateRetriever.CheckSignaturesIndices\",\"components\":[{\"name\":\"nonSignerQuorumBitmapIndices\",\"type\":\"uint32[]\",\"internalType\":\"uint32[]\"},{\"name\":\"quorumApkIndices\",\"type\":\"uint32[]\",\"internalType\":\"uint32[]\"},{\"name\":\"totalStakeIndices\",\"type\":\"uint32[]\",\"internalType\":\"uint32[]\"},{\"name\":\"nonSignerStakeIndices\",\"type\":\"uint32[][]\",\"internalType\":\"uint32[][]\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getOperatorState\",\"inputs\":[{\"name\":\"registryCoordinator\",\"type\":\"address\",\"internalType\":\"contractIEORegistryCoordinator\"},{\"name\":\"quorumNumbers\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"blockNumber\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple[][]\",\"internalType\":\"structOperatorStateRetriever.Operator[][]\",\"components\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorId\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"stake\",\"type\":\"uint96\",\"internalType\":\"uint96\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getOperatorState\",\"inputs\":[{\"name\":\"registryCoordinator\",\"type\":\"address\",\"internalType\":\"contractIEORegistryCoordinator\"},{\"name\":\"operatorId\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"blockNumber\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"\",\"type\":\"tuple[][]\",\"internalType\":\"structOperatorStateRetriever.Operator[][]\",\"components\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorId\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"stake\",\"type\":\"uint96\",\"internalType\":\"uint96\"}]}],\"stateMutability\":\"view\"}]", - Bin: "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", -} - -// ContractOperatorStateRetrieverABI is the input ABI used to generate the binding from. -// Deprecated: Use ContractOperatorStateRetrieverMetaData.ABI instead. -var ContractOperatorStateRetrieverABI = ContractOperatorStateRetrieverMetaData.ABI - -// ContractOperatorStateRetrieverBin is the compiled bytecode used for deploying new contracts. -// Deprecated: Use ContractOperatorStateRetrieverMetaData.Bin instead. -var ContractOperatorStateRetrieverBin = ContractOperatorStateRetrieverMetaData.Bin - -// DeployContractOperatorStateRetriever deploys a new Ethereum contract, binding an instance of ContractOperatorStateRetriever to it. -func DeployContractOperatorStateRetriever(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ContractOperatorStateRetriever, error) { - parsed, err := ContractOperatorStateRetrieverMetaData.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(ContractOperatorStateRetrieverBin), backend) - if err != nil { - return common.Address{}, nil, nil, err - } - return address, tx, &ContractOperatorStateRetriever{ContractOperatorStateRetrieverCaller: ContractOperatorStateRetrieverCaller{contract: contract}, ContractOperatorStateRetrieverTransactor: ContractOperatorStateRetrieverTransactor{contract: contract}, ContractOperatorStateRetrieverFilterer: ContractOperatorStateRetrieverFilterer{contract: contract}}, nil -} - -// ContractOperatorStateRetrieverMethods is an auto generated interface around an Ethereum contract. -type ContractOperatorStateRetrieverMethods interface { - ContractOperatorStateRetrieverCalls - ContractOperatorStateRetrieverTransacts - ContractOperatorStateRetrieverFilters -} - -// ContractOperatorStateRetrieverCalls is an auto generated interface that defines the call methods available for an Ethereum contract. -type ContractOperatorStateRetrieverCalls interface { - GetCheckSignaturesIndices(opts *bind.CallOpts, registryCoordinator common.Address, referenceBlockNumber uint32, quorumNumbers []byte, nonSignerOperatorIds [][32]byte) (OperatorStateRetrieverCheckSignaturesIndices, error) - - GetOperatorState(opts *bind.CallOpts, registryCoordinator common.Address, quorumNumbers []byte, blockNumber uint32) ([][]OperatorStateRetrieverOperator, error) - - GetOperatorState0(opts *bind.CallOpts, registryCoordinator common.Address, operatorId [32]byte, blockNumber uint32) (*big.Int, [][]OperatorStateRetrieverOperator, error) -} - -// ContractOperatorStateRetrieverTransacts is an auto generated interface that defines the transact methods available for an Ethereum contract. -type ContractOperatorStateRetrieverTransacts interface { -} - -// ContractOperatorStateRetrieverFilterer is an auto generated interface that defines the log filtering methods available for an Ethereum contract. -type ContractOperatorStateRetrieverFilters interface { -} - -// ContractOperatorStateRetriever is an auto generated Go binding around an Ethereum contract. -type ContractOperatorStateRetriever struct { - ContractOperatorStateRetrieverCaller // Read-only binding to the contract - ContractOperatorStateRetrieverTransactor // Write-only binding to the contract - ContractOperatorStateRetrieverFilterer // Log filterer for contract events -} - -// ContractOperatorStateRetriever implements the ContractOperatorStateRetrieverMethods interface. -var _ ContractOperatorStateRetrieverMethods = (*ContractOperatorStateRetriever)(nil) - -// ContractOperatorStateRetrieverCaller is an auto generated read-only Go binding around an Ethereum contract. -type ContractOperatorStateRetrieverCaller struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// ContractOperatorStateRetrieverCaller implements the ContractOperatorStateRetrieverCalls interface. -var _ ContractOperatorStateRetrieverCalls = (*ContractOperatorStateRetrieverCaller)(nil) - -// ContractOperatorStateRetrieverTransactor is an auto generated write-only Go binding around an Ethereum contract. -type ContractOperatorStateRetrieverTransactor struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// ContractOperatorStateRetrieverTransactor implements the ContractOperatorStateRetrieverTransacts interface. -var _ ContractOperatorStateRetrieverTransacts = (*ContractOperatorStateRetrieverTransactor)(nil) - -// ContractOperatorStateRetrieverFilterer is an auto generated log filtering Go binding around an Ethereum contract events. -type ContractOperatorStateRetrieverFilterer struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// ContractOperatorStateRetrieverFilterer implements the ContractOperatorStateRetrieverFilters interface. -var _ ContractOperatorStateRetrieverFilters = (*ContractOperatorStateRetrieverFilterer)(nil) - -// ContractOperatorStateRetrieverSession is an auto generated Go binding around an Ethereum contract, -// with pre-set call and transact options. -type ContractOperatorStateRetrieverSession struct { - Contract *ContractOperatorStateRetriever // 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 -} - -// ContractOperatorStateRetrieverCallerSession is an auto generated read-only Go binding around an Ethereum contract, -// with pre-set call options. -type ContractOperatorStateRetrieverCallerSession struct { - Contract *ContractOperatorStateRetrieverCaller // Generic contract caller binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session -} - -// ContractOperatorStateRetrieverTransactorSession is an auto generated write-only Go binding around an Ethereum contract, -// with pre-set transact options. -type ContractOperatorStateRetrieverTransactorSession struct { - Contract *ContractOperatorStateRetrieverTransactor // Generic contract transactor binding to set the session for - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session -} - -// ContractOperatorStateRetrieverRaw is an auto generated low-level Go binding around an Ethereum contract. -type ContractOperatorStateRetrieverRaw struct { - Contract *ContractOperatorStateRetriever // Generic contract binding to access the raw methods on -} - -// ContractOperatorStateRetrieverCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. -type ContractOperatorStateRetrieverCallerRaw struct { - Contract *ContractOperatorStateRetrieverCaller // Generic read-only contract binding to access the raw methods on -} - -// ContractOperatorStateRetrieverTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. -type ContractOperatorStateRetrieverTransactorRaw struct { - Contract *ContractOperatorStateRetrieverTransactor // Generic write-only contract binding to access the raw methods on -} - -// NewContractOperatorStateRetriever creates a new instance of ContractOperatorStateRetriever, bound to a specific deployed contract. -func NewContractOperatorStateRetriever(address common.Address, backend bind.ContractBackend) (*ContractOperatorStateRetriever, error) { - contract, err := bindContractOperatorStateRetriever(address, backend, backend, backend) - if err != nil { - return nil, err - } - return &ContractOperatorStateRetriever{ContractOperatorStateRetrieverCaller: ContractOperatorStateRetrieverCaller{contract: contract}, ContractOperatorStateRetrieverTransactor: ContractOperatorStateRetrieverTransactor{contract: contract}, ContractOperatorStateRetrieverFilterer: ContractOperatorStateRetrieverFilterer{contract: contract}}, nil -} - -// NewContractOperatorStateRetrieverCaller creates a new read-only instance of ContractOperatorStateRetriever, bound to a specific deployed contract. -func NewContractOperatorStateRetrieverCaller(address common.Address, caller bind.ContractCaller) (*ContractOperatorStateRetrieverCaller, error) { - contract, err := bindContractOperatorStateRetriever(address, caller, nil, nil) - if err != nil { - return nil, err - } - return &ContractOperatorStateRetrieverCaller{contract: contract}, nil -} - -// NewContractOperatorStateRetrieverTransactor creates a new write-only instance of ContractOperatorStateRetriever, bound to a specific deployed contract. -func NewContractOperatorStateRetrieverTransactor(address common.Address, transactor bind.ContractTransactor) (*ContractOperatorStateRetrieverTransactor, error) { - contract, err := bindContractOperatorStateRetriever(address, nil, transactor, nil) - if err != nil { - return nil, err - } - return &ContractOperatorStateRetrieverTransactor{contract: contract}, nil -} - -// NewContractOperatorStateRetrieverFilterer creates a new log filterer instance of ContractOperatorStateRetriever, bound to a specific deployed contract. -func NewContractOperatorStateRetrieverFilterer(address common.Address, filterer bind.ContractFilterer) (*ContractOperatorStateRetrieverFilterer, error) { - contract, err := bindContractOperatorStateRetriever(address, nil, nil, filterer) - if err != nil { - return nil, err - } - return &ContractOperatorStateRetrieverFilterer{contract: contract}, nil -} - -// bindContractOperatorStateRetriever binds a generic wrapper to an already deployed contract. -func bindContractOperatorStateRetriever(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { - parsed, err := ContractOperatorStateRetrieverMetaData.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 (_ContractOperatorStateRetriever *ContractOperatorStateRetrieverRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _ContractOperatorStateRetriever.Contract.ContractOperatorStateRetrieverCaller.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 (_ContractOperatorStateRetriever *ContractOperatorStateRetrieverRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _ContractOperatorStateRetriever.Contract.ContractOperatorStateRetrieverTransactor.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_ContractOperatorStateRetriever *ContractOperatorStateRetrieverRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _ContractOperatorStateRetriever.Contract.ContractOperatorStateRetrieverTransactor.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 (_ContractOperatorStateRetriever *ContractOperatorStateRetrieverCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _ContractOperatorStateRetriever.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 (_ContractOperatorStateRetriever *ContractOperatorStateRetrieverTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _ContractOperatorStateRetriever.Contract.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_ContractOperatorStateRetriever *ContractOperatorStateRetrieverTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _ContractOperatorStateRetriever.Contract.contract.Transact(opts, method, params...) -} - -// GetCheckSignaturesIndices is a free data retrieval call binding the contract method 0x4f739f74. -// -// Solidity: function getCheckSignaturesIndices(address registryCoordinator, uint32 referenceBlockNumber, bytes quorumNumbers, bytes32[] nonSignerOperatorIds) view returns((uint32[],uint32[],uint32[],uint32[][])) -func (_ContractOperatorStateRetriever *ContractOperatorStateRetrieverCaller) GetCheckSignaturesIndices(opts *bind.CallOpts, registryCoordinator common.Address, referenceBlockNumber uint32, quorumNumbers []byte, nonSignerOperatorIds [][32]byte) (OperatorStateRetrieverCheckSignaturesIndices, error) { - var out []interface{} - err := _ContractOperatorStateRetriever.contract.Call(opts, &out, "getCheckSignaturesIndices", registryCoordinator, referenceBlockNumber, quorumNumbers, nonSignerOperatorIds) - - if err != nil { - return *new(OperatorStateRetrieverCheckSignaturesIndices), err - } - - out0 := *abi.ConvertType(out[0], new(OperatorStateRetrieverCheckSignaturesIndices)).(*OperatorStateRetrieverCheckSignaturesIndices) - - return out0, err - -} - -// GetCheckSignaturesIndices is a free data retrieval call binding the contract method 0x4f739f74. -// -// Solidity: function getCheckSignaturesIndices(address registryCoordinator, uint32 referenceBlockNumber, bytes quorumNumbers, bytes32[] nonSignerOperatorIds) view returns((uint32[],uint32[],uint32[],uint32[][])) -func (_ContractOperatorStateRetriever *ContractOperatorStateRetrieverSession) GetCheckSignaturesIndices(registryCoordinator common.Address, referenceBlockNumber uint32, quorumNumbers []byte, nonSignerOperatorIds [][32]byte) (OperatorStateRetrieverCheckSignaturesIndices, error) { - return _ContractOperatorStateRetriever.Contract.GetCheckSignaturesIndices(&_ContractOperatorStateRetriever.CallOpts, registryCoordinator, referenceBlockNumber, quorumNumbers, nonSignerOperatorIds) -} - -// GetCheckSignaturesIndices is a free data retrieval call binding the contract method 0x4f739f74. -// -// Solidity: function getCheckSignaturesIndices(address registryCoordinator, uint32 referenceBlockNumber, bytes quorumNumbers, bytes32[] nonSignerOperatorIds) view returns((uint32[],uint32[],uint32[],uint32[][])) -func (_ContractOperatorStateRetriever *ContractOperatorStateRetrieverCallerSession) GetCheckSignaturesIndices(registryCoordinator common.Address, referenceBlockNumber uint32, quorumNumbers []byte, nonSignerOperatorIds [][32]byte) (OperatorStateRetrieverCheckSignaturesIndices, error) { - return _ContractOperatorStateRetriever.Contract.GetCheckSignaturesIndices(&_ContractOperatorStateRetriever.CallOpts, registryCoordinator, referenceBlockNumber, quorumNumbers, nonSignerOperatorIds) -} - -// GetOperatorState is a free data retrieval call binding the contract method 0x3563b0d1. -// -// Solidity: function getOperatorState(address registryCoordinator, bytes quorumNumbers, uint32 blockNumber) view returns((address,bytes32,uint96)[][]) -func (_ContractOperatorStateRetriever *ContractOperatorStateRetrieverCaller) GetOperatorState(opts *bind.CallOpts, registryCoordinator common.Address, quorumNumbers []byte, blockNumber uint32) ([][]OperatorStateRetrieverOperator, error) { - var out []interface{} - err := _ContractOperatorStateRetriever.contract.Call(opts, &out, "getOperatorState", registryCoordinator, quorumNumbers, blockNumber) - - if err != nil { - return *new([][]OperatorStateRetrieverOperator), err - } - - out0 := *abi.ConvertType(out[0], new([][]OperatorStateRetrieverOperator)).(*[][]OperatorStateRetrieverOperator) - - return out0, err - -} - -// GetOperatorState is a free data retrieval call binding the contract method 0x3563b0d1. -// -// Solidity: function getOperatorState(address registryCoordinator, bytes quorumNumbers, uint32 blockNumber) view returns((address,bytes32,uint96)[][]) -func (_ContractOperatorStateRetriever *ContractOperatorStateRetrieverSession) GetOperatorState(registryCoordinator common.Address, quorumNumbers []byte, blockNumber uint32) ([][]OperatorStateRetrieverOperator, error) { - return _ContractOperatorStateRetriever.Contract.GetOperatorState(&_ContractOperatorStateRetriever.CallOpts, registryCoordinator, quorumNumbers, blockNumber) -} - -// GetOperatorState is a free data retrieval call binding the contract method 0x3563b0d1. -// -// Solidity: function getOperatorState(address registryCoordinator, bytes quorumNumbers, uint32 blockNumber) view returns((address,bytes32,uint96)[][]) -func (_ContractOperatorStateRetriever *ContractOperatorStateRetrieverCallerSession) GetOperatorState(registryCoordinator common.Address, quorumNumbers []byte, blockNumber uint32) ([][]OperatorStateRetrieverOperator, error) { - return _ContractOperatorStateRetriever.Contract.GetOperatorState(&_ContractOperatorStateRetriever.CallOpts, registryCoordinator, quorumNumbers, blockNumber) -} - -// GetOperatorState0 is a free data retrieval call binding the contract method 0xcefdc1d4. -// -// Solidity: function getOperatorState(address registryCoordinator, bytes32 operatorId, uint32 blockNumber) view returns(uint256, (address,bytes32,uint96)[][]) -func (_ContractOperatorStateRetriever *ContractOperatorStateRetrieverCaller) GetOperatorState0(opts *bind.CallOpts, registryCoordinator common.Address, operatorId [32]byte, blockNumber uint32) (*big.Int, [][]OperatorStateRetrieverOperator, error) { - var out []interface{} - err := _ContractOperatorStateRetriever.contract.Call(opts, &out, "getOperatorState0", registryCoordinator, operatorId, blockNumber) - - if err != nil { - return *new(*big.Int), *new([][]OperatorStateRetrieverOperator), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - out1 := *abi.ConvertType(out[1], new([][]OperatorStateRetrieverOperator)).(*[][]OperatorStateRetrieverOperator) - - return out0, out1, err - -} - -// GetOperatorState0 is a free data retrieval call binding the contract method 0xcefdc1d4. -// -// Solidity: function getOperatorState(address registryCoordinator, bytes32 operatorId, uint32 blockNumber) view returns(uint256, (address,bytes32,uint96)[][]) -func (_ContractOperatorStateRetriever *ContractOperatorStateRetrieverSession) GetOperatorState0(registryCoordinator common.Address, operatorId [32]byte, blockNumber uint32) (*big.Int, [][]OperatorStateRetrieverOperator, error) { - return _ContractOperatorStateRetriever.Contract.GetOperatorState0(&_ContractOperatorStateRetriever.CallOpts, registryCoordinator, operatorId, blockNumber) -} - -// GetOperatorState0 is a free data retrieval call binding the contract method 0xcefdc1d4. -// -// Solidity: function getOperatorState(address registryCoordinator, bytes32 operatorId, uint32 blockNumber) view returns(uint256, (address,bytes32,uint96)[][]) -func (_ContractOperatorStateRetriever *ContractOperatorStateRetrieverCallerSession) GetOperatorState0(registryCoordinator common.Address, operatorId [32]byte, blockNumber uint32) (*big.Int, [][]OperatorStateRetrieverOperator, error) { - return _ContractOperatorStateRetriever.Contract.GetOperatorState0(&_ContractOperatorStateRetriever.CallOpts, registryCoordinator, operatorId, blockNumber) -} diff --git a/contracts/bindings/ServiceManagerBase/binding.go b/contracts/bindings/ServiceManagerBase/binding.go deleted file mode 100644 index 0a77c49..0000000 --- a/contracts/bindings/ServiceManagerBase/binding.go +++ /dev/null @@ -1,758 +0,0 @@ -// Code generated - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package contractServiceManagerBase - -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 -) - -// ISignatureUtilsSignatureWithSaltAndExpiry is an auto generated low-level Go binding around an user-defined struct. -type ISignatureUtilsSignatureWithSaltAndExpiry struct { - Signature []byte - Salt [32]byte - Expiry *big.Int -} - -// ContractServiceManagerBaseMetaData contains all meta data concerning the ContractServiceManagerBase contract. -var ContractServiceManagerBaseMetaData = &bind.MetaData{ - ABI: "[{\"type\":\"function\",\"name\":\"avsDirectory\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"deregisterOperatorFromAVS\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"getOperatorRestakedStrategies\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address[]\",\"internalType\":\"address[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getRestakeableStrategies\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address[]\",\"internalType\":\"address[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"owner\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"registerOperatorToAVS\",\"inputs\":[{\"name\":\"operator\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"operatorSignature\",\"type\":\"tuple\",\"internalType\":\"structISignatureUtils.SignatureWithSaltAndExpiry\",\"components\":[{\"name\":\"signature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"salt\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"renounceOwnership\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setMetadataURI\",\"inputs\":[{\"name\":\"_metadataURI\",\"type\":\"string\",\"internalType\":\"string\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"transferOwnership\",\"inputs\":[{\"name\":\"newOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"Initialized\",\"inputs\":[{\"name\":\"version\",\"type\":\"uint8\",\"indexed\":false,\"internalType\":\"uint8\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OwnershipTransferred\",\"inputs\":[{\"name\":\"previousOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false}]", -} - -// ContractServiceManagerBaseABI is the input ABI used to generate the binding from. -// Deprecated: Use ContractServiceManagerBaseMetaData.ABI instead. -var ContractServiceManagerBaseABI = ContractServiceManagerBaseMetaData.ABI - -// ContractServiceManagerBaseMethods is an auto generated interface around an Ethereum contract. -type ContractServiceManagerBaseMethods interface { - ContractServiceManagerBaseCalls - ContractServiceManagerBaseTransacts - ContractServiceManagerBaseFilters -} - -// ContractServiceManagerBaseCalls is an auto generated interface that defines the call methods available for an Ethereum contract. -type ContractServiceManagerBaseCalls interface { - AvsDirectory(opts *bind.CallOpts) (common.Address, error) - - GetOperatorRestakedStrategies(opts *bind.CallOpts, operator common.Address) ([]common.Address, error) - - GetRestakeableStrategies(opts *bind.CallOpts) ([]common.Address, error) - - Owner(opts *bind.CallOpts) (common.Address, error) -} - -// ContractServiceManagerBaseTransacts is an auto generated interface that defines the transact methods available for an Ethereum contract. -type ContractServiceManagerBaseTransacts interface { - DeregisterOperatorFromAVS(opts *bind.TransactOpts, operator common.Address) (*types.Transaction, error) - - RegisterOperatorToAVS(opts *bind.TransactOpts, operator common.Address, operatorSignature ISignatureUtilsSignatureWithSaltAndExpiry) (*types.Transaction, error) - - RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) - - SetMetadataURI(opts *bind.TransactOpts, _metadataURI string) (*types.Transaction, error) - - TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) -} - -// ContractServiceManagerBaseFilterer is an auto generated interface that defines the log filtering methods available for an Ethereum contract. -type ContractServiceManagerBaseFilters interface { - FilterInitialized(opts *bind.FilterOpts) (*ContractServiceManagerBaseInitializedIterator, error) - WatchInitialized(opts *bind.WatchOpts, sink chan<- *ContractServiceManagerBaseInitialized) (event.Subscription, error) - ParseInitialized(log types.Log) (*ContractServiceManagerBaseInitialized, error) - - FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*ContractServiceManagerBaseOwnershipTransferredIterator, error) - WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *ContractServiceManagerBaseOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) - ParseOwnershipTransferred(log types.Log) (*ContractServiceManagerBaseOwnershipTransferred, error) -} - -// ContractServiceManagerBase is an auto generated Go binding around an Ethereum contract. -type ContractServiceManagerBase struct { - ContractServiceManagerBaseCaller // Read-only binding to the contract - ContractServiceManagerBaseTransactor // Write-only binding to the contract - ContractServiceManagerBaseFilterer // Log filterer for contract events -} - -// ContractServiceManagerBase implements the ContractServiceManagerBaseMethods interface. -var _ ContractServiceManagerBaseMethods = (*ContractServiceManagerBase)(nil) - -// ContractServiceManagerBaseCaller is an auto generated read-only Go binding around an Ethereum contract. -type ContractServiceManagerBaseCaller struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// ContractServiceManagerBaseCaller implements the ContractServiceManagerBaseCalls interface. -var _ ContractServiceManagerBaseCalls = (*ContractServiceManagerBaseCaller)(nil) - -// ContractServiceManagerBaseTransactor is an auto generated write-only Go binding around an Ethereum contract. -type ContractServiceManagerBaseTransactor struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// ContractServiceManagerBaseTransactor implements the ContractServiceManagerBaseTransacts interface. -var _ ContractServiceManagerBaseTransacts = (*ContractServiceManagerBaseTransactor)(nil) - -// ContractServiceManagerBaseFilterer is an auto generated log filtering Go binding around an Ethereum contract events. -type ContractServiceManagerBaseFilterer struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// ContractServiceManagerBaseFilterer implements the ContractServiceManagerBaseFilters interface. -var _ ContractServiceManagerBaseFilters = (*ContractServiceManagerBaseFilterer)(nil) - -// ContractServiceManagerBaseSession is an auto generated Go binding around an Ethereum contract, -// with pre-set call and transact options. -type ContractServiceManagerBaseSession struct { - Contract *ContractServiceManagerBase // 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 -} - -// ContractServiceManagerBaseCallerSession is an auto generated read-only Go binding around an Ethereum contract, -// with pre-set call options. -type ContractServiceManagerBaseCallerSession struct { - Contract *ContractServiceManagerBaseCaller // Generic contract caller binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session -} - -// ContractServiceManagerBaseTransactorSession is an auto generated write-only Go binding around an Ethereum contract, -// with pre-set transact options. -type ContractServiceManagerBaseTransactorSession struct { - Contract *ContractServiceManagerBaseTransactor // Generic contract transactor binding to set the session for - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session -} - -// ContractServiceManagerBaseRaw is an auto generated low-level Go binding around an Ethereum contract. -type ContractServiceManagerBaseRaw struct { - Contract *ContractServiceManagerBase // Generic contract binding to access the raw methods on -} - -// ContractServiceManagerBaseCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. -type ContractServiceManagerBaseCallerRaw struct { - Contract *ContractServiceManagerBaseCaller // Generic read-only contract binding to access the raw methods on -} - -// ContractServiceManagerBaseTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. -type ContractServiceManagerBaseTransactorRaw struct { - Contract *ContractServiceManagerBaseTransactor // Generic write-only contract binding to access the raw methods on -} - -// NewContractServiceManagerBase creates a new instance of ContractServiceManagerBase, bound to a specific deployed contract. -func NewContractServiceManagerBase(address common.Address, backend bind.ContractBackend) (*ContractServiceManagerBase, error) { - contract, err := bindContractServiceManagerBase(address, backend, backend, backend) - if err != nil { - return nil, err - } - return &ContractServiceManagerBase{ContractServiceManagerBaseCaller: ContractServiceManagerBaseCaller{contract: contract}, ContractServiceManagerBaseTransactor: ContractServiceManagerBaseTransactor{contract: contract}, ContractServiceManagerBaseFilterer: ContractServiceManagerBaseFilterer{contract: contract}}, nil -} - -// NewContractServiceManagerBaseCaller creates a new read-only instance of ContractServiceManagerBase, bound to a specific deployed contract. -func NewContractServiceManagerBaseCaller(address common.Address, caller bind.ContractCaller) (*ContractServiceManagerBaseCaller, error) { - contract, err := bindContractServiceManagerBase(address, caller, nil, nil) - if err != nil { - return nil, err - } - return &ContractServiceManagerBaseCaller{contract: contract}, nil -} - -// NewContractServiceManagerBaseTransactor creates a new write-only instance of ContractServiceManagerBase, bound to a specific deployed contract. -func NewContractServiceManagerBaseTransactor(address common.Address, transactor bind.ContractTransactor) (*ContractServiceManagerBaseTransactor, error) { - contract, err := bindContractServiceManagerBase(address, nil, transactor, nil) - if err != nil { - return nil, err - } - return &ContractServiceManagerBaseTransactor{contract: contract}, nil -} - -// NewContractServiceManagerBaseFilterer creates a new log filterer instance of ContractServiceManagerBase, bound to a specific deployed contract. -func NewContractServiceManagerBaseFilterer(address common.Address, filterer bind.ContractFilterer) (*ContractServiceManagerBaseFilterer, error) { - contract, err := bindContractServiceManagerBase(address, nil, nil, filterer) - if err != nil { - return nil, err - } - return &ContractServiceManagerBaseFilterer{contract: contract}, nil -} - -// bindContractServiceManagerBase binds a generic wrapper to an already deployed contract. -func bindContractServiceManagerBase(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { - parsed, err := ContractServiceManagerBaseMetaData.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 (_ContractServiceManagerBase *ContractServiceManagerBaseRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _ContractServiceManagerBase.Contract.ContractServiceManagerBaseCaller.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 (_ContractServiceManagerBase *ContractServiceManagerBaseRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _ContractServiceManagerBase.Contract.ContractServiceManagerBaseTransactor.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_ContractServiceManagerBase *ContractServiceManagerBaseRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _ContractServiceManagerBase.Contract.ContractServiceManagerBaseTransactor.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 (_ContractServiceManagerBase *ContractServiceManagerBaseCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _ContractServiceManagerBase.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 (_ContractServiceManagerBase *ContractServiceManagerBaseTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _ContractServiceManagerBase.Contract.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_ContractServiceManagerBase *ContractServiceManagerBaseTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _ContractServiceManagerBase.Contract.contract.Transact(opts, method, params...) -} - -// AvsDirectory is a free data retrieval call binding the contract method 0x6b3aa72e. -// -// Solidity: function avsDirectory() view returns(address) -func (_ContractServiceManagerBase *ContractServiceManagerBaseCaller) AvsDirectory(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _ContractServiceManagerBase.contract.Call(opts, &out, "avsDirectory") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// AvsDirectory is a free data retrieval call binding the contract method 0x6b3aa72e. -// -// Solidity: function avsDirectory() view returns(address) -func (_ContractServiceManagerBase *ContractServiceManagerBaseSession) AvsDirectory() (common.Address, error) { - return _ContractServiceManagerBase.Contract.AvsDirectory(&_ContractServiceManagerBase.CallOpts) -} - -// AvsDirectory is a free data retrieval call binding the contract method 0x6b3aa72e. -// -// Solidity: function avsDirectory() view returns(address) -func (_ContractServiceManagerBase *ContractServiceManagerBaseCallerSession) AvsDirectory() (common.Address, error) { - return _ContractServiceManagerBase.Contract.AvsDirectory(&_ContractServiceManagerBase.CallOpts) -} - -// GetOperatorRestakedStrategies is a free data retrieval call binding the contract method 0x33cfb7b7. -// -// Solidity: function getOperatorRestakedStrategies(address operator) view returns(address[]) -func (_ContractServiceManagerBase *ContractServiceManagerBaseCaller) GetOperatorRestakedStrategies(opts *bind.CallOpts, operator common.Address) ([]common.Address, error) { - var out []interface{} - err := _ContractServiceManagerBase.contract.Call(opts, &out, "getOperatorRestakedStrategies", operator) - - if err != nil { - return *new([]common.Address), err - } - - out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address) - - return out0, err - -} - -// GetOperatorRestakedStrategies is a free data retrieval call binding the contract method 0x33cfb7b7. -// -// Solidity: function getOperatorRestakedStrategies(address operator) view returns(address[]) -func (_ContractServiceManagerBase *ContractServiceManagerBaseSession) GetOperatorRestakedStrategies(operator common.Address) ([]common.Address, error) { - return _ContractServiceManagerBase.Contract.GetOperatorRestakedStrategies(&_ContractServiceManagerBase.CallOpts, operator) -} - -// GetOperatorRestakedStrategies is a free data retrieval call binding the contract method 0x33cfb7b7. -// -// Solidity: function getOperatorRestakedStrategies(address operator) view returns(address[]) -func (_ContractServiceManagerBase *ContractServiceManagerBaseCallerSession) GetOperatorRestakedStrategies(operator common.Address) ([]common.Address, error) { - return _ContractServiceManagerBase.Contract.GetOperatorRestakedStrategies(&_ContractServiceManagerBase.CallOpts, operator) -} - -// GetRestakeableStrategies is a free data retrieval call binding the contract method 0xe481af9d. -// -// Solidity: function getRestakeableStrategies() view returns(address[]) -func (_ContractServiceManagerBase *ContractServiceManagerBaseCaller) GetRestakeableStrategies(opts *bind.CallOpts) ([]common.Address, error) { - var out []interface{} - err := _ContractServiceManagerBase.contract.Call(opts, &out, "getRestakeableStrategies") - - if err != nil { - return *new([]common.Address), err - } - - out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address) - - return out0, err - -} - -// GetRestakeableStrategies is a free data retrieval call binding the contract method 0xe481af9d. -// -// Solidity: function getRestakeableStrategies() view returns(address[]) -func (_ContractServiceManagerBase *ContractServiceManagerBaseSession) GetRestakeableStrategies() ([]common.Address, error) { - return _ContractServiceManagerBase.Contract.GetRestakeableStrategies(&_ContractServiceManagerBase.CallOpts) -} - -// GetRestakeableStrategies is a free data retrieval call binding the contract method 0xe481af9d. -// -// Solidity: function getRestakeableStrategies() view returns(address[]) -func (_ContractServiceManagerBase *ContractServiceManagerBaseCallerSession) GetRestakeableStrategies() ([]common.Address, error) { - return _ContractServiceManagerBase.Contract.GetRestakeableStrategies(&_ContractServiceManagerBase.CallOpts) -} - -// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. -// -// Solidity: function owner() view returns(address) -func (_ContractServiceManagerBase *ContractServiceManagerBaseCaller) Owner(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _ContractServiceManagerBase.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 (_ContractServiceManagerBase *ContractServiceManagerBaseSession) Owner() (common.Address, error) { - return _ContractServiceManagerBase.Contract.Owner(&_ContractServiceManagerBase.CallOpts) -} - -// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. -// -// Solidity: function owner() view returns(address) -func (_ContractServiceManagerBase *ContractServiceManagerBaseCallerSession) Owner() (common.Address, error) { - return _ContractServiceManagerBase.Contract.Owner(&_ContractServiceManagerBase.CallOpts) -} - -// DeregisterOperatorFromAVS is a paid mutator transaction binding the contract method 0xa364f4da. -// -// Solidity: function deregisterOperatorFromAVS(address operator) returns() -func (_ContractServiceManagerBase *ContractServiceManagerBaseTransactor) DeregisterOperatorFromAVS(opts *bind.TransactOpts, operator common.Address) (*types.Transaction, error) { - return _ContractServiceManagerBase.contract.Transact(opts, "deregisterOperatorFromAVS", operator) -} - -// DeregisterOperatorFromAVS is a paid mutator transaction binding the contract method 0xa364f4da. -// -// Solidity: function deregisterOperatorFromAVS(address operator) returns() -func (_ContractServiceManagerBase *ContractServiceManagerBaseSession) DeregisterOperatorFromAVS(operator common.Address) (*types.Transaction, error) { - return _ContractServiceManagerBase.Contract.DeregisterOperatorFromAVS(&_ContractServiceManagerBase.TransactOpts, operator) -} - -// DeregisterOperatorFromAVS is a paid mutator transaction binding the contract method 0xa364f4da. -// -// Solidity: function deregisterOperatorFromAVS(address operator) returns() -func (_ContractServiceManagerBase *ContractServiceManagerBaseTransactorSession) DeregisterOperatorFromAVS(operator common.Address) (*types.Transaction, error) { - return _ContractServiceManagerBase.Contract.DeregisterOperatorFromAVS(&_ContractServiceManagerBase.TransactOpts, operator) -} - -// RegisterOperatorToAVS is a paid mutator transaction binding the contract method 0x9926ee7d. -// -// Solidity: function registerOperatorToAVS(address operator, (bytes,bytes32,uint256) operatorSignature) returns() -func (_ContractServiceManagerBase *ContractServiceManagerBaseTransactor) RegisterOperatorToAVS(opts *bind.TransactOpts, operator common.Address, operatorSignature ISignatureUtilsSignatureWithSaltAndExpiry) (*types.Transaction, error) { - return _ContractServiceManagerBase.contract.Transact(opts, "registerOperatorToAVS", operator, operatorSignature) -} - -// RegisterOperatorToAVS is a paid mutator transaction binding the contract method 0x9926ee7d. -// -// Solidity: function registerOperatorToAVS(address operator, (bytes,bytes32,uint256) operatorSignature) returns() -func (_ContractServiceManagerBase *ContractServiceManagerBaseSession) RegisterOperatorToAVS(operator common.Address, operatorSignature ISignatureUtilsSignatureWithSaltAndExpiry) (*types.Transaction, error) { - return _ContractServiceManagerBase.Contract.RegisterOperatorToAVS(&_ContractServiceManagerBase.TransactOpts, operator, operatorSignature) -} - -// RegisterOperatorToAVS is a paid mutator transaction binding the contract method 0x9926ee7d. -// -// Solidity: function registerOperatorToAVS(address operator, (bytes,bytes32,uint256) operatorSignature) returns() -func (_ContractServiceManagerBase *ContractServiceManagerBaseTransactorSession) RegisterOperatorToAVS(operator common.Address, operatorSignature ISignatureUtilsSignatureWithSaltAndExpiry) (*types.Transaction, error) { - return _ContractServiceManagerBase.Contract.RegisterOperatorToAVS(&_ContractServiceManagerBase.TransactOpts, operator, operatorSignature) -} - -// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. -// -// Solidity: function renounceOwnership() returns() -func (_ContractServiceManagerBase *ContractServiceManagerBaseTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) { - return _ContractServiceManagerBase.contract.Transact(opts, "renounceOwnership") -} - -// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. -// -// Solidity: function renounceOwnership() returns() -func (_ContractServiceManagerBase *ContractServiceManagerBaseSession) RenounceOwnership() (*types.Transaction, error) { - return _ContractServiceManagerBase.Contract.RenounceOwnership(&_ContractServiceManagerBase.TransactOpts) -} - -// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. -// -// Solidity: function renounceOwnership() returns() -func (_ContractServiceManagerBase *ContractServiceManagerBaseTransactorSession) RenounceOwnership() (*types.Transaction, error) { - return _ContractServiceManagerBase.Contract.RenounceOwnership(&_ContractServiceManagerBase.TransactOpts) -} - -// SetMetadataURI is a paid mutator transaction binding the contract method 0x750521f5. -// -// Solidity: function setMetadataURI(string _metadataURI) returns() -func (_ContractServiceManagerBase *ContractServiceManagerBaseTransactor) SetMetadataURI(opts *bind.TransactOpts, _metadataURI string) (*types.Transaction, error) { - return _ContractServiceManagerBase.contract.Transact(opts, "setMetadataURI", _metadataURI) -} - -// SetMetadataURI is a paid mutator transaction binding the contract method 0x750521f5. -// -// Solidity: function setMetadataURI(string _metadataURI) returns() -func (_ContractServiceManagerBase *ContractServiceManagerBaseSession) SetMetadataURI(_metadataURI string) (*types.Transaction, error) { - return _ContractServiceManagerBase.Contract.SetMetadataURI(&_ContractServiceManagerBase.TransactOpts, _metadataURI) -} - -// SetMetadataURI is a paid mutator transaction binding the contract method 0x750521f5. -// -// Solidity: function setMetadataURI(string _metadataURI) returns() -func (_ContractServiceManagerBase *ContractServiceManagerBaseTransactorSession) SetMetadataURI(_metadataURI string) (*types.Transaction, error) { - return _ContractServiceManagerBase.Contract.SetMetadataURI(&_ContractServiceManagerBase.TransactOpts, _metadataURI) -} - -// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. -// -// Solidity: function transferOwnership(address newOwner) returns() -func (_ContractServiceManagerBase *ContractServiceManagerBaseTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { - return _ContractServiceManagerBase.contract.Transact(opts, "transferOwnership", newOwner) -} - -// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. -// -// Solidity: function transferOwnership(address newOwner) returns() -func (_ContractServiceManagerBase *ContractServiceManagerBaseSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { - return _ContractServiceManagerBase.Contract.TransferOwnership(&_ContractServiceManagerBase.TransactOpts, newOwner) -} - -// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. -// -// Solidity: function transferOwnership(address newOwner) returns() -func (_ContractServiceManagerBase *ContractServiceManagerBaseTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { - return _ContractServiceManagerBase.Contract.TransferOwnership(&_ContractServiceManagerBase.TransactOpts, newOwner) -} - -// ContractServiceManagerBaseInitializedIterator is returned from FilterInitialized and is used to iterate over the raw logs and unpacked data for Initialized events raised by the ContractServiceManagerBase contract. -type ContractServiceManagerBaseInitializedIterator struct { - Event *ContractServiceManagerBaseInitialized // 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 *ContractServiceManagerBaseInitializedIterator) 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(ContractServiceManagerBaseInitialized) - 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(ContractServiceManagerBaseInitialized) - 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 *ContractServiceManagerBaseInitializedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ContractServiceManagerBaseInitializedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ContractServiceManagerBaseInitialized represents a Initialized event raised by the ContractServiceManagerBase contract. -type ContractServiceManagerBaseInitialized 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 (_ContractServiceManagerBase *ContractServiceManagerBaseFilterer) FilterInitialized(opts *bind.FilterOpts) (*ContractServiceManagerBaseInitializedIterator, error) { - - logs, sub, err := _ContractServiceManagerBase.contract.FilterLogs(opts, "Initialized") - if err != nil { - return nil, err - } - return &ContractServiceManagerBaseInitializedIterator{contract: _ContractServiceManagerBase.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 (_ContractServiceManagerBase *ContractServiceManagerBaseFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *ContractServiceManagerBaseInitialized) (event.Subscription, error) { - - logs, sub, err := _ContractServiceManagerBase.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(ContractServiceManagerBaseInitialized) - if err := _ContractServiceManagerBase.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 (_ContractServiceManagerBase *ContractServiceManagerBaseFilterer) ParseInitialized(log types.Log) (*ContractServiceManagerBaseInitialized, error) { - event := new(ContractServiceManagerBaseInitialized) - if err := _ContractServiceManagerBase.contract.UnpackLog(event, "Initialized", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ContractServiceManagerBaseOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the ContractServiceManagerBase contract. -type ContractServiceManagerBaseOwnershipTransferredIterator struct { - Event *ContractServiceManagerBaseOwnershipTransferred // 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 *ContractServiceManagerBaseOwnershipTransferredIterator) 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(ContractServiceManagerBaseOwnershipTransferred) - 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(ContractServiceManagerBaseOwnershipTransferred) - 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 *ContractServiceManagerBaseOwnershipTransferredIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ContractServiceManagerBaseOwnershipTransferredIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ContractServiceManagerBaseOwnershipTransferred represents a OwnershipTransferred event raised by the ContractServiceManagerBase contract. -type ContractServiceManagerBaseOwnershipTransferred 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 (_ContractServiceManagerBase *ContractServiceManagerBaseFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*ContractServiceManagerBaseOwnershipTransferredIterator, 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 := _ContractServiceManagerBase.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) - if err != nil { - return nil, err - } - return &ContractServiceManagerBaseOwnershipTransferredIterator{contract: _ContractServiceManagerBase.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 (_ContractServiceManagerBase *ContractServiceManagerBaseFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *ContractServiceManagerBaseOwnershipTransferred, 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 := _ContractServiceManagerBase.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(ContractServiceManagerBaseOwnershipTransferred) - if err := _ContractServiceManagerBase.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 (_ContractServiceManagerBase *ContractServiceManagerBaseFilterer) ParseOwnershipTransferred(log types.Log) (*ContractServiceManagerBaseOwnershipTransferred, error) { - event := new(ContractServiceManagerBaseOwnershipTransferred) - if err := _ContractServiceManagerBase.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} diff --git a/contracts/bindings/StrategyManager/binding.go b/contracts/bindings/StrategyManager/binding.go deleted file mode 100644 index 2099489..0000000 --- a/contracts/bindings/StrategyManager/binding.go +++ /dev/null @@ -1,2726 +0,0 @@ -// Code generated - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package contractStrategyManager - -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 -) - -// IStrategyManagerDeprecatedStructQueuedWithdrawal is an auto generated low-level Go binding around an user-defined struct. -type IStrategyManagerDeprecatedStructQueuedWithdrawal struct { - Strategies []common.Address - Shares []*big.Int - Staker common.Address - WithdrawerAndNonce IStrategyManagerDeprecatedStructWithdrawerAndNonce - WithdrawalStartBlock uint32 - DelegatedAddress common.Address -} - -// IStrategyManagerDeprecatedStructWithdrawerAndNonce is an auto generated low-level Go binding around an user-defined struct. -type IStrategyManagerDeprecatedStructWithdrawerAndNonce struct { - Withdrawer common.Address - Nonce *big.Int -} - -// ContractStrategyManagerMetaData contains all meta data concerning the ContractStrategyManager contract. -var ContractStrategyManagerMetaData = &bind.MetaData{ - ABI: "[{\"type\":\"constructor\",\"inputs\":[{\"name\":\"_delegation\",\"type\":\"address\",\"internalType\":\"contractIDelegationManager\"},{\"name\":\"_eigenPodManager\",\"type\":\"address\",\"internalType\":\"contractIEigenPodManager\"},{\"name\":\"_slasher\",\"type\":\"address\",\"internalType\":\"contractISlasher\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"DEPOSIT_TYPEHASH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"DOMAIN_TYPEHASH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"addShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"shares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"addStrategiesToDepositWhitelist\",\"inputs\":[{\"name\":\"strategiesToWhitelist\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"thirdPartyTransfersForbiddenValues\",\"type\":\"bool[]\",\"internalType\":\"bool[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"calculateWithdrawalRoot\",\"inputs\":[{\"name\":\"queuedWithdrawal\",\"type\":\"tuple\",\"internalType\":\"structIStrategyManager.DeprecatedStruct_QueuedWithdrawal\",\"components\":[{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"shares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"},{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"withdrawerAndNonce\",\"type\":\"tuple\",\"internalType\":\"structIStrategyManager.DeprecatedStruct_WithdrawerAndNonce\",\"components\":[{\"name\":\"withdrawer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"nonce\",\"type\":\"uint96\",\"internalType\":\"uint96\"}]},{\"name\":\"withdrawalStartBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"delegatedAddress\",\"type\":\"address\",\"internalType\":\"address\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"pure\"},{\"type\":\"function\",\"name\":\"delegation\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIDelegationManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"depositIntoStrategy\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"shares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"depositIntoStrategyWithSignature\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"expiry\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"signature\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[{\"name\":\"shares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"domainSeparator\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"eigenPodManager\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIEigenPodManager\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getDeposits\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[{\"name\":\"initialOwner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"initialStrategyWhitelister\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"_pauserRegistry\",\"type\":\"address\",\"internalType\":\"contractIPauserRegistry\"},{\"name\":\"initialPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"migrateQueuedWithdrawal\",\"inputs\":[{\"name\":\"queuedWithdrawal\",\"type\":\"tuple\",\"internalType\":\"structIStrategyManager.DeprecatedStruct_QueuedWithdrawal\",\"components\":[{\"name\":\"strategies\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"},{\"name\":\"shares\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"},{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"withdrawerAndNonce\",\"type\":\"tuple\",\"internalType\":\"structIStrategyManager.DeprecatedStruct_WithdrawerAndNonce\",\"components\":[{\"name\":\"withdrawer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"nonce\",\"type\":\"uint96\",\"internalType\":\"uint96\"}]},{\"name\":\"withdrawalStartBlock\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"delegatedAddress\",\"type\":\"address\",\"internalType\":\"address\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"},{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"nonces\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"owner\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pause\",\"inputs\":[{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"pauseAll\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[{\"name\":\"index\",\"type\":\"uint8\",\"internalType\":\"uint8\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pauserRegistry\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIPauserRegistry\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"removeShares\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"shares\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"removeStrategiesFromDepositWhitelist\",\"inputs\":[{\"name\":\"strategiesToRemoveFromWhitelist\",\"type\":\"address[]\",\"internalType\":\"contractIStrategy[]\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"renounceOwnership\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setPauserRegistry\",\"inputs\":[{\"name\":\"newPauserRegistry\",\"type\":\"address\",\"internalType\":\"contractIPauserRegistry\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setStrategyWhitelister\",\"inputs\":[{\"name\":\"newStrategyWhitelister\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setThirdPartyTransfersForbidden\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"value\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"slasher\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractISlasher\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"stakerStrategyList\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"stakerStrategyListLength\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"stakerStrategyShares\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"strategyIsWhitelistedForDeposit\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"strategyWhitelister\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"thirdPartyTransfersForbidden\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"transferOwnership\",\"inputs\":[{\"name\":\"newOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"unpause\",\"inputs\":[{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"withdrawSharesAsTokens\",\"inputs\":[{\"name\":\"recipient\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"strategy\",\"type\":\"address\",\"internalType\":\"contractIStrategy\"},{\"name\":\"shares\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"token\",\"type\":\"address\",\"internalType\":\"contractIERC20\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"withdrawalRootPending\",\"inputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"event\",\"name\":\"Deposit\",\"inputs\":[{\"name\":\"staker\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"token\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIERC20\"},{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"shares\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Initialized\",\"inputs\":[{\"name\":\"version\",\"type\":\"uint8\",\"indexed\":false,\"internalType\":\"uint8\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OwnershipTransferred\",\"inputs\":[{\"name\":\"previousOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Paused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"PauserRegistrySet\",\"inputs\":[{\"name\":\"pauserRegistry\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIPauserRegistry\"},{\"name\":\"newPauserRegistry\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIPauserRegistry\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StrategyAddedToDepositWhitelist\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StrategyRemovedFromDepositWhitelist\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"StrategyWhitelisterChanged\",\"inputs\":[{\"name\":\"previousAddress\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"newAddress\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Unpaused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newPausedStatus\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"UpdatedThirdPartyTransfersForbidden\",\"inputs\":[{\"name\":\"strategy\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"contractIStrategy\"},{\"name\":\"value\",\"type\":\"bool\",\"indexed\":false,\"internalType\":\"bool\"}],\"anonymous\":false}]", - Bin: "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", -} - -// ContractStrategyManagerABI is the input ABI used to generate the binding from. -// Deprecated: Use ContractStrategyManagerMetaData.ABI instead. -var ContractStrategyManagerABI = ContractStrategyManagerMetaData.ABI - -// ContractStrategyManagerBin is the compiled bytecode used for deploying new contracts. -// Deprecated: Use ContractStrategyManagerMetaData.Bin instead. -var ContractStrategyManagerBin = ContractStrategyManagerMetaData.Bin - -// DeployContractStrategyManager deploys a new Ethereum contract, binding an instance of ContractStrategyManager to it. -func DeployContractStrategyManager(auth *bind.TransactOpts, backend bind.ContractBackend, _delegation common.Address, _eigenPodManager common.Address, _slasher common.Address) (common.Address, *types.Transaction, *ContractStrategyManager, error) { - parsed, err := ContractStrategyManagerMetaData.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(ContractStrategyManagerBin), backend, _delegation, _eigenPodManager, _slasher) - if err != nil { - return common.Address{}, nil, nil, err - } - return address, tx, &ContractStrategyManager{ContractStrategyManagerCaller: ContractStrategyManagerCaller{contract: contract}, ContractStrategyManagerTransactor: ContractStrategyManagerTransactor{contract: contract}, ContractStrategyManagerFilterer: ContractStrategyManagerFilterer{contract: contract}}, nil -} - -// ContractStrategyManagerMethods is an auto generated interface around an Ethereum contract. -type ContractStrategyManagerMethods interface { - ContractStrategyManagerCalls - ContractStrategyManagerTransacts - ContractStrategyManagerFilters -} - -// ContractStrategyManagerCalls is an auto generated interface that defines the call methods available for an Ethereum contract. -type ContractStrategyManagerCalls interface { - DEPOSITTYPEHASH(opts *bind.CallOpts) ([32]byte, error) - - DOMAINTYPEHASH(opts *bind.CallOpts) ([32]byte, error) - - CalculateWithdrawalRoot(opts *bind.CallOpts, queuedWithdrawal IStrategyManagerDeprecatedStructQueuedWithdrawal) ([32]byte, error) - - Delegation(opts *bind.CallOpts) (common.Address, error) - - DomainSeparator(opts *bind.CallOpts) ([32]byte, error) - - EigenPodManager(opts *bind.CallOpts) (common.Address, error) - - GetDeposits(opts *bind.CallOpts, staker common.Address) ([]common.Address, []*big.Int, error) - - Nonces(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) - - Owner(opts *bind.CallOpts) (common.Address, error) - - Paused(opts *bind.CallOpts, index uint8) (bool, error) - - Paused0(opts *bind.CallOpts) (*big.Int, error) - - PauserRegistry(opts *bind.CallOpts) (common.Address, error) - - Slasher(opts *bind.CallOpts) (common.Address, error) - - StakerStrategyList(opts *bind.CallOpts, arg0 common.Address, arg1 *big.Int) (common.Address, error) - - StakerStrategyListLength(opts *bind.CallOpts, staker common.Address) (*big.Int, error) - - StakerStrategyShares(opts *bind.CallOpts, arg0 common.Address, arg1 common.Address) (*big.Int, error) - - StrategyIsWhitelistedForDeposit(opts *bind.CallOpts, arg0 common.Address) (bool, error) - - StrategyWhitelister(opts *bind.CallOpts) (common.Address, error) - - ThirdPartyTransfersForbidden(opts *bind.CallOpts, arg0 common.Address) (bool, error) - - WithdrawalRootPending(opts *bind.CallOpts, arg0 [32]byte) (bool, error) -} - -// ContractStrategyManagerTransacts is an auto generated interface that defines the transact methods available for an Ethereum contract. -type ContractStrategyManagerTransacts interface { - AddShares(opts *bind.TransactOpts, staker common.Address, token common.Address, strategy common.Address, shares *big.Int) (*types.Transaction, error) - - AddStrategiesToDepositWhitelist(opts *bind.TransactOpts, strategiesToWhitelist []common.Address, thirdPartyTransfersForbiddenValues []bool) (*types.Transaction, error) - - DepositIntoStrategy(opts *bind.TransactOpts, strategy common.Address, token common.Address, amount *big.Int) (*types.Transaction, error) - - DepositIntoStrategyWithSignature(opts *bind.TransactOpts, strategy common.Address, token common.Address, amount *big.Int, staker common.Address, expiry *big.Int, signature []byte) (*types.Transaction, error) - - Initialize(opts *bind.TransactOpts, initialOwner common.Address, initialStrategyWhitelister common.Address, _pauserRegistry common.Address, initialPausedStatus *big.Int) (*types.Transaction, error) - - MigrateQueuedWithdrawal(opts *bind.TransactOpts, queuedWithdrawal IStrategyManagerDeprecatedStructQueuedWithdrawal) (*types.Transaction, error) - - Pause(opts *bind.TransactOpts, newPausedStatus *big.Int) (*types.Transaction, error) - - PauseAll(opts *bind.TransactOpts) (*types.Transaction, error) - - RemoveShares(opts *bind.TransactOpts, staker common.Address, strategy common.Address, shares *big.Int) (*types.Transaction, error) - - RemoveStrategiesFromDepositWhitelist(opts *bind.TransactOpts, strategiesToRemoveFromWhitelist []common.Address) (*types.Transaction, error) - - RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) - - SetPauserRegistry(opts *bind.TransactOpts, newPauserRegistry common.Address) (*types.Transaction, error) - - SetStrategyWhitelister(opts *bind.TransactOpts, newStrategyWhitelister common.Address) (*types.Transaction, error) - - SetThirdPartyTransfersForbidden(opts *bind.TransactOpts, strategy common.Address, value bool) (*types.Transaction, error) - - TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) - - Unpause(opts *bind.TransactOpts, newPausedStatus *big.Int) (*types.Transaction, error) - - WithdrawSharesAsTokens(opts *bind.TransactOpts, recipient common.Address, strategy common.Address, shares *big.Int, token common.Address) (*types.Transaction, error) -} - -// ContractStrategyManagerFilterer is an auto generated interface that defines the log filtering methods available for an Ethereum contract. -type ContractStrategyManagerFilters interface { - FilterDeposit(opts *bind.FilterOpts) (*ContractStrategyManagerDepositIterator, error) - WatchDeposit(opts *bind.WatchOpts, sink chan<- *ContractStrategyManagerDeposit) (event.Subscription, error) - ParseDeposit(log types.Log) (*ContractStrategyManagerDeposit, error) - - FilterInitialized(opts *bind.FilterOpts) (*ContractStrategyManagerInitializedIterator, error) - WatchInitialized(opts *bind.WatchOpts, sink chan<- *ContractStrategyManagerInitialized) (event.Subscription, error) - ParseInitialized(log types.Log) (*ContractStrategyManagerInitialized, error) - - FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*ContractStrategyManagerOwnershipTransferredIterator, error) - WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *ContractStrategyManagerOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) - ParseOwnershipTransferred(log types.Log) (*ContractStrategyManagerOwnershipTransferred, error) - - FilterPaused(opts *bind.FilterOpts, account []common.Address) (*ContractStrategyManagerPausedIterator, error) - WatchPaused(opts *bind.WatchOpts, sink chan<- *ContractStrategyManagerPaused, account []common.Address) (event.Subscription, error) - ParsePaused(log types.Log) (*ContractStrategyManagerPaused, error) - - FilterPauserRegistrySet(opts *bind.FilterOpts) (*ContractStrategyManagerPauserRegistrySetIterator, error) - WatchPauserRegistrySet(opts *bind.WatchOpts, sink chan<- *ContractStrategyManagerPauserRegistrySet) (event.Subscription, error) - ParsePauserRegistrySet(log types.Log) (*ContractStrategyManagerPauserRegistrySet, error) - - FilterStrategyAddedToDepositWhitelist(opts *bind.FilterOpts) (*ContractStrategyManagerStrategyAddedToDepositWhitelistIterator, error) - WatchStrategyAddedToDepositWhitelist(opts *bind.WatchOpts, sink chan<- *ContractStrategyManagerStrategyAddedToDepositWhitelist) (event.Subscription, error) - ParseStrategyAddedToDepositWhitelist(log types.Log) (*ContractStrategyManagerStrategyAddedToDepositWhitelist, error) - - FilterStrategyRemovedFromDepositWhitelist(opts *bind.FilterOpts) (*ContractStrategyManagerStrategyRemovedFromDepositWhitelistIterator, error) - WatchStrategyRemovedFromDepositWhitelist(opts *bind.WatchOpts, sink chan<- *ContractStrategyManagerStrategyRemovedFromDepositWhitelist) (event.Subscription, error) - ParseStrategyRemovedFromDepositWhitelist(log types.Log) (*ContractStrategyManagerStrategyRemovedFromDepositWhitelist, error) - - FilterStrategyWhitelisterChanged(opts *bind.FilterOpts) (*ContractStrategyManagerStrategyWhitelisterChangedIterator, error) - WatchStrategyWhitelisterChanged(opts *bind.WatchOpts, sink chan<- *ContractStrategyManagerStrategyWhitelisterChanged) (event.Subscription, error) - ParseStrategyWhitelisterChanged(log types.Log) (*ContractStrategyManagerStrategyWhitelisterChanged, error) - - FilterUnpaused(opts *bind.FilterOpts, account []common.Address) (*ContractStrategyManagerUnpausedIterator, error) - WatchUnpaused(opts *bind.WatchOpts, sink chan<- *ContractStrategyManagerUnpaused, account []common.Address) (event.Subscription, error) - ParseUnpaused(log types.Log) (*ContractStrategyManagerUnpaused, error) - - FilterUpdatedThirdPartyTransfersForbidden(opts *bind.FilterOpts) (*ContractStrategyManagerUpdatedThirdPartyTransfersForbiddenIterator, error) - WatchUpdatedThirdPartyTransfersForbidden(opts *bind.WatchOpts, sink chan<- *ContractStrategyManagerUpdatedThirdPartyTransfersForbidden) (event.Subscription, error) - ParseUpdatedThirdPartyTransfersForbidden(log types.Log) (*ContractStrategyManagerUpdatedThirdPartyTransfersForbidden, error) -} - -// ContractStrategyManager is an auto generated Go binding around an Ethereum contract. -type ContractStrategyManager struct { - ContractStrategyManagerCaller // Read-only binding to the contract - ContractStrategyManagerTransactor // Write-only binding to the contract - ContractStrategyManagerFilterer // Log filterer for contract events -} - -// ContractStrategyManager implements the ContractStrategyManagerMethods interface. -var _ ContractStrategyManagerMethods = (*ContractStrategyManager)(nil) - -// ContractStrategyManagerCaller is an auto generated read-only Go binding around an Ethereum contract. -type ContractStrategyManagerCaller struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// ContractStrategyManagerCaller implements the ContractStrategyManagerCalls interface. -var _ ContractStrategyManagerCalls = (*ContractStrategyManagerCaller)(nil) - -// ContractStrategyManagerTransactor is an auto generated write-only Go binding around an Ethereum contract. -type ContractStrategyManagerTransactor struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// ContractStrategyManagerTransactor implements the ContractStrategyManagerTransacts interface. -var _ ContractStrategyManagerTransacts = (*ContractStrategyManagerTransactor)(nil) - -// ContractStrategyManagerFilterer is an auto generated log filtering Go binding around an Ethereum contract events. -type ContractStrategyManagerFilterer struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// ContractStrategyManagerFilterer implements the ContractStrategyManagerFilters interface. -var _ ContractStrategyManagerFilters = (*ContractStrategyManagerFilterer)(nil) - -// ContractStrategyManagerSession is an auto generated Go binding around an Ethereum contract, -// with pre-set call and transact options. -type ContractStrategyManagerSession struct { - Contract *ContractStrategyManager // 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 -} - -// ContractStrategyManagerCallerSession is an auto generated read-only Go binding around an Ethereum contract, -// with pre-set call options. -type ContractStrategyManagerCallerSession struct { - Contract *ContractStrategyManagerCaller // Generic contract caller binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session -} - -// ContractStrategyManagerTransactorSession is an auto generated write-only Go binding around an Ethereum contract, -// with pre-set transact options. -type ContractStrategyManagerTransactorSession struct { - Contract *ContractStrategyManagerTransactor // Generic contract transactor binding to set the session for - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session -} - -// ContractStrategyManagerRaw is an auto generated low-level Go binding around an Ethereum contract. -type ContractStrategyManagerRaw struct { - Contract *ContractStrategyManager // Generic contract binding to access the raw methods on -} - -// ContractStrategyManagerCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. -type ContractStrategyManagerCallerRaw struct { - Contract *ContractStrategyManagerCaller // Generic read-only contract binding to access the raw methods on -} - -// ContractStrategyManagerTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. -type ContractStrategyManagerTransactorRaw struct { - Contract *ContractStrategyManagerTransactor // Generic write-only contract binding to access the raw methods on -} - -// NewContractStrategyManager creates a new instance of ContractStrategyManager, bound to a specific deployed contract. -func NewContractStrategyManager(address common.Address, backend bind.ContractBackend) (*ContractStrategyManager, error) { - contract, err := bindContractStrategyManager(address, backend, backend, backend) - if err != nil { - return nil, err - } - return &ContractStrategyManager{ContractStrategyManagerCaller: ContractStrategyManagerCaller{contract: contract}, ContractStrategyManagerTransactor: ContractStrategyManagerTransactor{contract: contract}, ContractStrategyManagerFilterer: ContractStrategyManagerFilterer{contract: contract}}, nil -} - -// NewContractStrategyManagerCaller creates a new read-only instance of ContractStrategyManager, bound to a specific deployed contract. -func NewContractStrategyManagerCaller(address common.Address, caller bind.ContractCaller) (*ContractStrategyManagerCaller, error) { - contract, err := bindContractStrategyManager(address, caller, nil, nil) - if err != nil { - return nil, err - } - return &ContractStrategyManagerCaller{contract: contract}, nil -} - -// NewContractStrategyManagerTransactor creates a new write-only instance of ContractStrategyManager, bound to a specific deployed contract. -func NewContractStrategyManagerTransactor(address common.Address, transactor bind.ContractTransactor) (*ContractStrategyManagerTransactor, error) { - contract, err := bindContractStrategyManager(address, nil, transactor, nil) - if err != nil { - return nil, err - } - return &ContractStrategyManagerTransactor{contract: contract}, nil -} - -// NewContractStrategyManagerFilterer creates a new log filterer instance of ContractStrategyManager, bound to a specific deployed contract. -func NewContractStrategyManagerFilterer(address common.Address, filterer bind.ContractFilterer) (*ContractStrategyManagerFilterer, error) { - contract, err := bindContractStrategyManager(address, nil, nil, filterer) - if err != nil { - return nil, err - } - return &ContractStrategyManagerFilterer{contract: contract}, nil -} - -// bindContractStrategyManager binds a generic wrapper to an already deployed contract. -func bindContractStrategyManager(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { - parsed, err := ContractStrategyManagerMetaData.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 (_ContractStrategyManager *ContractStrategyManagerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _ContractStrategyManager.Contract.ContractStrategyManagerCaller.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 (_ContractStrategyManager *ContractStrategyManagerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _ContractStrategyManager.Contract.ContractStrategyManagerTransactor.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_ContractStrategyManager *ContractStrategyManagerRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _ContractStrategyManager.Contract.ContractStrategyManagerTransactor.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 (_ContractStrategyManager *ContractStrategyManagerCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _ContractStrategyManager.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 (_ContractStrategyManager *ContractStrategyManagerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _ContractStrategyManager.Contract.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_ContractStrategyManager *ContractStrategyManagerTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _ContractStrategyManager.Contract.contract.Transact(opts, method, params...) -} - -// DEPOSITTYPEHASH is a free data retrieval call binding the contract method 0x48825e94. -// -// Solidity: function DEPOSIT_TYPEHASH() view returns(bytes32) -func (_ContractStrategyManager *ContractStrategyManagerCaller) DEPOSITTYPEHASH(opts *bind.CallOpts) ([32]byte, error) { - var out []interface{} - err := _ContractStrategyManager.contract.Call(opts, &out, "DEPOSIT_TYPEHASH") - - if err != nil { - return *new([32]byte), err - } - - out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) - - return out0, err - -} - -// DEPOSITTYPEHASH is a free data retrieval call binding the contract method 0x48825e94. -// -// Solidity: function DEPOSIT_TYPEHASH() view returns(bytes32) -func (_ContractStrategyManager *ContractStrategyManagerSession) DEPOSITTYPEHASH() ([32]byte, error) { - return _ContractStrategyManager.Contract.DEPOSITTYPEHASH(&_ContractStrategyManager.CallOpts) -} - -// DEPOSITTYPEHASH is a free data retrieval call binding the contract method 0x48825e94. -// -// Solidity: function DEPOSIT_TYPEHASH() view returns(bytes32) -func (_ContractStrategyManager *ContractStrategyManagerCallerSession) DEPOSITTYPEHASH() ([32]byte, error) { - return _ContractStrategyManager.Contract.DEPOSITTYPEHASH(&_ContractStrategyManager.CallOpts) -} - -// DOMAINTYPEHASH is a free data retrieval call binding the contract method 0x20606b70. -// -// Solidity: function DOMAIN_TYPEHASH() view returns(bytes32) -func (_ContractStrategyManager *ContractStrategyManagerCaller) DOMAINTYPEHASH(opts *bind.CallOpts) ([32]byte, error) { - var out []interface{} - err := _ContractStrategyManager.contract.Call(opts, &out, "DOMAIN_TYPEHASH") - - if err != nil { - return *new([32]byte), err - } - - out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) - - return out0, err - -} - -// DOMAINTYPEHASH is a free data retrieval call binding the contract method 0x20606b70. -// -// Solidity: function DOMAIN_TYPEHASH() view returns(bytes32) -func (_ContractStrategyManager *ContractStrategyManagerSession) DOMAINTYPEHASH() ([32]byte, error) { - return _ContractStrategyManager.Contract.DOMAINTYPEHASH(&_ContractStrategyManager.CallOpts) -} - -// DOMAINTYPEHASH is a free data retrieval call binding the contract method 0x20606b70. -// -// Solidity: function DOMAIN_TYPEHASH() view returns(bytes32) -func (_ContractStrategyManager *ContractStrategyManagerCallerSession) DOMAINTYPEHASH() ([32]byte, error) { - return _ContractStrategyManager.Contract.DOMAINTYPEHASH(&_ContractStrategyManager.CallOpts) -} - -// CalculateWithdrawalRoot is a free data retrieval call binding the contract method 0xb43b514b. -// -// Solidity: function calculateWithdrawalRoot((address[],uint256[],address,(address,uint96),uint32,address) queuedWithdrawal) pure returns(bytes32) -func (_ContractStrategyManager *ContractStrategyManagerCaller) CalculateWithdrawalRoot(opts *bind.CallOpts, queuedWithdrawal IStrategyManagerDeprecatedStructQueuedWithdrawal) ([32]byte, error) { - var out []interface{} - err := _ContractStrategyManager.contract.Call(opts, &out, "calculateWithdrawalRoot", queuedWithdrawal) - - if err != nil { - return *new([32]byte), err - } - - out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) - - return out0, err - -} - -// CalculateWithdrawalRoot is a free data retrieval call binding the contract method 0xb43b514b. -// -// Solidity: function calculateWithdrawalRoot((address[],uint256[],address,(address,uint96),uint32,address) queuedWithdrawal) pure returns(bytes32) -func (_ContractStrategyManager *ContractStrategyManagerSession) CalculateWithdrawalRoot(queuedWithdrawal IStrategyManagerDeprecatedStructQueuedWithdrawal) ([32]byte, error) { - return _ContractStrategyManager.Contract.CalculateWithdrawalRoot(&_ContractStrategyManager.CallOpts, queuedWithdrawal) -} - -// CalculateWithdrawalRoot is a free data retrieval call binding the contract method 0xb43b514b. -// -// Solidity: function calculateWithdrawalRoot((address[],uint256[],address,(address,uint96),uint32,address) queuedWithdrawal) pure returns(bytes32) -func (_ContractStrategyManager *ContractStrategyManagerCallerSession) CalculateWithdrawalRoot(queuedWithdrawal IStrategyManagerDeprecatedStructQueuedWithdrawal) ([32]byte, error) { - return _ContractStrategyManager.Contract.CalculateWithdrawalRoot(&_ContractStrategyManager.CallOpts, queuedWithdrawal) -} - -// Delegation is a free data retrieval call binding the contract method 0xdf5cf723. -// -// Solidity: function delegation() view returns(address) -func (_ContractStrategyManager *ContractStrategyManagerCaller) Delegation(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _ContractStrategyManager.contract.Call(opts, &out, "delegation") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// Delegation is a free data retrieval call binding the contract method 0xdf5cf723. -// -// Solidity: function delegation() view returns(address) -func (_ContractStrategyManager *ContractStrategyManagerSession) Delegation() (common.Address, error) { - return _ContractStrategyManager.Contract.Delegation(&_ContractStrategyManager.CallOpts) -} - -// Delegation is a free data retrieval call binding the contract method 0xdf5cf723. -// -// Solidity: function delegation() view returns(address) -func (_ContractStrategyManager *ContractStrategyManagerCallerSession) Delegation() (common.Address, error) { - return _ContractStrategyManager.Contract.Delegation(&_ContractStrategyManager.CallOpts) -} - -// DomainSeparator is a free data retrieval call binding the contract method 0xf698da25. -// -// Solidity: function domainSeparator() view returns(bytes32) -func (_ContractStrategyManager *ContractStrategyManagerCaller) DomainSeparator(opts *bind.CallOpts) ([32]byte, error) { - var out []interface{} - err := _ContractStrategyManager.contract.Call(opts, &out, "domainSeparator") - - if err != nil { - return *new([32]byte), err - } - - out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) - - return out0, err - -} - -// DomainSeparator is a free data retrieval call binding the contract method 0xf698da25. -// -// Solidity: function domainSeparator() view returns(bytes32) -func (_ContractStrategyManager *ContractStrategyManagerSession) DomainSeparator() ([32]byte, error) { - return _ContractStrategyManager.Contract.DomainSeparator(&_ContractStrategyManager.CallOpts) -} - -// DomainSeparator is a free data retrieval call binding the contract method 0xf698da25. -// -// Solidity: function domainSeparator() view returns(bytes32) -func (_ContractStrategyManager *ContractStrategyManagerCallerSession) DomainSeparator() ([32]byte, error) { - return _ContractStrategyManager.Contract.DomainSeparator(&_ContractStrategyManager.CallOpts) -} - -// EigenPodManager is a free data retrieval call binding the contract method 0x4665bcda. -// -// Solidity: function eigenPodManager() view returns(address) -func (_ContractStrategyManager *ContractStrategyManagerCaller) EigenPodManager(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _ContractStrategyManager.contract.Call(opts, &out, "eigenPodManager") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// EigenPodManager is a free data retrieval call binding the contract method 0x4665bcda. -// -// Solidity: function eigenPodManager() view returns(address) -func (_ContractStrategyManager *ContractStrategyManagerSession) EigenPodManager() (common.Address, error) { - return _ContractStrategyManager.Contract.EigenPodManager(&_ContractStrategyManager.CallOpts) -} - -// EigenPodManager is a free data retrieval call binding the contract method 0x4665bcda. -// -// Solidity: function eigenPodManager() view returns(address) -func (_ContractStrategyManager *ContractStrategyManagerCallerSession) EigenPodManager() (common.Address, error) { - return _ContractStrategyManager.Contract.EigenPodManager(&_ContractStrategyManager.CallOpts) -} - -// GetDeposits is a free data retrieval call binding the contract method 0x94f649dd. -// -// Solidity: function getDeposits(address staker) view returns(address[], uint256[]) -func (_ContractStrategyManager *ContractStrategyManagerCaller) GetDeposits(opts *bind.CallOpts, staker common.Address) ([]common.Address, []*big.Int, error) { - var out []interface{} - err := _ContractStrategyManager.contract.Call(opts, &out, "getDeposits", staker) - - if err != nil { - return *new([]common.Address), *new([]*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address) - out1 := *abi.ConvertType(out[1], new([]*big.Int)).(*[]*big.Int) - - return out0, out1, err - -} - -// GetDeposits is a free data retrieval call binding the contract method 0x94f649dd. -// -// Solidity: function getDeposits(address staker) view returns(address[], uint256[]) -func (_ContractStrategyManager *ContractStrategyManagerSession) GetDeposits(staker common.Address) ([]common.Address, []*big.Int, error) { - return _ContractStrategyManager.Contract.GetDeposits(&_ContractStrategyManager.CallOpts, staker) -} - -// GetDeposits is a free data retrieval call binding the contract method 0x94f649dd. -// -// Solidity: function getDeposits(address staker) view returns(address[], uint256[]) -func (_ContractStrategyManager *ContractStrategyManagerCallerSession) GetDeposits(staker common.Address) ([]common.Address, []*big.Int, error) { - return _ContractStrategyManager.Contract.GetDeposits(&_ContractStrategyManager.CallOpts, staker) -} - -// Nonces is a free data retrieval call binding the contract method 0x7ecebe00. -// -// Solidity: function nonces(address ) view returns(uint256) -func (_ContractStrategyManager *ContractStrategyManagerCaller) Nonces(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) { - var out []interface{} - err := _ContractStrategyManager.contract.Call(opts, &out, "nonces", arg0) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// Nonces is a free data retrieval call binding the contract method 0x7ecebe00. -// -// Solidity: function nonces(address ) view returns(uint256) -func (_ContractStrategyManager *ContractStrategyManagerSession) Nonces(arg0 common.Address) (*big.Int, error) { - return _ContractStrategyManager.Contract.Nonces(&_ContractStrategyManager.CallOpts, arg0) -} - -// Nonces is a free data retrieval call binding the contract method 0x7ecebe00. -// -// Solidity: function nonces(address ) view returns(uint256) -func (_ContractStrategyManager *ContractStrategyManagerCallerSession) Nonces(arg0 common.Address) (*big.Int, error) { - return _ContractStrategyManager.Contract.Nonces(&_ContractStrategyManager.CallOpts, arg0) -} - -// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. -// -// Solidity: function owner() view returns(address) -func (_ContractStrategyManager *ContractStrategyManagerCaller) Owner(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _ContractStrategyManager.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 (_ContractStrategyManager *ContractStrategyManagerSession) Owner() (common.Address, error) { - return _ContractStrategyManager.Contract.Owner(&_ContractStrategyManager.CallOpts) -} - -// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. -// -// Solidity: function owner() view returns(address) -func (_ContractStrategyManager *ContractStrategyManagerCallerSession) Owner() (common.Address, error) { - return _ContractStrategyManager.Contract.Owner(&_ContractStrategyManager.CallOpts) -} - -// Paused is a free data retrieval call binding the contract method 0x5ac86ab7. -// -// Solidity: function paused(uint8 index) view returns(bool) -func (_ContractStrategyManager *ContractStrategyManagerCaller) Paused(opts *bind.CallOpts, index uint8) (bool, error) { - var out []interface{} - err := _ContractStrategyManager.contract.Call(opts, &out, "paused", index) - - 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 0x5ac86ab7. -// -// Solidity: function paused(uint8 index) view returns(bool) -func (_ContractStrategyManager *ContractStrategyManagerSession) Paused(index uint8) (bool, error) { - return _ContractStrategyManager.Contract.Paused(&_ContractStrategyManager.CallOpts, index) -} - -// Paused is a free data retrieval call binding the contract method 0x5ac86ab7. -// -// Solidity: function paused(uint8 index) view returns(bool) -func (_ContractStrategyManager *ContractStrategyManagerCallerSession) Paused(index uint8) (bool, error) { - return _ContractStrategyManager.Contract.Paused(&_ContractStrategyManager.CallOpts, index) -} - -// Paused0 is a free data retrieval call binding the contract method 0x5c975abb. -// -// Solidity: function paused() view returns(uint256) -func (_ContractStrategyManager *ContractStrategyManagerCaller) Paused0(opts *bind.CallOpts) (*big.Int, error) { - var out []interface{} - err := _ContractStrategyManager.contract.Call(opts, &out, "paused0") - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// Paused0 is a free data retrieval call binding the contract method 0x5c975abb. -// -// Solidity: function paused() view returns(uint256) -func (_ContractStrategyManager *ContractStrategyManagerSession) Paused0() (*big.Int, error) { - return _ContractStrategyManager.Contract.Paused0(&_ContractStrategyManager.CallOpts) -} - -// Paused0 is a free data retrieval call binding the contract method 0x5c975abb. -// -// Solidity: function paused() view returns(uint256) -func (_ContractStrategyManager *ContractStrategyManagerCallerSession) Paused0() (*big.Int, error) { - return _ContractStrategyManager.Contract.Paused0(&_ContractStrategyManager.CallOpts) -} - -// PauserRegistry is a free data retrieval call binding the contract method 0x886f1195. -// -// Solidity: function pauserRegistry() view returns(address) -func (_ContractStrategyManager *ContractStrategyManagerCaller) PauserRegistry(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _ContractStrategyManager.contract.Call(opts, &out, "pauserRegistry") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// PauserRegistry is a free data retrieval call binding the contract method 0x886f1195. -// -// Solidity: function pauserRegistry() view returns(address) -func (_ContractStrategyManager *ContractStrategyManagerSession) PauserRegistry() (common.Address, error) { - return _ContractStrategyManager.Contract.PauserRegistry(&_ContractStrategyManager.CallOpts) -} - -// PauserRegistry is a free data retrieval call binding the contract method 0x886f1195. -// -// Solidity: function pauserRegistry() view returns(address) -func (_ContractStrategyManager *ContractStrategyManagerCallerSession) PauserRegistry() (common.Address, error) { - return _ContractStrategyManager.Contract.PauserRegistry(&_ContractStrategyManager.CallOpts) -} - -// Slasher is a free data retrieval call binding the contract method 0xb1344271. -// -// Solidity: function slasher() view returns(address) -func (_ContractStrategyManager *ContractStrategyManagerCaller) Slasher(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _ContractStrategyManager.contract.Call(opts, &out, "slasher") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// Slasher is a free data retrieval call binding the contract method 0xb1344271. -// -// Solidity: function slasher() view returns(address) -func (_ContractStrategyManager *ContractStrategyManagerSession) Slasher() (common.Address, error) { - return _ContractStrategyManager.Contract.Slasher(&_ContractStrategyManager.CallOpts) -} - -// Slasher is a free data retrieval call binding the contract method 0xb1344271. -// -// Solidity: function slasher() view returns(address) -func (_ContractStrategyManager *ContractStrategyManagerCallerSession) Slasher() (common.Address, error) { - return _ContractStrategyManager.Contract.Slasher(&_ContractStrategyManager.CallOpts) -} - -// StakerStrategyList is a free data retrieval call binding the contract method 0xcbc2bd62. -// -// Solidity: function stakerStrategyList(address , uint256 ) view returns(address) -func (_ContractStrategyManager *ContractStrategyManagerCaller) StakerStrategyList(opts *bind.CallOpts, arg0 common.Address, arg1 *big.Int) (common.Address, error) { - var out []interface{} - err := _ContractStrategyManager.contract.Call(opts, &out, "stakerStrategyList", arg0, arg1) - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// StakerStrategyList is a free data retrieval call binding the contract method 0xcbc2bd62. -// -// Solidity: function stakerStrategyList(address , uint256 ) view returns(address) -func (_ContractStrategyManager *ContractStrategyManagerSession) StakerStrategyList(arg0 common.Address, arg1 *big.Int) (common.Address, error) { - return _ContractStrategyManager.Contract.StakerStrategyList(&_ContractStrategyManager.CallOpts, arg0, arg1) -} - -// StakerStrategyList is a free data retrieval call binding the contract method 0xcbc2bd62. -// -// Solidity: function stakerStrategyList(address , uint256 ) view returns(address) -func (_ContractStrategyManager *ContractStrategyManagerCallerSession) StakerStrategyList(arg0 common.Address, arg1 *big.Int) (common.Address, error) { - return _ContractStrategyManager.Contract.StakerStrategyList(&_ContractStrategyManager.CallOpts, arg0, arg1) -} - -// StakerStrategyListLength is a free data retrieval call binding the contract method 0x8b8aac3c. -// -// Solidity: function stakerStrategyListLength(address staker) view returns(uint256) -func (_ContractStrategyManager *ContractStrategyManagerCaller) StakerStrategyListLength(opts *bind.CallOpts, staker common.Address) (*big.Int, error) { - var out []interface{} - err := _ContractStrategyManager.contract.Call(opts, &out, "stakerStrategyListLength", staker) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// StakerStrategyListLength is a free data retrieval call binding the contract method 0x8b8aac3c. -// -// Solidity: function stakerStrategyListLength(address staker) view returns(uint256) -func (_ContractStrategyManager *ContractStrategyManagerSession) StakerStrategyListLength(staker common.Address) (*big.Int, error) { - return _ContractStrategyManager.Contract.StakerStrategyListLength(&_ContractStrategyManager.CallOpts, staker) -} - -// StakerStrategyListLength is a free data retrieval call binding the contract method 0x8b8aac3c. -// -// Solidity: function stakerStrategyListLength(address staker) view returns(uint256) -func (_ContractStrategyManager *ContractStrategyManagerCallerSession) StakerStrategyListLength(staker common.Address) (*big.Int, error) { - return _ContractStrategyManager.Contract.StakerStrategyListLength(&_ContractStrategyManager.CallOpts, staker) -} - -// StakerStrategyShares is a free data retrieval call binding the contract method 0x7a7e0d92. -// -// Solidity: function stakerStrategyShares(address , address ) view returns(uint256) -func (_ContractStrategyManager *ContractStrategyManagerCaller) StakerStrategyShares(opts *bind.CallOpts, arg0 common.Address, arg1 common.Address) (*big.Int, error) { - var out []interface{} - err := _ContractStrategyManager.contract.Call(opts, &out, "stakerStrategyShares", arg0, arg1) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// StakerStrategyShares is a free data retrieval call binding the contract method 0x7a7e0d92. -// -// Solidity: function stakerStrategyShares(address , address ) view returns(uint256) -func (_ContractStrategyManager *ContractStrategyManagerSession) StakerStrategyShares(arg0 common.Address, arg1 common.Address) (*big.Int, error) { - return _ContractStrategyManager.Contract.StakerStrategyShares(&_ContractStrategyManager.CallOpts, arg0, arg1) -} - -// StakerStrategyShares is a free data retrieval call binding the contract method 0x7a7e0d92. -// -// Solidity: function stakerStrategyShares(address , address ) view returns(uint256) -func (_ContractStrategyManager *ContractStrategyManagerCallerSession) StakerStrategyShares(arg0 common.Address, arg1 common.Address) (*big.Int, error) { - return _ContractStrategyManager.Contract.StakerStrategyShares(&_ContractStrategyManager.CallOpts, arg0, arg1) -} - -// StrategyIsWhitelistedForDeposit is a free data retrieval call binding the contract method 0x663c1de4. -// -// Solidity: function strategyIsWhitelistedForDeposit(address ) view returns(bool) -func (_ContractStrategyManager *ContractStrategyManagerCaller) StrategyIsWhitelistedForDeposit(opts *bind.CallOpts, arg0 common.Address) (bool, error) { - var out []interface{} - err := _ContractStrategyManager.contract.Call(opts, &out, "strategyIsWhitelistedForDeposit", arg0) - - if err != nil { - return *new(bool), err - } - - out0 := *abi.ConvertType(out[0], new(bool)).(*bool) - - return out0, err - -} - -// StrategyIsWhitelistedForDeposit is a free data retrieval call binding the contract method 0x663c1de4. -// -// Solidity: function strategyIsWhitelistedForDeposit(address ) view returns(bool) -func (_ContractStrategyManager *ContractStrategyManagerSession) StrategyIsWhitelistedForDeposit(arg0 common.Address) (bool, error) { - return _ContractStrategyManager.Contract.StrategyIsWhitelistedForDeposit(&_ContractStrategyManager.CallOpts, arg0) -} - -// StrategyIsWhitelistedForDeposit is a free data retrieval call binding the contract method 0x663c1de4. -// -// Solidity: function strategyIsWhitelistedForDeposit(address ) view returns(bool) -func (_ContractStrategyManager *ContractStrategyManagerCallerSession) StrategyIsWhitelistedForDeposit(arg0 common.Address) (bool, error) { - return _ContractStrategyManager.Contract.StrategyIsWhitelistedForDeposit(&_ContractStrategyManager.CallOpts, arg0) -} - -// StrategyWhitelister is a free data retrieval call binding the contract method 0x967fc0d2. -// -// Solidity: function strategyWhitelister() view returns(address) -func (_ContractStrategyManager *ContractStrategyManagerCaller) StrategyWhitelister(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _ContractStrategyManager.contract.Call(opts, &out, "strategyWhitelister") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// StrategyWhitelister is a free data retrieval call binding the contract method 0x967fc0d2. -// -// Solidity: function strategyWhitelister() view returns(address) -func (_ContractStrategyManager *ContractStrategyManagerSession) StrategyWhitelister() (common.Address, error) { - return _ContractStrategyManager.Contract.StrategyWhitelister(&_ContractStrategyManager.CallOpts) -} - -// StrategyWhitelister is a free data retrieval call binding the contract method 0x967fc0d2. -// -// Solidity: function strategyWhitelister() view returns(address) -func (_ContractStrategyManager *ContractStrategyManagerCallerSession) StrategyWhitelister() (common.Address, error) { - return _ContractStrategyManager.Contract.StrategyWhitelister(&_ContractStrategyManager.CallOpts) -} - -// ThirdPartyTransfersForbidden is a free data retrieval call binding the contract method 0x9b4da03d. -// -// Solidity: function thirdPartyTransfersForbidden(address ) view returns(bool) -func (_ContractStrategyManager *ContractStrategyManagerCaller) ThirdPartyTransfersForbidden(opts *bind.CallOpts, arg0 common.Address) (bool, error) { - var out []interface{} - err := _ContractStrategyManager.contract.Call(opts, &out, "thirdPartyTransfersForbidden", arg0) - - if err != nil { - return *new(bool), err - } - - out0 := *abi.ConvertType(out[0], new(bool)).(*bool) - - return out0, err - -} - -// ThirdPartyTransfersForbidden is a free data retrieval call binding the contract method 0x9b4da03d. -// -// Solidity: function thirdPartyTransfersForbidden(address ) view returns(bool) -func (_ContractStrategyManager *ContractStrategyManagerSession) ThirdPartyTransfersForbidden(arg0 common.Address) (bool, error) { - return _ContractStrategyManager.Contract.ThirdPartyTransfersForbidden(&_ContractStrategyManager.CallOpts, arg0) -} - -// ThirdPartyTransfersForbidden is a free data retrieval call binding the contract method 0x9b4da03d. -// -// Solidity: function thirdPartyTransfersForbidden(address ) view returns(bool) -func (_ContractStrategyManager *ContractStrategyManagerCallerSession) ThirdPartyTransfersForbidden(arg0 common.Address) (bool, error) { - return _ContractStrategyManager.Contract.ThirdPartyTransfersForbidden(&_ContractStrategyManager.CallOpts, arg0) -} - -// WithdrawalRootPending is a free data retrieval call binding the contract method 0xc3c6b3a9. -// -// Solidity: function withdrawalRootPending(bytes32 ) view returns(bool) -func (_ContractStrategyManager *ContractStrategyManagerCaller) WithdrawalRootPending(opts *bind.CallOpts, arg0 [32]byte) (bool, error) { - var out []interface{} - err := _ContractStrategyManager.contract.Call(opts, &out, "withdrawalRootPending", arg0) - - if err != nil { - return *new(bool), err - } - - out0 := *abi.ConvertType(out[0], new(bool)).(*bool) - - return out0, err - -} - -// WithdrawalRootPending is a free data retrieval call binding the contract method 0xc3c6b3a9. -// -// Solidity: function withdrawalRootPending(bytes32 ) view returns(bool) -func (_ContractStrategyManager *ContractStrategyManagerSession) WithdrawalRootPending(arg0 [32]byte) (bool, error) { - return _ContractStrategyManager.Contract.WithdrawalRootPending(&_ContractStrategyManager.CallOpts, arg0) -} - -// WithdrawalRootPending is a free data retrieval call binding the contract method 0xc3c6b3a9. -// -// Solidity: function withdrawalRootPending(bytes32 ) view returns(bool) -func (_ContractStrategyManager *ContractStrategyManagerCallerSession) WithdrawalRootPending(arg0 [32]byte) (bool, error) { - return _ContractStrategyManager.Contract.WithdrawalRootPending(&_ContractStrategyManager.CallOpts, arg0) -} - -// AddShares is a paid mutator transaction binding the contract method 0xc4623ea1. -// -// Solidity: function addShares(address staker, address token, address strategy, uint256 shares) returns() -func (_ContractStrategyManager *ContractStrategyManagerTransactor) AddShares(opts *bind.TransactOpts, staker common.Address, token common.Address, strategy common.Address, shares *big.Int) (*types.Transaction, error) { - return _ContractStrategyManager.contract.Transact(opts, "addShares", staker, token, strategy, shares) -} - -// AddShares is a paid mutator transaction binding the contract method 0xc4623ea1. -// -// Solidity: function addShares(address staker, address token, address strategy, uint256 shares) returns() -func (_ContractStrategyManager *ContractStrategyManagerSession) AddShares(staker common.Address, token common.Address, strategy common.Address, shares *big.Int) (*types.Transaction, error) { - return _ContractStrategyManager.Contract.AddShares(&_ContractStrategyManager.TransactOpts, staker, token, strategy, shares) -} - -// AddShares is a paid mutator transaction binding the contract method 0xc4623ea1. -// -// Solidity: function addShares(address staker, address token, address strategy, uint256 shares) returns() -func (_ContractStrategyManager *ContractStrategyManagerTransactorSession) AddShares(staker common.Address, token common.Address, strategy common.Address, shares *big.Int) (*types.Transaction, error) { - return _ContractStrategyManager.Contract.AddShares(&_ContractStrategyManager.TransactOpts, staker, token, strategy, shares) -} - -// AddStrategiesToDepositWhitelist is a paid mutator transaction binding the contract method 0xdf5b3547. -// -// Solidity: function addStrategiesToDepositWhitelist(address[] strategiesToWhitelist, bool[] thirdPartyTransfersForbiddenValues) returns() -func (_ContractStrategyManager *ContractStrategyManagerTransactor) AddStrategiesToDepositWhitelist(opts *bind.TransactOpts, strategiesToWhitelist []common.Address, thirdPartyTransfersForbiddenValues []bool) (*types.Transaction, error) { - return _ContractStrategyManager.contract.Transact(opts, "addStrategiesToDepositWhitelist", strategiesToWhitelist, thirdPartyTransfersForbiddenValues) -} - -// AddStrategiesToDepositWhitelist is a paid mutator transaction binding the contract method 0xdf5b3547. -// -// Solidity: function addStrategiesToDepositWhitelist(address[] strategiesToWhitelist, bool[] thirdPartyTransfersForbiddenValues) returns() -func (_ContractStrategyManager *ContractStrategyManagerSession) AddStrategiesToDepositWhitelist(strategiesToWhitelist []common.Address, thirdPartyTransfersForbiddenValues []bool) (*types.Transaction, error) { - return _ContractStrategyManager.Contract.AddStrategiesToDepositWhitelist(&_ContractStrategyManager.TransactOpts, strategiesToWhitelist, thirdPartyTransfersForbiddenValues) -} - -// AddStrategiesToDepositWhitelist is a paid mutator transaction binding the contract method 0xdf5b3547. -// -// Solidity: function addStrategiesToDepositWhitelist(address[] strategiesToWhitelist, bool[] thirdPartyTransfersForbiddenValues) returns() -func (_ContractStrategyManager *ContractStrategyManagerTransactorSession) AddStrategiesToDepositWhitelist(strategiesToWhitelist []common.Address, thirdPartyTransfersForbiddenValues []bool) (*types.Transaction, error) { - return _ContractStrategyManager.Contract.AddStrategiesToDepositWhitelist(&_ContractStrategyManager.TransactOpts, strategiesToWhitelist, thirdPartyTransfersForbiddenValues) -} - -// DepositIntoStrategy is a paid mutator transaction binding the contract method 0xe7a050aa. -// -// Solidity: function depositIntoStrategy(address strategy, address token, uint256 amount) returns(uint256 shares) -func (_ContractStrategyManager *ContractStrategyManagerTransactor) DepositIntoStrategy(opts *bind.TransactOpts, strategy common.Address, token common.Address, amount *big.Int) (*types.Transaction, error) { - return _ContractStrategyManager.contract.Transact(opts, "depositIntoStrategy", strategy, token, amount) -} - -// DepositIntoStrategy is a paid mutator transaction binding the contract method 0xe7a050aa. -// -// Solidity: function depositIntoStrategy(address strategy, address token, uint256 amount) returns(uint256 shares) -func (_ContractStrategyManager *ContractStrategyManagerSession) DepositIntoStrategy(strategy common.Address, token common.Address, amount *big.Int) (*types.Transaction, error) { - return _ContractStrategyManager.Contract.DepositIntoStrategy(&_ContractStrategyManager.TransactOpts, strategy, token, amount) -} - -// DepositIntoStrategy is a paid mutator transaction binding the contract method 0xe7a050aa. -// -// Solidity: function depositIntoStrategy(address strategy, address token, uint256 amount) returns(uint256 shares) -func (_ContractStrategyManager *ContractStrategyManagerTransactorSession) DepositIntoStrategy(strategy common.Address, token common.Address, amount *big.Int) (*types.Transaction, error) { - return _ContractStrategyManager.Contract.DepositIntoStrategy(&_ContractStrategyManager.TransactOpts, strategy, token, amount) -} - -// DepositIntoStrategyWithSignature is a paid mutator transaction binding the contract method 0x32e89ace. -// -// Solidity: function depositIntoStrategyWithSignature(address strategy, address token, uint256 amount, address staker, uint256 expiry, bytes signature) returns(uint256 shares) -func (_ContractStrategyManager *ContractStrategyManagerTransactor) DepositIntoStrategyWithSignature(opts *bind.TransactOpts, strategy common.Address, token common.Address, amount *big.Int, staker common.Address, expiry *big.Int, signature []byte) (*types.Transaction, error) { - return _ContractStrategyManager.contract.Transact(opts, "depositIntoStrategyWithSignature", strategy, token, amount, staker, expiry, signature) -} - -// DepositIntoStrategyWithSignature is a paid mutator transaction binding the contract method 0x32e89ace. -// -// Solidity: function depositIntoStrategyWithSignature(address strategy, address token, uint256 amount, address staker, uint256 expiry, bytes signature) returns(uint256 shares) -func (_ContractStrategyManager *ContractStrategyManagerSession) DepositIntoStrategyWithSignature(strategy common.Address, token common.Address, amount *big.Int, staker common.Address, expiry *big.Int, signature []byte) (*types.Transaction, error) { - return _ContractStrategyManager.Contract.DepositIntoStrategyWithSignature(&_ContractStrategyManager.TransactOpts, strategy, token, amount, staker, expiry, signature) -} - -// DepositIntoStrategyWithSignature is a paid mutator transaction binding the contract method 0x32e89ace. -// -// Solidity: function depositIntoStrategyWithSignature(address strategy, address token, uint256 amount, address staker, uint256 expiry, bytes signature) returns(uint256 shares) -func (_ContractStrategyManager *ContractStrategyManagerTransactorSession) DepositIntoStrategyWithSignature(strategy common.Address, token common.Address, amount *big.Int, staker common.Address, expiry *big.Int, signature []byte) (*types.Transaction, error) { - return _ContractStrategyManager.Contract.DepositIntoStrategyWithSignature(&_ContractStrategyManager.TransactOpts, strategy, token, amount, staker, expiry, signature) -} - -// Initialize is a paid mutator transaction binding the contract method 0xcf756fdf. -// -// Solidity: function initialize(address initialOwner, address initialStrategyWhitelister, address _pauserRegistry, uint256 initialPausedStatus) returns() -func (_ContractStrategyManager *ContractStrategyManagerTransactor) Initialize(opts *bind.TransactOpts, initialOwner common.Address, initialStrategyWhitelister common.Address, _pauserRegistry common.Address, initialPausedStatus *big.Int) (*types.Transaction, error) { - return _ContractStrategyManager.contract.Transact(opts, "initialize", initialOwner, initialStrategyWhitelister, _pauserRegistry, initialPausedStatus) -} - -// Initialize is a paid mutator transaction binding the contract method 0xcf756fdf. -// -// Solidity: function initialize(address initialOwner, address initialStrategyWhitelister, address _pauserRegistry, uint256 initialPausedStatus) returns() -func (_ContractStrategyManager *ContractStrategyManagerSession) Initialize(initialOwner common.Address, initialStrategyWhitelister common.Address, _pauserRegistry common.Address, initialPausedStatus *big.Int) (*types.Transaction, error) { - return _ContractStrategyManager.Contract.Initialize(&_ContractStrategyManager.TransactOpts, initialOwner, initialStrategyWhitelister, _pauserRegistry, initialPausedStatus) -} - -// Initialize is a paid mutator transaction binding the contract method 0xcf756fdf. -// -// Solidity: function initialize(address initialOwner, address initialStrategyWhitelister, address _pauserRegistry, uint256 initialPausedStatus) returns() -func (_ContractStrategyManager *ContractStrategyManagerTransactorSession) Initialize(initialOwner common.Address, initialStrategyWhitelister common.Address, _pauserRegistry common.Address, initialPausedStatus *big.Int) (*types.Transaction, error) { - return _ContractStrategyManager.Contract.Initialize(&_ContractStrategyManager.TransactOpts, initialOwner, initialStrategyWhitelister, _pauserRegistry, initialPausedStatus) -} - -// MigrateQueuedWithdrawal is a paid mutator transaction binding the contract method 0xcd293f6f. -// -// Solidity: function migrateQueuedWithdrawal((address[],uint256[],address,(address,uint96),uint32,address) queuedWithdrawal) returns(bool, bytes32) -func (_ContractStrategyManager *ContractStrategyManagerTransactor) MigrateQueuedWithdrawal(opts *bind.TransactOpts, queuedWithdrawal IStrategyManagerDeprecatedStructQueuedWithdrawal) (*types.Transaction, error) { - return _ContractStrategyManager.contract.Transact(opts, "migrateQueuedWithdrawal", queuedWithdrawal) -} - -// MigrateQueuedWithdrawal is a paid mutator transaction binding the contract method 0xcd293f6f. -// -// Solidity: function migrateQueuedWithdrawal((address[],uint256[],address,(address,uint96),uint32,address) queuedWithdrawal) returns(bool, bytes32) -func (_ContractStrategyManager *ContractStrategyManagerSession) MigrateQueuedWithdrawal(queuedWithdrawal IStrategyManagerDeprecatedStructQueuedWithdrawal) (*types.Transaction, error) { - return _ContractStrategyManager.Contract.MigrateQueuedWithdrawal(&_ContractStrategyManager.TransactOpts, queuedWithdrawal) -} - -// MigrateQueuedWithdrawal is a paid mutator transaction binding the contract method 0xcd293f6f. -// -// Solidity: function migrateQueuedWithdrawal((address[],uint256[],address,(address,uint96),uint32,address) queuedWithdrawal) returns(bool, bytes32) -func (_ContractStrategyManager *ContractStrategyManagerTransactorSession) MigrateQueuedWithdrawal(queuedWithdrawal IStrategyManagerDeprecatedStructQueuedWithdrawal) (*types.Transaction, error) { - return _ContractStrategyManager.Contract.MigrateQueuedWithdrawal(&_ContractStrategyManager.TransactOpts, queuedWithdrawal) -} - -// Pause is a paid mutator transaction binding the contract method 0x136439dd. -// -// Solidity: function pause(uint256 newPausedStatus) returns() -func (_ContractStrategyManager *ContractStrategyManagerTransactor) Pause(opts *bind.TransactOpts, newPausedStatus *big.Int) (*types.Transaction, error) { - return _ContractStrategyManager.contract.Transact(opts, "pause", newPausedStatus) -} - -// Pause is a paid mutator transaction binding the contract method 0x136439dd. -// -// Solidity: function pause(uint256 newPausedStatus) returns() -func (_ContractStrategyManager *ContractStrategyManagerSession) Pause(newPausedStatus *big.Int) (*types.Transaction, error) { - return _ContractStrategyManager.Contract.Pause(&_ContractStrategyManager.TransactOpts, newPausedStatus) -} - -// Pause is a paid mutator transaction binding the contract method 0x136439dd. -// -// Solidity: function pause(uint256 newPausedStatus) returns() -func (_ContractStrategyManager *ContractStrategyManagerTransactorSession) Pause(newPausedStatus *big.Int) (*types.Transaction, error) { - return _ContractStrategyManager.Contract.Pause(&_ContractStrategyManager.TransactOpts, newPausedStatus) -} - -// PauseAll is a paid mutator transaction binding the contract method 0x595c6a67. -// -// Solidity: function pauseAll() returns() -func (_ContractStrategyManager *ContractStrategyManagerTransactor) PauseAll(opts *bind.TransactOpts) (*types.Transaction, error) { - return _ContractStrategyManager.contract.Transact(opts, "pauseAll") -} - -// PauseAll is a paid mutator transaction binding the contract method 0x595c6a67. -// -// Solidity: function pauseAll() returns() -func (_ContractStrategyManager *ContractStrategyManagerSession) PauseAll() (*types.Transaction, error) { - return _ContractStrategyManager.Contract.PauseAll(&_ContractStrategyManager.TransactOpts) -} - -// PauseAll is a paid mutator transaction binding the contract method 0x595c6a67. -// -// Solidity: function pauseAll() returns() -func (_ContractStrategyManager *ContractStrategyManagerTransactorSession) PauseAll() (*types.Transaction, error) { - return _ContractStrategyManager.Contract.PauseAll(&_ContractStrategyManager.TransactOpts) -} - -// RemoveShares is a paid mutator transaction binding the contract method 0x8c80d4e5. -// -// Solidity: function removeShares(address staker, address strategy, uint256 shares) returns() -func (_ContractStrategyManager *ContractStrategyManagerTransactor) RemoveShares(opts *bind.TransactOpts, staker common.Address, strategy common.Address, shares *big.Int) (*types.Transaction, error) { - return _ContractStrategyManager.contract.Transact(opts, "removeShares", staker, strategy, shares) -} - -// RemoveShares is a paid mutator transaction binding the contract method 0x8c80d4e5. -// -// Solidity: function removeShares(address staker, address strategy, uint256 shares) returns() -func (_ContractStrategyManager *ContractStrategyManagerSession) RemoveShares(staker common.Address, strategy common.Address, shares *big.Int) (*types.Transaction, error) { - return _ContractStrategyManager.Contract.RemoveShares(&_ContractStrategyManager.TransactOpts, staker, strategy, shares) -} - -// RemoveShares is a paid mutator transaction binding the contract method 0x8c80d4e5. -// -// Solidity: function removeShares(address staker, address strategy, uint256 shares) returns() -func (_ContractStrategyManager *ContractStrategyManagerTransactorSession) RemoveShares(staker common.Address, strategy common.Address, shares *big.Int) (*types.Transaction, error) { - return _ContractStrategyManager.Contract.RemoveShares(&_ContractStrategyManager.TransactOpts, staker, strategy, shares) -} - -// RemoveStrategiesFromDepositWhitelist is a paid mutator transaction binding the contract method 0xb5d8b5b8. -// -// Solidity: function removeStrategiesFromDepositWhitelist(address[] strategiesToRemoveFromWhitelist) returns() -func (_ContractStrategyManager *ContractStrategyManagerTransactor) RemoveStrategiesFromDepositWhitelist(opts *bind.TransactOpts, strategiesToRemoveFromWhitelist []common.Address) (*types.Transaction, error) { - return _ContractStrategyManager.contract.Transact(opts, "removeStrategiesFromDepositWhitelist", strategiesToRemoveFromWhitelist) -} - -// RemoveStrategiesFromDepositWhitelist is a paid mutator transaction binding the contract method 0xb5d8b5b8. -// -// Solidity: function removeStrategiesFromDepositWhitelist(address[] strategiesToRemoveFromWhitelist) returns() -func (_ContractStrategyManager *ContractStrategyManagerSession) RemoveStrategiesFromDepositWhitelist(strategiesToRemoveFromWhitelist []common.Address) (*types.Transaction, error) { - return _ContractStrategyManager.Contract.RemoveStrategiesFromDepositWhitelist(&_ContractStrategyManager.TransactOpts, strategiesToRemoveFromWhitelist) -} - -// RemoveStrategiesFromDepositWhitelist is a paid mutator transaction binding the contract method 0xb5d8b5b8. -// -// Solidity: function removeStrategiesFromDepositWhitelist(address[] strategiesToRemoveFromWhitelist) returns() -func (_ContractStrategyManager *ContractStrategyManagerTransactorSession) RemoveStrategiesFromDepositWhitelist(strategiesToRemoveFromWhitelist []common.Address) (*types.Transaction, error) { - return _ContractStrategyManager.Contract.RemoveStrategiesFromDepositWhitelist(&_ContractStrategyManager.TransactOpts, strategiesToRemoveFromWhitelist) -} - -// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. -// -// Solidity: function renounceOwnership() returns() -func (_ContractStrategyManager *ContractStrategyManagerTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) { - return _ContractStrategyManager.contract.Transact(opts, "renounceOwnership") -} - -// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. -// -// Solidity: function renounceOwnership() returns() -func (_ContractStrategyManager *ContractStrategyManagerSession) RenounceOwnership() (*types.Transaction, error) { - return _ContractStrategyManager.Contract.RenounceOwnership(&_ContractStrategyManager.TransactOpts) -} - -// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. -// -// Solidity: function renounceOwnership() returns() -func (_ContractStrategyManager *ContractStrategyManagerTransactorSession) RenounceOwnership() (*types.Transaction, error) { - return _ContractStrategyManager.Contract.RenounceOwnership(&_ContractStrategyManager.TransactOpts) -} - -// SetPauserRegistry is a paid mutator transaction binding the contract method 0x10d67a2f. -// -// Solidity: function setPauserRegistry(address newPauserRegistry) returns() -func (_ContractStrategyManager *ContractStrategyManagerTransactor) SetPauserRegistry(opts *bind.TransactOpts, newPauserRegistry common.Address) (*types.Transaction, error) { - return _ContractStrategyManager.contract.Transact(opts, "setPauserRegistry", newPauserRegistry) -} - -// SetPauserRegistry is a paid mutator transaction binding the contract method 0x10d67a2f. -// -// Solidity: function setPauserRegistry(address newPauserRegistry) returns() -func (_ContractStrategyManager *ContractStrategyManagerSession) SetPauserRegistry(newPauserRegistry common.Address) (*types.Transaction, error) { - return _ContractStrategyManager.Contract.SetPauserRegistry(&_ContractStrategyManager.TransactOpts, newPauserRegistry) -} - -// SetPauserRegistry is a paid mutator transaction binding the contract method 0x10d67a2f. -// -// Solidity: function setPauserRegistry(address newPauserRegistry) returns() -func (_ContractStrategyManager *ContractStrategyManagerTransactorSession) SetPauserRegistry(newPauserRegistry common.Address) (*types.Transaction, error) { - return _ContractStrategyManager.Contract.SetPauserRegistry(&_ContractStrategyManager.TransactOpts, newPauserRegistry) -} - -// SetStrategyWhitelister is a paid mutator transaction binding the contract method 0xc6656702. -// -// Solidity: function setStrategyWhitelister(address newStrategyWhitelister) returns() -func (_ContractStrategyManager *ContractStrategyManagerTransactor) SetStrategyWhitelister(opts *bind.TransactOpts, newStrategyWhitelister common.Address) (*types.Transaction, error) { - return _ContractStrategyManager.contract.Transact(opts, "setStrategyWhitelister", newStrategyWhitelister) -} - -// SetStrategyWhitelister is a paid mutator transaction binding the contract method 0xc6656702. -// -// Solidity: function setStrategyWhitelister(address newStrategyWhitelister) returns() -func (_ContractStrategyManager *ContractStrategyManagerSession) SetStrategyWhitelister(newStrategyWhitelister common.Address) (*types.Transaction, error) { - return _ContractStrategyManager.Contract.SetStrategyWhitelister(&_ContractStrategyManager.TransactOpts, newStrategyWhitelister) -} - -// SetStrategyWhitelister is a paid mutator transaction binding the contract method 0xc6656702. -// -// Solidity: function setStrategyWhitelister(address newStrategyWhitelister) returns() -func (_ContractStrategyManager *ContractStrategyManagerTransactorSession) SetStrategyWhitelister(newStrategyWhitelister common.Address) (*types.Transaction, error) { - return _ContractStrategyManager.Contract.SetStrategyWhitelister(&_ContractStrategyManager.TransactOpts, newStrategyWhitelister) -} - -// SetThirdPartyTransfersForbidden is a paid mutator transaction binding the contract method 0x4e5a4263. -// -// Solidity: function setThirdPartyTransfersForbidden(address strategy, bool value) returns() -func (_ContractStrategyManager *ContractStrategyManagerTransactor) SetThirdPartyTransfersForbidden(opts *bind.TransactOpts, strategy common.Address, value bool) (*types.Transaction, error) { - return _ContractStrategyManager.contract.Transact(opts, "setThirdPartyTransfersForbidden", strategy, value) -} - -// SetThirdPartyTransfersForbidden is a paid mutator transaction binding the contract method 0x4e5a4263. -// -// Solidity: function setThirdPartyTransfersForbidden(address strategy, bool value) returns() -func (_ContractStrategyManager *ContractStrategyManagerSession) SetThirdPartyTransfersForbidden(strategy common.Address, value bool) (*types.Transaction, error) { - return _ContractStrategyManager.Contract.SetThirdPartyTransfersForbidden(&_ContractStrategyManager.TransactOpts, strategy, value) -} - -// SetThirdPartyTransfersForbidden is a paid mutator transaction binding the contract method 0x4e5a4263. -// -// Solidity: function setThirdPartyTransfersForbidden(address strategy, bool value) returns() -func (_ContractStrategyManager *ContractStrategyManagerTransactorSession) SetThirdPartyTransfersForbidden(strategy common.Address, value bool) (*types.Transaction, error) { - return _ContractStrategyManager.Contract.SetThirdPartyTransfersForbidden(&_ContractStrategyManager.TransactOpts, strategy, value) -} - -// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. -// -// Solidity: function transferOwnership(address newOwner) returns() -func (_ContractStrategyManager *ContractStrategyManagerTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { - return _ContractStrategyManager.contract.Transact(opts, "transferOwnership", newOwner) -} - -// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. -// -// Solidity: function transferOwnership(address newOwner) returns() -func (_ContractStrategyManager *ContractStrategyManagerSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { - return _ContractStrategyManager.Contract.TransferOwnership(&_ContractStrategyManager.TransactOpts, newOwner) -} - -// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. -// -// Solidity: function transferOwnership(address newOwner) returns() -func (_ContractStrategyManager *ContractStrategyManagerTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { - return _ContractStrategyManager.Contract.TransferOwnership(&_ContractStrategyManager.TransactOpts, newOwner) -} - -// Unpause is a paid mutator transaction binding the contract method 0xfabc1cbc. -// -// Solidity: function unpause(uint256 newPausedStatus) returns() -func (_ContractStrategyManager *ContractStrategyManagerTransactor) Unpause(opts *bind.TransactOpts, newPausedStatus *big.Int) (*types.Transaction, error) { - return _ContractStrategyManager.contract.Transact(opts, "unpause", newPausedStatus) -} - -// Unpause is a paid mutator transaction binding the contract method 0xfabc1cbc. -// -// Solidity: function unpause(uint256 newPausedStatus) returns() -func (_ContractStrategyManager *ContractStrategyManagerSession) Unpause(newPausedStatus *big.Int) (*types.Transaction, error) { - return _ContractStrategyManager.Contract.Unpause(&_ContractStrategyManager.TransactOpts, newPausedStatus) -} - -// Unpause is a paid mutator transaction binding the contract method 0xfabc1cbc. -// -// Solidity: function unpause(uint256 newPausedStatus) returns() -func (_ContractStrategyManager *ContractStrategyManagerTransactorSession) Unpause(newPausedStatus *big.Int) (*types.Transaction, error) { - return _ContractStrategyManager.Contract.Unpause(&_ContractStrategyManager.TransactOpts, newPausedStatus) -} - -// WithdrawSharesAsTokens is a paid mutator transaction binding the contract method 0xc608c7f3. -// -// Solidity: function withdrawSharesAsTokens(address recipient, address strategy, uint256 shares, address token) returns() -func (_ContractStrategyManager *ContractStrategyManagerTransactor) WithdrawSharesAsTokens(opts *bind.TransactOpts, recipient common.Address, strategy common.Address, shares *big.Int, token common.Address) (*types.Transaction, error) { - return _ContractStrategyManager.contract.Transact(opts, "withdrawSharesAsTokens", recipient, strategy, shares, token) -} - -// WithdrawSharesAsTokens is a paid mutator transaction binding the contract method 0xc608c7f3. -// -// Solidity: function withdrawSharesAsTokens(address recipient, address strategy, uint256 shares, address token) returns() -func (_ContractStrategyManager *ContractStrategyManagerSession) WithdrawSharesAsTokens(recipient common.Address, strategy common.Address, shares *big.Int, token common.Address) (*types.Transaction, error) { - return _ContractStrategyManager.Contract.WithdrawSharesAsTokens(&_ContractStrategyManager.TransactOpts, recipient, strategy, shares, token) -} - -// WithdrawSharesAsTokens is a paid mutator transaction binding the contract method 0xc608c7f3. -// -// Solidity: function withdrawSharesAsTokens(address recipient, address strategy, uint256 shares, address token) returns() -func (_ContractStrategyManager *ContractStrategyManagerTransactorSession) WithdrawSharesAsTokens(recipient common.Address, strategy common.Address, shares *big.Int, token common.Address) (*types.Transaction, error) { - return _ContractStrategyManager.Contract.WithdrawSharesAsTokens(&_ContractStrategyManager.TransactOpts, recipient, strategy, shares, token) -} - -// ContractStrategyManagerDepositIterator is returned from FilterDeposit and is used to iterate over the raw logs and unpacked data for Deposit events raised by the ContractStrategyManager contract. -type ContractStrategyManagerDepositIterator struct { - Event *ContractStrategyManagerDeposit // 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 *ContractStrategyManagerDepositIterator) 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(ContractStrategyManagerDeposit) - 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(ContractStrategyManagerDeposit) - 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 *ContractStrategyManagerDepositIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ContractStrategyManagerDepositIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ContractStrategyManagerDeposit represents a Deposit event raised by the ContractStrategyManager contract. -type ContractStrategyManagerDeposit struct { - Staker common.Address - Token common.Address - Strategy common.Address - Shares *big.Int - Raw types.Log // Blockchain specific contextual infos -} - -// FilterDeposit is a free log retrieval operation binding the contract event 0x7cfff908a4b583f36430b25d75964c458d8ede8a99bd61be750e97ee1b2f3a96. -// -// Solidity: event Deposit(address staker, address token, address strategy, uint256 shares) -func (_ContractStrategyManager *ContractStrategyManagerFilterer) FilterDeposit(opts *bind.FilterOpts) (*ContractStrategyManagerDepositIterator, error) { - - logs, sub, err := _ContractStrategyManager.contract.FilterLogs(opts, "Deposit") - if err != nil { - return nil, err - } - return &ContractStrategyManagerDepositIterator{contract: _ContractStrategyManager.contract, event: "Deposit", logs: logs, sub: sub}, nil -} - -// WatchDeposit is a free log subscription operation binding the contract event 0x7cfff908a4b583f36430b25d75964c458d8ede8a99bd61be750e97ee1b2f3a96. -// -// Solidity: event Deposit(address staker, address token, address strategy, uint256 shares) -func (_ContractStrategyManager *ContractStrategyManagerFilterer) WatchDeposit(opts *bind.WatchOpts, sink chan<- *ContractStrategyManagerDeposit) (event.Subscription, error) { - - logs, sub, err := _ContractStrategyManager.contract.WatchLogs(opts, "Deposit") - 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(ContractStrategyManagerDeposit) - if err := _ContractStrategyManager.contract.UnpackLog(event, "Deposit", 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 -} - -// ParseDeposit is a log parse operation binding the contract event 0x7cfff908a4b583f36430b25d75964c458d8ede8a99bd61be750e97ee1b2f3a96. -// -// Solidity: event Deposit(address staker, address token, address strategy, uint256 shares) -func (_ContractStrategyManager *ContractStrategyManagerFilterer) ParseDeposit(log types.Log) (*ContractStrategyManagerDeposit, error) { - event := new(ContractStrategyManagerDeposit) - if err := _ContractStrategyManager.contract.UnpackLog(event, "Deposit", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ContractStrategyManagerInitializedIterator is returned from FilterInitialized and is used to iterate over the raw logs and unpacked data for Initialized events raised by the ContractStrategyManager contract. -type ContractStrategyManagerInitializedIterator struct { - Event *ContractStrategyManagerInitialized // 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 *ContractStrategyManagerInitializedIterator) 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(ContractStrategyManagerInitialized) - 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(ContractStrategyManagerInitialized) - 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 *ContractStrategyManagerInitializedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ContractStrategyManagerInitializedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ContractStrategyManagerInitialized represents a Initialized event raised by the ContractStrategyManager contract. -type ContractStrategyManagerInitialized 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 (_ContractStrategyManager *ContractStrategyManagerFilterer) FilterInitialized(opts *bind.FilterOpts) (*ContractStrategyManagerInitializedIterator, error) { - - logs, sub, err := _ContractStrategyManager.contract.FilterLogs(opts, "Initialized") - if err != nil { - return nil, err - } - return &ContractStrategyManagerInitializedIterator{contract: _ContractStrategyManager.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 (_ContractStrategyManager *ContractStrategyManagerFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *ContractStrategyManagerInitialized) (event.Subscription, error) { - - logs, sub, err := _ContractStrategyManager.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(ContractStrategyManagerInitialized) - if err := _ContractStrategyManager.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 (_ContractStrategyManager *ContractStrategyManagerFilterer) ParseInitialized(log types.Log) (*ContractStrategyManagerInitialized, error) { - event := new(ContractStrategyManagerInitialized) - if err := _ContractStrategyManager.contract.UnpackLog(event, "Initialized", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ContractStrategyManagerOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the ContractStrategyManager contract. -type ContractStrategyManagerOwnershipTransferredIterator struct { - Event *ContractStrategyManagerOwnershipTransferred // 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 *ContractStrategyManagerOwnershipTransferredIterator) 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(ContractStrategyManagerOwnershipTransferred) - 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(ContractStrategyManagerOwnershipTransferred) - 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 *ContractStrategyManagerOwnershipTransferredIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ContractStrategyManagerOwnershipTransferredIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ContractStrategyManagerOwnershipTransferred represents a OwnershipTransferred event raised by the ContractStrategyManager contract. -type ContractStrategyManagerOwnershipTransferred 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 (_ContractStrategyManager *ContractStrategyManagerFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*ContractStrategyManagerOwnershipTransferredIterator, 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 := _ContractStrategyManager.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) - if err != nil { - return nil, err - } - return &ContractStrategyManagerOwnershipTransferredIterator{contract: _ContractStrategyManager.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 (_ContractStrategyManager *ContractStrategyManagerFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *ContractStrategyManagerOwnershipTransferred, 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 := _ContractStrategyManager.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(ContractStrategyManagerOwnershipTransferred) - if err := _ContractStrategyManager.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 (_ContractStrategyManager *ContractStrategyManagerFilterer) ParseOwnershipTransferred(log types.Log) (*ContractStrategyManagerOwnershipTransferred, error) { - event := new(ContractStrategyManagerOwnershipTransferred) - if err := _ContractStrategyManager.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ContractStrategyManagerPausedIterator is returned from FilterPaused and is used to iterate over the raw logs and unpacked data for Paused events raised by the ContractStrategyManager contract. -type ContractStrategyManagerPausedIterator struct { - Event *ContractStrategyManagerPaused // 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 *ContractStrategyManagerPausedIterator) 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(ContractStrategyManagerPaused) - 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(ContractStrategyManagerPaused) - 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 *ContractStrategyManagerPausedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ContractStrategyManagerPausedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ContractStrategyManagerPaused represents a Paused event raised by the ContractStrategyManager contract. -type ContractStrategyManagerPaused struct { - Account common.Address - NewPausedStatus *big.Int - Raw types.Log // Blockchain specific contextual infos -} - -// FilterPaused is a free log retrieval operation binding the contract event 0xab40a374bc51de372200a8bc981af8c9ecdc08dfdaef0bb6e09f88f3c616ef3d. -// -// Solidity: event Paused(address indexed account, uint256 newPausedStatus) -func (_ContractStrategyManager *ContractStrategyManagerFilterer) FilterPaused(opts *bind.FilterOpts, account []common.Address) (*ContractStrategyManagerPausedIterator, error) { - - var accountRule []interface{} - for _, accountItem := range account { - accountRule = append(accountRule, accountItem) - } - - logs, sub, err := _ContractStrategyManager.contract.FilterLogs(opts, "Paused", accountRule) - if err != nil { - return nil, err - } - return &ContractStrategyManagerPausedIterator{contract: _ContractStrategyManager.contract, event: "Paused", logs: logs, sub: sub}, nil -} - -// WatchPaused is a free log subscription operation binding the contract event 0xab40a374bc51de372200a8bc981af8c9ecdc08dfdaef0bb6e09f88f3c616ef3d. -// -// Solidity: event Paused(address indexed account, uint256 newPausedStatus) -func (_ContractStrategyManager *ContractStrategyManagerFilterer) WatchPaused(opts *bind.WatchOpts, sink chan<- *ContractStrategyManagerPaused, account []common.Address) (event.Subscription, error) { - - var accountRule []interface{} - for _, accountItem := range account { - accountRule = append(accountRule, accountItem) - } - - logs, sub, err := _ContractStrategyManager.contract.WatchLogs(opts, "Paused", 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(ContractStrategyManagerPaused) - if err := _ContractStrategyManager.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 0xab40a374bc51de372200a8bc981af8c9ecdc08dfdaef0bb6e09f88f3c616ef3d. -// -// Solidity: event Paused(address indexed account, uint256 newPausedStatus) -func (_ContractStrategyManager *ContractStrategyManagerFilterer) ParsePaused(log types.Log) (*ContractStrategyManagerPaused, error) { - event := new(ContractStrategyManagerPaused) - if err := _ContractStrategyManager.contract.UnpackLog(event, "Paused", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ContractStrategyManagerPauserRegistrySetIterator is returned from FilterPauserRegistrySet and is used to iterate over the raw logs and unpacked data for PauserRegistrySet events raised by the ContractStrategyManager contract. -type ContractStrategyManagerPauserRegistrySetIterator struct { - Event *ContractStrategyManagerPauserRegistrySet // 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 *ContractStrategyManagerPauserRegistrySetIterator) 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(ContractStrategyManagerPauserRegistrySet) - 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(ContractStrategyManagerPauserRegistrySet) - 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 *ContractStrategyManagerPauserRegistrySetIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ContractStrategyManagerPauserRegistrySetIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ContractStrategyManagerPauserRegistrySet represents a PauserRegistrySet event raised by the ContractStrategyManager contract. -type ContractStrategyManagerPauserRegistrySet struct { - PauserRegistry common.Address - NewPauserRegistry common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterPauserRegistrySet is a free log retrieval operation binding the contract event 0x6e9fcd539896fca60e8b0f01dd580233e48a6b0f7df013b89ba7f565869acdb6. -// -// Solidity: event PauserRegistrySet(address pauserRegistry, address newPauserRegistry) -func (_ContractStrategyManager *ContractStrategyManagerFilterer) FilterPauserRegistrySet(opts *bind.FilterOpts) (*ContractStrategyManagerPauserRegistrySetIterator, error) { - - logs, sub, err := _ContractStrategyManager.contract.FilterLogs(opts, "PauserRegistrySet") - if err != nil { - return nil, err - } - return &ContractStrategyManagerPauserRegistrySetIterator{contract: _ContractStrategyManager.contract, event: "PauserRegistrySet", logs: logs, sub: sub}, nil -} - -// WatchPauserRegistrySet is a free log subscription operation binding the contract event 0x6e9fcd539896fca60e8b0f01dd580233e48a6b0f7df013b89ba7f565869acdb6. -// -// Solidity: event PauserRegistrySet(address pauserRegistry, address newPauserRegistry) -func (_ContractStrategyManager *ContractStrategyManagerFilterer) WatchPauserRegistrySet(opts *bind.WatchOpts, sink chan<- *ContractStrategyManagerPauserRegistrySet) (event.Subscription, error) { - - logs, sub, err := _ContractStrategyManager.contract.WatchLogs(opts, "PauserRegistrySet") - 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(ContractStrategyManagerPauserRegistrySet) - if err := _ContractStrategyManager.contract.UnpackLog(event, "PauserRegistrySet", 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 -} - -// ParsePauserRegistrySet is a log parse operation binding the contract event 0x6e9fcd539896fca60e8b0f01dd580233e48a6b0f7df013b89ba7f565869acdb6. -// -// Solidity: event PauserRegistrySet(address pauserRegistry, address newPauserRegistry) -func (_ContractStrategyManager *ContractStrategyManagerFilterer) ParsePauserRegistrySet(log types.Log) (*ContractStrategyManagerPauserRegistrySet, error) { - event := new(ContractStrategyManagerPauserRegistrySet) - if err := _ContractStrategyManager.contract.UnpackLog(event, "PauserRegistrySet", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ContractStrategyManagerStrategyAddedToDepositWhitelistIterator is returned from FilterStrategyAddedToDepositWhitelist and is used to iterate over the raw logs and unpacked data for StrategyAddedToDepositWhitelist events raised by the ContractStrategyManager contract. -type ContractStrategyManagerStrategyAddedToDepositWhitelistIterator struct { - Event *ContractStrategyManagerStrategyAddedToDepositWhitelist // 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 *ContractStrategyManagerStrategyAddedToDepositWhitelistIterator) 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(ContractStrategyManagerStrategyAddedToDepositWhitelist) - 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(ContractStrategyManagerStrategyAddedToDepositWhitelist) - 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 *ContractStrategyManagerStrategyAddedToDepositWhitelistIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ContractStrategyManagerStrategyAddedToDepositWhitelistIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ContractStrategyManagerStrategyAddedToDepositWhitelist represents a StrategyAddedToDepositWhitelist event raised by the ContractStrategyManager contract. -type ContractStrategyManagerStrategyAddedToDepositWhitelist struct { - Strategy common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterStrategyAddedToDepositWhitelist is a free log retrieval operation binding the contract event 0x0c35b17d91c96eb2751cd456e1252f42a386e524ef9ff26ecc9950859fdc04fe. -// -// Solidity: event StrategyAddedToDepositWhitelist(address strategy) -func (_ContractStrategyManager *ContractStrategyManagerFilterer) FilterStrategyAddedToDepositWhitelist(opts *bind.FilterOpts) (*ContractStrategyManagerStrategyAddedToDepositWhitelistIterator, error) { - - logs, sub, err := _ContractStrategyManager.contract.FilterLogs(opts, "StrategyAddedToDepositWhitelist") - if err != nil { - return nil, err - } - return &ContractStrategyManagerStrategyAddedToDepositWhitelistIterator{contract: _ContractStrategyManager.contract, event: "StrategyAddedToDepositWhitelist", logs: logs, sub: sub}, nil -} - -// WatchStrategyAddedToDepositWhitelist is a free log subscription operation binding the contract event 0x0c35b17d91c96eb2751cd456e1252f42a386e524ef9ff26ecc9950859fdc04fe. -// -// Solidity: event StrategyAddedToDepositWhitelist(address strategy) -func (_ContractStrategyManager *ContractStrategyManagerFilterer) WatchStrategyAddedToDepositWhitelist(opts *bind.WatchOpts, sink chan<- *ContractStrategyManagerStrategyAddedToDepositWhitelist) (event.Subscription, error) { - - logs, sub, err := _ContractStrategyManager.contract.WatchLogs(opts, "StrategyAddedToDepositWhitelist") - 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(ContractStrategyManagerStrategyAddedToDepositWhitelist) - if err := _ContractStrategyManager.contract.UnpackLog(event, "StrategyAddedToDepositWhitelist", 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 -} - -// ParseStrategyAddedToDepositWhitelist is a log parse operation binding the contract event 0x0c35b17d91c96eb2751cd456e1252f42a386e524ef9ff26ecc9950859fdc04fe. -// -// Solidity: event StrategyAddedToDepositWhitelist(address strategy) -func (_ContractStrategyManager *ContractStrategyManagerFilterer) ParseStrategyAddedToDepositWhitelist(log types.Log) (*ContractStrategyManagerStrategyAddedToDepositWhitelist, error) { - event := new(ContractStrategyManagerStrategyAddedToDepositWhitelist) - if err := _ContractStrategyManager.contract.UnpackLog(event, "StrategyAddedToDepositWhitelist", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ContractStrategyManagerStrategyRemovedFromDepositWhitelistIterator is returned from FilterStrategyRemovedFromDepositWhitelist and is used to iterate over the raw logs and unpacked data for StrategyRemovedFromDepositWhitelist events raised by the ContractStrategyManager contract. -type ContractStrategyManagerStrategyRemovedFromDepositWhitelistIterator struct { - Event *ContractStrategyManagerStrategyRemovedFromDepositWhitelist // 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 *ContractStrategyManagerStrategyRemovedFromDepositWhitelistIterator) 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(ContractStrategyManagerStrategyRemovedFromDepositWhitelist) - 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(ContractStrategyManagerStrategyRemovedFromDepositWhitelist) - 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 *ContractStrategyManagerStrategyRemovedFromDepositWhitelistIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ContractStrategyManagerStrategyRemovedFromDepositWhitelistIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ContractStrategyManagerStrategyRemovedFromDepositWhitelist represents a StrategyRemovedFromDepositWhitelist event raised by the ContractStrategyManager contract. -type ContractStrategyManagerStrategyRemovedFromDepositWhitelist struct { - Strategy common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterStrategyRemovedFromDepositWhitelist is a free log retrieval operation binding the contract event 0x4074413b4b443e4e58019f2855a8765113358c7c72e39509c6af45fc0f5ba030. -// -// Solidity: event StrategyRemovedFromDepositWhitelist(address strategy) -func (_ContractStrategyManager *ContractStrategyManagerFilterer) FilterStrategyRemovedFromDepositWhitelist(opts *bind.FilterOpts) (*ContractStrategyManagerStrategyRemovedFromDepositWhitelistIterator, error) { - - logs, sub, err := _ContractStrategyManager.contract.FilterLogs(opts, "StrategyRemovedFromDepositWhitelist") - if err != nil { - return nil, err - } - return &ContractStrategyManagerStrategyRemovedFromDepositWhitelistIterator{contract: _ContractStrategyManager.contract, event: "StrategyRemovedFromDepositWhitelist", logs: logs, sub: sub}, nil -} - -// WatchStrategyRemovedFromDepositWhitelist is a free log subscription operation binding the contract event 0x4074413b4b443e4e58019f2855a8765113358c7c72e39509c6af45fc0f5ba030. -// -// Solidity: event StrategyRemovedFromDepositWhitelist(address strategy) -func (_ContractStrategyManager *ContractStrategyManagerFilterer) WatchStrategyRemovedFromDepositWhitelist(opts *bind.WatchOpts, sink chan<- *ContractStrategyManagerStrategyRemovedFromDepositWhitelist) (event.Subscription, error) { - - logs, sub, err := _ContractStrategyManager.contract.WatchLogs(opts, "StrategyRemovedFromDepositWhitelist") - 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(ContractStrategyManagerStrategyRemovedFromDepositWhitelist) - if err := _ContractStrategyManager.contract.UnpackLog(event, "StrategyRemovedFromDepositWhitelist", 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 -} - -// ParseStrategyRemovedFromDepositWhitelist is a log parse operation binding the contract event 0x4074413b4b443e4e58019f2855a8765113358c7c72e39509c6af45fc0f5ba030. -// -// Solidity: event StrategyRemovedFromDepositWhitelist(address strategy) -func (_ContractStrategyManager *ContractStrategyManagerFilterer) ParseStrategyRemovedFromDepositWhitelist(log types.Log) (*ContractStrategyManagerStrategyRemovedFromDepositWhitelist, error) { - event := new(ContractStrategyManagerStrategyRemovedFromDepositWhitelist) - if err := _ContractStrategyManager.contract.UnpackLog(event, "StrategyRemovedFromDepositWhitelist", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ContractStrategyManagerStrategyWhitelisterChangedIterator is returned from FilterStrategyWhitelisterChanged and is used to iterate over the raw logs and unpacked data for StrategyWhitelisterChanged events raised by the ContractStrategyManager contract. -type ContractStrategyManagerStrategyWhitelisterChangedIterator struct { - Event *ContractStrategyManagerStrategyWhitelisterChanged // 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 *ContractStrategyManagerStrategyWhitelisterChangedIterator) 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(ContractStrategyManagerStrategyWhitelisterChanged) - 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(ContractStrategyManagerStrategyWhitelisterChanged) - 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 *ContractStrategyManagerStrategyWhitelisterChangedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ContractStrategyManagerStrategyWhitelisterChangedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ContractStrategyManagerStrategyWhitelisterChanged represents a StrategyWhitelisterChanged event raised by the ContractStrategyManager contract. -type ContractStrategyManagerStrategyWhitelisterChanged struct { - PreviousAddress common.Address - NewAddress common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterStrategyWhitelisterChanged is a free log retrieval operation binding the contract event 0x4264275e593955ff9d6146a51a4525f6ddace2e81db9391abcc9d1ca48047d29. -// -// Solidity: event StrategyWhitelisterChanged(address previousAddress, address newAddress) -func (_ContractStrategyManager *ContractStrategyManagerFilterer) FilterStrategyWhitelisterChanged(opts *bind.FilterOpts) (*ContractStrategyManagerStrategyWhitelisterChangedIterator, error) { - - logs, sub, err := _ContractStrategyManager.contract.FilterLogs(opts, "StrategyWhitelisterChanged") - if err != nil { - return nil, err - } - return &ContractStrategyManagerStrategyWhitelisterChangedIterator{contract: _ContractStrategyManager.contract, event: "StrategyWhitelisterChanged", logs: logs, sub: sub}, nil -} - -// WatchStrategyWhitelisterChanged is a free log subscription operation binding the contract event 0x4264275e593955ff9d6146a51a4525f6ddace2e81db9391abcc9d1ca48047d29. -// -// Solidity: event StrategyWhitelisterChanged(address previousAddress, address newAddress) -func (_ContractStrategyManager *ContractStrategyManagerFilterer) WatchStrategyWhitelisterChanged(opts *bind.WatchOpts, sink chan<- *ContractStrategyManagerStrategyWhitelisterChanged) (event.Subscription, error) { - - logs, sub, err := _ContractStrategyManager.contract.WatchLogs(opts, "StrategyWhitelisterChanged") - 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(ContractStrategyManagerStrategyWhitelisterChanged) - if err := _ContractStrategyManager.contract.UnpackLog(event, "StrategyWhitelisterChanged", 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 -} - -// ParseStrategyWhitelisterChanged is a log parse operation binding the contract event 0x4264275e593955ff9d6146a51a4525f6ddace2e81db9391abcc9d1ca48047d29. -// -// Solidity: event StrategyWhitelisterChanged(address previousAddress, address newAddress) -func (_ContractStrategyManager *ContractStrategyManagerFilterer) ParseStrategyWhitelisterChanged(log types.Log) (*ContractStrategyManagerStrategyWhitelisterChanged, error) { - event := new(ContractStrategyManagerStrategyWhitelisterChanged) - if err := _ContractStrategyManager.contract.UnpackLog(event, "StrategyWhitelisterChanged", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ContractStrategyManagerUnpausedIterator is returned from FilterUnpaused and is used to iterate over the raw logs and unpacked data for Unpaused events raised by the ContractStrategyManager contract. -type ContractStrategyManagerUnpausedIterator struct { - Event *ContractStrategyManagerUnpaused // 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 *ContractStrategyManagerUnpausedIterator) 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(ContractStrategyManagerUnpaused) - 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(ContractStrategyManagerUnpaused) - 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 *ContractStrategyManagerUnpausedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ContractStrategyManagerUnpausedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ContractStrategyManagerUnpaused represents a Unpaused event raised by the ContractStrategyManager contract. -type ContractStrategyManagerUnpaused struct { - Account common.Address - NewPausedStatus *big.Int - Raw types.Log // Blockchain specific contextual infos -} - -// FilterUnpaused is a free log retrieval operation binding the contract event 0x3582d1828e26bf56bd801502bc021ac0bc8afb57c826e4986b45593c8fad389c. -// -// Solidity: event Unpaused(address indexed account, uint256 newPausedStatus) -func (_ContractStrategyManager *ContractStrategyManagerFilterer) FilterUnpaused(opts *bind.FilterOpts, account []common.Address) (*ContractStrategyManagerUnpausedIterator, error) { - - var accountRule []interface{} - for _, accountItem := range account { - accountRule = append(accountRule, accountItem) - } - - logs, sub, err := _ContractStrategyManager.contract.FilterLogs(opts, "Unpaused", accountRule) - if err != nil { - return nil, err - } - return &ContractStrategyManagerUnpausedIterator{contract: _ContractStrategyManager.contract, event: "Unpaused", logs: logs, sub: sub}, nil -} - -// WatchUnpaused is a free log subscription operation binding the contract event 0x3582d1828e26bf56bd801502bc021ac0bc8afb57c826e4986b45593c8fad389c. -// -// Solidity: event Unpaused(address indexed account, uint256 newPausedStatus) -func (_ContractStrategyManager *ContractStrategyManagerFilterer) WatchUnpaused(opts *bind.WatchOpts, sink chan<- *ContractStrategyManagerUnpaused, account []common.Address) (event.Subscription, error) { - - var accountRule []interface{} - for _, accountItem := range account { - accountRule = append(accountRule, accountItem) - } - - logs, sub, err := _ContractStrategyManager.contract.WatchLogs(opts, "Unpaused", 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(ContractStrategyManagerUnpaused) - if err := _ContractStrategyManager.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 0x3582d1828e26bf56bd801502bc021ac0bc8afb57c826e4986b45593c8fad389c. -// -// Solidity: event Unpaused(address indexed account, uint256 newPausedStatus) -func (_ContractStrategyManager *ContractStrategyManagerFilterer) ParseUnpaused(log types.Log) (*ContractStrategyManagerUnpaused, error) { - event := new(ContractStrategyManagerUnpaused) - if err := _ContractStrategyManager.contract.UnpackLog(event, "Unpaused", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ContractStrategyManagerUpdatedThirdPartyTransfersForbiddenIterator is returned from FilterUpdatedThirdPartyTransfersForbidden and is used to iterate over the raw logs and unpacked data for UpdatedThirdPartyTransfersForbidden events raised by the ContractStrategyManager contract. -type ContractStrategyManagerUpdatedThirdPartyTransfersForbiddenIterator struct { - Event *ContractStrategyManagerUpdatedThirdPartyTransfersForbidden // 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 *ContractStrategyManagerUpdatedThirdPartyTransfersForbiddenIterator) 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(ContractStrategyManagerUpdatedThirdPartyTransfersForbidden) - 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(ContractStrategyManagerUpdatedThirdPartyTransfersForbidden) - 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 *ContractStrategyManagerUpdatedThirdPartyTransfersForbiddenIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ContractStrategyManagerUpdatedThirdPartyTransfersForbiddenIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ContractStrategyManagerUpdatedThirdPartyTransfersForbidden represents a UpdatedThirdPartyTransfersForbidden event raised by the ContractStrategyManager contract. -type ContractStrategyManagerUpdatedThirdPartyTransfersForbidden struct { - Strategy common.Address - Value bool - Raw types.Log // Blockchain specific contextual infos -} - -// FilterUpdatedThirdPartyTransfersForbidden is a free log retrieval operation binding the contract event 0x77d930df4937793473a95024d87a98fd2ccb9e92d3c2463b3dacd65d3e6a5786. -// -// Solidity: event UpdatedThirdPartyTransfersForbidden(address strategy, bool value) -func (_ContractStrategyManager *ContractStrategyManagerFilterer) FilterUpdatedThirdPartyTransfersForbidden(opts *bind.FilterOpts) (*ContractStrategyManagerUpdatedThirdPartyTransfersForbiddenIterator, error) { - - logs, sub, err := _ContractStrategyManager.contract.FilterLogs(opts, "UpdatedThirdPartyTransfersForbidden") - if err != nil { - return nil, err - } - return &ContractStrategyManagerUpdatedThirdPartyTransfersForbiddenIterator{contract: _ContractStrategyManager.contract, event: "UpdatedThirdPartyTransfersForbidden", logs: logs, sub: sub}, nil -} - -// WatchUpdatedThirdPartyTransfersForbidden is a free log subscription operation binding the contract event 0x77d930df4937793473a95024d87a98fd2ccb9e92d3c2463b3dacd65d3e6a5786. -// -// Solidity: event UpdatedThirdPartyTransfersForbidden(address strategy, bool value) -func (_ContractStrategyManager *ContractStrategyManagerFilterer) WatchUpdatedThirdPartyTransfersForbidden(opts *bind.WatchOpts, sink chan<- *ContractStrategyManagerUpdatedThirdPartyTransfersForbidden) (event.Subscription, error) { - - logs, sub, err := _ContractStrategyManager.contract.WatchLogs(opts, "UpdatedThirdPartyTransfersForbidden") - 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(ContractStrategyManagerUpdatedThirdPartyTransfersForbidden) - if err := _ContractStrategyManager.contract.UnpackLog(event, "UpdatedThirdPartyTransfersForbidden", 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 -} - -// ParseUpdatedThirdPartyTransfersForbidden is a log parse operation binding the contract event 0x77d930df4937793473a95024d87a98fd2ccb9e92d3c2463b3dacd65d3e6a5786. -// -// Solidity: event UpdatedThirdPartyTransfersForbidden(address strategy, bool value) -func (_ContractStrategyManager *ContractStrategyManagerFilterer) ParseUpdatedThirdPartyTransfersForbidden(log types.Log) (*ContractStrategyManagerUpdatedThirdPartyTransfersForbidden, error) { - event := new(ContractStrategyManagerUpdatedThirdPartyTransfersForbidden) - if err := _ContractStrategyManager.contract.UnpackLog(event, "UpdatedThirdPartyTransfersForbidden", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} diff --git a/contracts/generate.go b/contracts/generate.go new file mode 100644 index 0000000..bebe8ad --- /dev/null +++ b/contracts/generate.go @@ -0,0 +1,5 @@ +package contracts + +//go:generate tools/abigen.sh --abi ./abi/EOConfig.json --pkg eoconfig --type EOConfig --out ./bindings/EOConfig/binding.go +//go:generate tools/abigen.sh --abi ./abi/EORegistryCoordinator.json --pkg contractEORegistryCoordinator --type EORegistryCoordinator --out ./bindings/EORegistryCoordinator/binding.go +//go:generate tools/abigen.sh --abi ./abi/EOStakeRegistry.json --pkg contractEOStakeRegistry --type EOStakeRegistry --out ./bindings/EOStakeRegistry/binding.go diff --git a/contracts/tools/abigen.sh b/contracts/tools/abigen.sh new file mode 100755 index 0000000..a186b8f --- /dev/null +++ b/contracts/tools/abigen.sh @@ -0,0 +1,20 @@ +#!/bin/bash +# +# Generate the contract ABI code using the right ABI generator tool from bin dir +# +# You need to install abigen to use this tool: +# 1) checkout go-ethereum repository +# 2) run "go install ./cmd/abigen" (or "make devtools") +# 3) the abigen tool should be now installed in $GOPATH +# +if [ -z "${GOPATH}" ]; then GOPATH="${HOME}/go"; fi +ABIGEN="${GOPATH}/bin/abigen" + +if [ ! -x "${ABIGEN}" ] +then + echo "ABI generator not found as [${ABIGEN}]." + exit 1 +fi + +"${ABIGEN}" "${@}" +exit $? diff --git a/go.mod b/go.mod index d52846b..92eeeb7 100644 --- a/go.mod +++ b/go.mod @@ -1,53 +1,128 @@ module github.com/eodata/operator-cli -go 1.21 +go 1.24.3 require ( - github.com/Layr-Labs/eigensdk-go v0.1.2 - github.com/consensys/gnark-crypto v0.12.1 - github.com/ethereum/go-ethereum v1.13.15 - github.com/urfave/cli/v2 v2.27.1 + github.com/Layr-Labs/eigensdk-go v1.0.0-rc.1 + github.com/consensys/gnark-crypto v0.18.0 + github.com/ethereum/go-ethereum v1.16.1 + github.com/stretchr/testify v1.10.0 + github.com/urfave/cli/v2 v2.27.7 ) require ( - github.com/Microsoft/go-winio v0.6.1 // indirect - github.com/StackExchange/wmi v1.2.1 // indirect + github.com/DataDog/zstd v1.5.7 // indirect + github.com/Microsoft/go-winio v0.6.2 // indirect + github.com/VictoriaMetrics/fastcache v1.12.5 // indirect + github.com/apapsch/go-jsonmerge/v2 v2.0.0 // indirect + github.com/aws/aws-sdk-go-v2 v1.36.5 // indirect + github.com/aws/aws-sdk-go-v2/config v1.29.17 // indirect + github.com/aws/aws-sdk-go-v2/credentials v1.17.70 // indirect + github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.32 // indirect + github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.36 // indirect + github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.36 // indirect + github.com/aws/aws-sdk-go-v2/internal/ini v1.8.3 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.12.4 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.12.17 // indirect + github.com/aws/aws-sdk-go-v2/service/kms v1.41.2 // indirect + github.com/aws/aws-sdk-go-v2/service/sso v1.25.5 // indirect + github.com/aws/aws-sdk-go-v2/service/ssooidc v1.30.3 // indirect + github.com/aws/aws-sdk-go-v2/service/sts v1.34.0 // indirect + github.com/aws/smithy-go v1.22.4 // 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.2.0 // indirect - github.com/cespare/xxhash/v2 v2.2.0 // indirect - github.com/consensys/bavard v0.1.13 // indirect - github.com/cpuguy83/go-md2man/v2 v2.0.2 // indirect - github.com/crate-crypto/go-kzg-4844 v0.7.0 // indirect - github.com/deckarep/golang-set/v2 v2.1.0 // indirect - github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1 // indirect - github.com/ethereum/c-kzg-4844 v0.4.0 // indirect - github.com/fsnotify/fsnotify v1.6.0 // indirect + github.com/bits-and-blooms/bitset v1.22.0 // indirect + github.com/cenkalti/backoff/v4 v4.3.0 // indirect + github.com/cespare/xxhash/v2 v2.3.0 // indirect + github.com/cockroachdb/errors v1.12.0 // indirect + github.com/cockroachdb/fifo v0.0.0-20240816210425-c5d0cb0b6fc0 // indirect + github.com/cockroachdb/logtags v0.0.0-20241215232642-bb51bb14a506 // indirect + github.com/cockroachdb/pebble v1.1.5 // indirect + github.com/cockroachdb/redact v1.1.6 // indirect + github.com/cockroachdb/tokenbucket v0.0.0-20250429170803-42689b6311bb // indirect + github.com/cpuguy83/go-md2man/v2 v2.0.7 // indirect + github.com/crate-crypto/go-eth-kzg v1.3.0 // indirect + github.com/crate-crypto/go-ipa v0.0.0-20240724233137-53bbb0ceb27a // indirect + github.com/davecgh/go-spew v1.1.1 // indirect + github.com/deckarep/golang-set/v2 v2.8.0 // indirect + github.com/decred/dcrd/dcrec/secp256k1/v4 v4.4.0 // indirect + github.com/emicklei/dot v1.8.0 // indirect + github.com/ethereum/c-kzg-4844/v2 v2.1.1 // indirect + github.com/ethereum/go-verkle v0.2.2 // indirect + github.com/ferranbt/fastssz v0.1.4 // indirect + github.com/fsnotify/fsnotify v1.9.0 // indirect + github.com/gballet/go-libpcsclite v0.0.0-20191108122812-4678299bea08 // indirect + github.com/getsentry/sentry-go v0.34.1 // indirect github.com/go-ole/go-ole v1.3.0 // indirect + github.com/gofrs/flock v0.12.1 // indirect + github.com/gogo/protobuf v1.3.2 // indirect github.com/golang-jwt/jwt v3.2.2+incompatible // indirect + github.com/golang-jwt/jwt/v4 v4.5.2 // indirect + github.com/golang/snappy v1.0.0 // indirect github.com/google/uuid v1.6.0 // indirect - github.com/gorilla/websocket v1.4.2 // indirect - github.com/holiman/uint256 v1.2.4 // indirect - github.com/mmcloughlin/addchain v0.4.0 // indirect - github.com/prometheus/client_golang v1.19.0 // indirect - github.com/prometheus/client_model v0.5.0 // indirect - github.com/prometheus/common v0.48.0 // indirect - github.com/prometheus/procfs v0.12.0 // indirect + github.com/gorilla/websocket v1.5.3 // indirect + github.com/graph-gophers/graphql-go v1.6.0 // indirect + github.com/hashicorp/go-bexpr v0.1.14 // indirect + github.com/holiman/billy v0.0.0-20250707135307-f2f9b9aae7db // indirect + github.com/holiman/bloomfilter/v2 v2.0.3 // indirect + github.com/holiman/uint256 v1.3.2 // indirect + github.com/huin/goupnp v1.3.0 // indirect + github.com/influxdata/influxdb-client-go/v2 v2.14.0 // indirect + github.com/influxdata/influxdb1-client v0.0.0-20220302092344-a9ab5670611c // indirect + github.com/influxdata/line-protocol v0.0.0-20210922203350-b1ad95c89adf // indirect + github.com/jackpal/go-nat-pmp v1.0.2 // indirect + github.com/klauspost/compress v1.18.0 // indirect + github.com/klauspost/cpuid/v2 v2.3.0 // indirect + github.com/kr/pretty v0.3.1 // indirect + github.com/kr/text v0.2.0 // indirect + github.com/lmittmann/tint v1.1.2 // indirect + github.com/mattn/go-colorable v0.1.14 // indirect + github.com/mattn/go-isatty v0.0.20 // indirect + github.com/mattn/go-runewidth v0.0.16 // indirect + github.com/minio/sha256-simd v1.0.1 // indirect + github.com/mitchellh/mapstructure v1.5.0 // indirect + github.com/mitchellh/pointerstructure v1.2.1 // indirect + github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect + github.com/oapi-codegen/runtime v1.1.1 // indirect + github.com/olekukonko/tablewriter v1.0.6 // indirect + github.com/peterh/liner v1.2.2 // indirect + github.com/pion/dtls/v2 v2.2.12 // indirect + github.com/pion/logging v0.2.4 // indirect + github.com/pion/stun/v2 v2.0.0 // indirect + github.com/pion/transport/v2 v2.2.10 // indirect + github.com/pion/transport/v3 v3.0.7 // indirect + github.com/pkg/errors v0.9.1 // indirect + github.com/pmezard/go-difflib v1.0.0 // indirect + github.com/prometheus/client_golang v1.22.0 // indirect + github.com/prometheus/client_model v0.6.2 // indirect + github.com/prometheus/common v0.65.0 // indirect + github.com/prometheus/procfs v0.17.0 // indirect + github.com/rivo/uniseg v0.4.7 // indirect + github.com/rogpeppe/go-internal v1.14.1 // indirect + github.com/rs/cors v1.11.1 // indirect github.com/russross/blackfriday/v2 v2.1.0 // indirect - github.com/shirou/gopsutil v3.21.4-0.20210419000835-c7a38de76ee5+incompatible // indirect - github.com/supranational/blst v0.3.11 // indirect - github.com/tklauser/go-sysconf v0.3.12 // indirect - github.com/tklauser/numcpus v0.6.1 // indirect - github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 // indirect + github.com/shirou/gopsutil v3.21.11+incompatible // indirect + github.com/supranational/blst v0.3.15 // indirect + github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 // indirect + github.com/tklauser/go-sysconf v0.3.15 // indirect + github.com/tklauser/numcpus v0.10.0 // indirect + github.com/wlynxg/anet v0.0.5 // indirect + github.com/xrash/smetrics v0.0.0-20250705151800-55b8f293f342 // indirect + github.com/yusufpapurcu/wmi v1.2.4 // indirect go.uber.org/multierr v1.11.0 // indirect go.uber.org/zap v1.27.0 // indirect - golang.org/x/crypto v0.31.0 // indirect - golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa // indirect - golang.org/x/mod v0.16.0 // indirect - golang.org/x/sync v0.5.0 // indirect - golang.org/x/sys v0.28.0 // indirect - golang.org/x/tools v0.15.0 // indirect - google.golang.org/protobuf v1.32.0 // indirect + golang.org/x/crypto v0.40.0 // indirect + golang.org/x/exp v0.0.0-20250711185948-6ae5c78190dc // indirect + golang.org/x/net v0.42.0 // indirect + golang.org/x/sync v0.16.0 // indirect + golang.org/x/sys v0.34.0 // indirect + golang.org/x/text v0.27.0 // indirect + golang.org/x/time v0.12.0 // indirect + google.golang.org/protobuf v1.36.6 // indirect + gopkg.in/natefinch/lumberjack.v2 v2.2.1 // indirect + gopkg.in/yaml.v2 v2.4.0 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect - rsc.io/tmplfunc v0.0.3 // indirect ) + +// Force tablewriter to v0.0.5 for go-ethereum compatibility +//lint:file-ignore gomoddirectives Ignore linting on go.mod directives +replace github.com/olekukonko/tablewriter v1.0.6 => github.com/olekukonko/tablewriter v0.0.5 diff --git a/go.sum b/go.sum index 28844c4..b966eb5 100644 --- a/go.sum +++ b/go.sum @@ -1,166 +1,354 @@ -github.com/DataDog/zstd v1.4.5 h1:EndNeuB0l9syBZhut0wns3gV1hL8zX8LIu6ZiVHWLIQ= -github.com/DataDog/zstd v1.4.5/go.mod h1:1jcaCB/ufaK+sKp1NBhlGmpz41jOoPQ35bpF36t7BBo= -github.com/Layr-Labs/eigensdk-go v0.1.2 h1:0CbdLMr9IPWFW3RPfPORFWQYgXMAa/K4tA8rncBQ/YY= -github.com/Layr-Labs/eigensdk-go v0.1.2/go.mod h1:J+d9zxN4VyMtchmsPzGASFcCjpnh1eT4aE2ggiqOz/g= -github.com/Microsoft/go-winio v0.6.1 h1:9/kr64B9VUZrLm5YYwbGtUJnMgqWVOdUAXu6Migciow= -github.com/Microsoft/go-winio v0.6.1/go.mod h1:LRdKpFKfdobln8UmuiYcKPot9D2v6svN5+sAH+4kjUM= -github.com/StackExchange/wmi v1.2.1 h1:VIkavFPXSjcnS+O8yTq7NI32k0R5Aj+v39y29VYDOSA= -github.com/StackExchange/wmi v1.2.1/go.mod h1:rcmrprowKIVzvc+NUiLncP2uuArMWLCbu9SBzvHz7e8= -github.com/VictoriaMetrics/fastcache v1.12.1 h1:i0mICQuojGDL3KblA7wUNlY5lOK6a4bwt3uRKnkZU40= -github.com/VictoriaMetrics/fastcache v1.12.1/go.mod h1:tX04vaqcNoQeGLD+ra5pU5sWkuxnzWhEzLwhP9w653o= +dario.cat/mergo v1.0.0 h1:AGCNq9Evsj31mOgNPcLyXc+4PNABt905YmuqPYYpBWk= +dario.cat/mergo v1.0.0/go.mod h1:uNxQE+84aUszobStD9th8a29P2fMDhsBdgRYvZOxGmk= +github.com/Azure/go-ansiterm v0.0.0-20210617225240-d185dfc1b5a1 h1:UQHMgLO+TxOElx5B5HZ4hJQsoJ/PvUvKRhJHDQXO8P8= +github.com/Azure/go-ansiterm v0.0.0-20210617225240-d185dfc1b5a1/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E= +github.com/DataDog/zstd v1.5.7 h1:ybO8RBeh29qrxIhCA9E8gKY6xfONU9T6G6aP9DTKfLE= +github.com/DataDog/zstd v1.5.7/go.mod h1:g4AWEaM3yOg3HYfnJ3YIawPnVdXJh9QME85blwSAmyw= +github.com/Layr-Labs/eigensdk-go v1.0.0-rc.1 h1:pH4RnJEk9NzxwzGIoUCj3cuOYx3rsb5JruGeqiyvdOw= +github.com/Layr-Labs/eigensdk-go v1.0.0-rc.1/go.mod h1:PIBT6xEoHR0mSADTfdQ+pu4LySlt0sr7UML0Wa6DKrM= +github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY= +github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU= +github.com/RaveNoX/go-jsoncommentstrip v1.0.0/go.mod h1:78ihd09MekBnJnxpICcwzCMzGrKSKYe4AqU6PDYYpjk= +github.com/VictoriaMetrics/fastcache v1.12.5 h1:966OX9JjqYmDAFdp3wEXLwzukiHIm+GVlZHv6B8KW3k= +github.com/VictoriaMetrics/fastcache v1.12.5/go.mod h1:K+JGPBn0sueFlLjZ8rcVM0cKkWKNElKyQXmw57QOoYI= +github.com/allegro/bigcache v1.2.1-0.20190218064605-e24eb225f156 h1:eMwmnE/GDgah4HI848JfFxHt+iPb26b4zyfspmqY0/8= +github.com/allegro/bigcache v1.2.1-0.20190218064605-e24eb225f156/go.mod h1:Cb/ax3seSYIx7SuZdm2G2xzfwmv3TPSk2ucNfQESPXM= +github.com/apapsch/go-jsonmerge/v2 v2.0.0 h1:axGnT1gRIfimI7gJifB699GoE/oq+F2MU7Dml6nw9rQ= +github.com/apapsch/go-jsonmerge/v2 v2.0.0/go.mod h1:lvDnEdqiQrp0O42VQGgmlKpxL1AP2+08jFMw88y4klk= +github.com/aws/aws-sdk-go-v2 v1.36.5 h1:0OF9RiEMEdDdZEMqF9MRjevyxAQcf6gY+E7vwBILFj0= +github.com/aws/aws-sdk-go-v2 v1.36.5/go.mod h1:EYrzvCCN9CMUTa5+6lf6MM4tq3Zjp8UhSGR/cBsjai0= +github.com/aws/aws-sdk-go-v2/config v1.29.17 h1:jSuiQ5jEe4SAMH6lLRMY9OVC+TqJLP5655pBGjmnjr0= +github.com/aws/aws-sdk-go-v2/config v1.29.17/go.mod h1:9P4wwACpbeXs9Pm9w1QTh6BwWwJjwYvJ1iCt5QbCXh8= +github.com/aws/aws-sdk-go-v2/credentials v1.17.70 h1:ONnH5CM16RTXRkS8Z1qg7/s2eDOhHhaXVd72mmyv4/0= +github.com/aws/aws-sdk-go-v2/credentials v1.17.70/go.mod h1:M+lWhhmomVGgtuPOhO85u4pEa3SmssPTdcYpP/5J/xc= +github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.32 h1:KAXP9JSHO1vKGCr5f4O6WmlVKLFFXgWYAGoJosorxzU= +github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.32/go.mod h1:h4Sg6FQdexC1yYG9RDnOvLbW1a/P986++/Y/a+GyEM8= +github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.36 h1:SsytQyTMHMDPspp+spo7XwXTP44aJZZAC7fBV2C5+5s= +github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.36/go.mod h1:Q1lnJArKRXkenyog6+Y+zr7WDpk4e6XlR6gs20bbeNo= +github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.36 h1:i2vNHQiXUvKhs3quBR6aqlgJaiaexz/aNvdCktW/kAM= +github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.36/go.mod h1:UdyGa7Q91id/sdyHPwth+043HhmP6yP9MBHgbZM0xo8= +github.com/aws/aws-sdk-go-v2/internal/ini v1.8.3 h1:bIqFDwgGXXN1Kpp99pDOdKMTTb5d2KyU5X/BZxjOkRo= +github.com/aws/aws-sdk-go-v2/internal/ini v1.8.3/go.mod h1:H5O/EsxDWyU+LP/V8i5sm8cxoZgc2fdNR9bxlOFrQTo= +github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.12.4 h1:CXV68E2dNqhuynZJPB80bhPQwAKqBWVer887figW6Jc= +github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.12.4/go.mod h1:/xFi9KtvBXP97ppCz1TAEvU1Uf66qvid89rbem3wCzQ= +github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.12.17 h1:t0E6FzREdtCsiLIoLCWsYliNsRBgyGD/MCK571qk4MI= +github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.12.17/go.mod h1:ygpklyoaypuyDvOM5ujWGrYWpAK3h7ugnmKCU/76Ys4= +github.com/aws/aws-sdk-go-v2/service/kms v1.41.2 h1:zJeUxFP7+XP52u23vrp4zMcVhShTWbNO8dHV6xCSvFo= +github.com/aws/aws-sdk-go-v2/service/kms v1.41.2/go.mod h1:Pqd9k4TuespkireN206cK2QBsaBTL6X+VPAez5Qcijk= +github.com/aws/aws-sdk-go-v2/service/sso v1.25.5 h1:AIRJ3lfb2w/1/8wOOSqYb9fUKGwQbtysJ2H1MofRUPg= +github.com/aws/aws-sdk-go-v2/service/sso v1.25.5/go.mod h1:b7SiVprpU+iGazDUqvRSLf5XmCdn+JtT1on7uNL6Ipc= +github.com/aws/aws-sdk-go-v2/service/ssooidc v1.30.3 h1:BpOxT3yhLwSJ77qIY3DoHAQjZsc4HEGfMCE4NGy3uFg= +github.com/aws/aws-sdk-go-v2/service/ssooidc v1.30.3/go.mod h1:vq/GQR1gOFLquZMSrxUK/cpvKCNVYibNyJ1m7JrU88E= +github.com/aws/aws-sdk-go-v2/service/sts v1.34.0 h1:NFOJ/NXEGV4Rq//71Hs1jC/NvPs1ezajK+yQmkwnPV0= +github.com/aws/aws-sdk-go-v2/service/sts v1.34.0/go.mod h1:7ph2tGpfQvwzgistp2+zga9f+bCjlQJPkPUmMgDSD7w= +github.com/aws/smithy-go v1.22.4 h1:uqXzVZNuNexwc/xrh6Tb56u89WDlJY6HS+KC0S4QSjw= +github.com/aws/smithy-go v1.22.4/go.mod h1:t1ufH5HMublsJYulve2RKmHDC15xu1f26kHCp/HgceI= github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw= -github.com/bits-and-blooms/bitset v1.10.0 h1:ePXTeiPEazB5+opbv5fr8umg2R/1NlzgDsyepwsSr88= -github.com/bits-and-blooms/bitset v1.10.0/go.mod h1:7hO7Gc7Pp1vODcmWvKMRA9BNmbv6a/7QIWpPxHddWR8= -github.com/btcsuite/btcd/btcec/v2 v2.2.0 h1:fzn1qaOt32TuLjFlkzYSsBC35Q3KUjT1SwPxiMSCF5k= -github.com/btcsuite/btcd/btcec/v2 v2.2.0/go.mod h1:U7MHm051Al6XmscBQ0BoNydpOTsFAn707034b5nY8zU= -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/bits-and-blooms/bitset v1.22.0 h1:Tquv9S8+SGaS3EhyA+up3FXzmkhxPGjQQCkcs2uw7w4= +github.com/bits-and-blooms/bitset v1.22.0/go.mod h1:7hO7Gc7Pp1vODcmWvKMRA9BNmbv6a/7QIWpPxHddWR8= +github.com/bmatcuk/doublestar v1.1.1/go.mod h1:UD6OnuiIn0yFxxA2le/rnRU1G4RaI4UvFv1sNto9p6w= +github.com/cenkalti/backoff/v4 v4.3.0 h1:MyRJ/UdXutAwSAT+s3wNd7MfTIcy71VQueUuFK343L8= +github.com/cenkalti/backoff/v4 v4.3.0/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE= github.com/cespare/cp v0.1.0 h1:SE+dxFebS7Iik5LK0tsi1k9ZCxEaFX4AjQmoyA+1dJk= github.com/cespare/cp v0.1.0/go.mod h1:SOGHArjBr4JWaSDEVpWpo/hNg6RoKrls6Oh40hiwW+s= -github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44= -github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= -github.com/cockroachdb/errors v1.8.1 h1:A5+txlVZfOqFBDa4mGz2bUWSp0aHElvHX2bKkdbQu+Y= -github.com/cockroachdb/errors v1.8.1/go.mod h1:qGwQn6JmZ+oMjuLwjWzUNqblqk0xl4CVV3SQbGwK7Ac= -github.com/cockroachdb/logtags v0.0.0-20190617123548-eb05cc24525f h1:o/kfcElHqOiXqcou5a3rIlMc7oJbMQkeLk0VQJ7zgqY= -github.com/cockroachdb/logtags v0.0.0-20190617123548-eb05cc24525f/go.mod h1:i/u985jwjWRlyHXQbwatDASoW0RMlZ/3i9yJHE2xLkI= -github.com/cockroachdb/pebble v0.0.0-20230928194634-aa077af62593 h1:aPEJyR4rPBvDmeyi+l/FS/VtA00IWvjeFvjen1m1l1A= -github.com/cockroachdb/pebble v0.0.0-20230928194634-aa077af62593/go.mod h1:6hk1eMY/u5t+Cf18q5lFMUA1Rc+Sm5I6Ra1QuPyxXCo= -github.com/cockroachdb/redact v1.0.8 h1:8QG/764wK+vmEYoOlfobpe12EQcS81ukx/a4hdVMxNw= -github.com/cockroachdb/redact v1.0.8/go.mod h1:BVNblN9mBWFyMyqK1k3AAiSxhvhfK2oOZZ2lK+dpvRg= -github.com/cockroachdb/sentry-go v0.6.1-cockroachdb.2 h1:IKgmqgMQlVJIZj19CdocBeSfSaiCbEBZGKODaixqtHM= -github.com/cockroachdb/sentry-go v0.6.1-cockroachdb.2/go.mod h1:8BT+cPK6xvFOcRlk0R8eg+OTkcqI6baNH4xAkpiYVvQ= -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/cpuguy83/go-md2man/v2 v2.0.2 h1:p1EgwI/C7NhT0JmVkwCD2ZBK8j4aeHQX2pMHHBfMQ6w= -github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o= -github.com/crate-crypto/go-ipa v0.0.0-20231025140028-3c0104f4b233 h1:d28BXYi+wUpz1KBmiF9bWrjEMacUEREV6MBi2ODnrfQ= -github.com/crate-crypto/go-ipa v0.0.0-20231025140028-3c0104f4b233/go.mod h1:geZJZH3SzKCqnz5VT0q/DyIG/tvu/dZk+VIfXicupJs= -github.com/crate-crypto/go-kzg-4844 v0.7.0 h1:C0vgZRk4q4EZ/JgPfzuSoxdCq3C3mOZMBShovmncxvA= -github.com/crate-crypto/go-kzg-4844 v0.7.0/go.mod h1:1kMhvPgI0Ky3yIa+9lFySEBUBXkYxeOi8ZF1sYioxhc= +github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= +github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +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.12.0 h1:d7oCs6vuIMUQRVbi6jWWWEJZahLCfJpnJSVobd1/sUo= +github.com/cockroachdb/errors v1.12.0/go.mod h1:SvzfYNNBshAVbZ8wzNc/UPK3w1vf0dKDUP41ucAIf7g= +github.com/cockroachdb/fifo v0.0.0-20240816210425-c5d0cb0b6fc0 h1:pU88SPhIFid6/k0egdR5V6eALQYq2qbSmukrkgIh/0A= +github.com/cockroachdb/fifo v0.0.0-20240816210425-c5d0cb0b6fc0/go.mod h1:9/y3cnZ5GKakj/H4y9r9GTjCvAFta7KLgSHPJJYc52M= +github.com/cockroachdb/logtags v0.0.0-20241215232642-bb51bb14a506 h1:ASDL+UJcILMqgNeV5jiqR4j+sTuvQNHdf2chuKj1M5k= +github.com/cockroachdb/logtags v0.0.0-20241215232642-bb51bb14a506/go.mod h1:Mw7HqKr2kdtu6aYGn3tPmAftiP3QPX63LdK/zcariIo= +github.com/cockroachdb/pebble v1.1.5 h1:5AAWCBWbat0uE0blr8qzufZP5tBjkRyy/jWe1QWLnvw= +github.com/cockroachdb/pebble v1.1.5/go.mod h1:17wO9el1YEigxkP/YtV8NtCivQDgoCyBg5c4VR/eOWo= +github.com/cockroachdb/redact v1.1.6 h1:zXJBwDZ84xJNlHl1rMyCojqyIxv+7YUpQiJLQ7n4314= +github.com/cockroachdb/redact v1.1.6/go.mod h1:BVNblN9mBWFyMyqK1k3AAiSxhvhfK2oOZZ2lK+dpvRg= +github.com/cockroachdb/tokenbucket v0.0.0-20250429170803-42689b6311bb h1:3bCgBvB8PbJVMX1ouCcSIxvsqKPYM7gs72o0zC76n9g= +github.com/cockroachdb/tokenbucket v0.0.0-20250429170803-42689b6311bb/go.mod h1:7nc4anLGjupUW/PeY5qiNYsdNXj7zopG+eqsS7To5IQ= +github.com/consensys/gnark-crypto v0.18.0 h1:vIye/FqI50VeAr0B3dx+YjeIvmc3LWz4yEfbWBpTUf0= +github.com/consensys/gnark-crypto v0.18.0/go.mod h1:L3mXGFTe1ZN+RSJ+CLjUt9x7PNdx8ubaYfDROyp2Z8c= +github.com/containerd/containerd v1.7.18 h1:jqjZTQNfXGoEaZdW1WwPU0RqSn1Bm2Ay/KJPUuO8nao= +github.com/containerd/containerd v1.7.18/go.mod h1:IYEk9/IO6wAPUz2bCMVUbsfXjzw5UNP5fLz4PsUygQ4= +github.com/containerd/log v0.1.0 h1:TCJt7ioM2cr/tfR8GPbGf9/VRAX8D2B4PjzCpfX540I= +github.com/containerd/log v0.1.0/go.mod h1:VRRf09a7mHDIRezVKTRCrOq78v577GXq3bSa3EhrzVo= +github.com/containerd/platforms v0.2.1 h1:zvwtM3rz2YHPQsF2CHYM8+KtB5dvhISiXh5ZpSBQv6A= +github.com/containerd/platforms v0.2.1/go.mod h1:XHCb+2/hzowdiut9rkudds9bE5yJ7npe7dG/wG+uFPw= +github.com/cpuguy83/dockercfg v0.3.2 h1:DlJTyZGBDlXqUZ2Dk2Q3xHs/FtnooJJVaad2S9GKorA= +github.com/cpuguy83/dockercfg v0.3.2/go.mod h1:sugsbF4//dDlL/i+S+rtpIWp+5h0BHJHfjj5/jFyUJc= +github.com/cpuguy83/go-md2man/v2 v2.0.7 h1:zbFlGlXEAKlwXpmvle3d8Oe3YnkKIK4xSRTd3sHPnBo= +github.com/cpuguy83/go-md2man/v2 v2.0.7/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g= +github.com/crate-crypto/go-eth-kzg v1.3.0 h1:05GrhASN9kDAidaFJOda6A4BEvgvuXbazXg/0E3OOdI= +github.com/crate-crypto/go-eth-kzg v1.3.0/go.mod h1:J9/u5sWfznSObptgfa92Jq8rTswn6ahQWEuiLHOjCUI= +github.com/crate-crypto/go-ipa v0.0.0-20240724233137-53bbb0ceb27a h1:W8mUrRp6NOVl3J+MYp5kPMoUZPp7aOYHtaua31lwRHg= +github.com/crate-crypto/go-ipa v0.0.0-20240724233137-53bbb0ceb27a/go.mod h1:sTwzHBvIzm2RfVCGNEBZgRyjwK40bVoun3ZnGOCafNM= +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 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/deckarep/golang-set/v2 v2.1.0 h1:g47V4Or+DUdzbs8FxCCmgb6VYd+ptPAngjM6dtGktsI= -github.com/deckarep/golang-set/v2 v2.1.0/go.mod h1:VAky9rY/yGXJOLEDv3OMci+7wtDpOF4IN+y82NBOac4= -github.com/decred/dcrd/crypto/blake256 v1.0.0 h1:/8DMNYp9SGi5f0w7uCm6d6M4OU2rGFK09Y2A4Xv7EE0= -github.com/decred/dcrd/crypto/blake256 v1.0.0/go.mod h1:sQl2p6Y26YV+ZOcSTP6thNdn47hh8kt6rqSlvmrXFAc= -github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1 h1:YLtO71vCjJRCBcrPMtQ9nqBsqpA1m5sE92cU+pd5Mcc= -github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1/go.mod h1:hyedUtir6IdtD/7lIxGeCxkaw7y45JueMRL4DIyJDKs= -github.com/ethereum/c-kzg-4844 v0.4.0 h1:3MS1s4JtA868KpJxroZoepdV0ZKBp3u/O5HcZ7R3nlY= -github.com/ethereum/c-kzg-4844 v0.4.0/go.mod h1:VewdlzQmpT5QSrVhbBuGoCdFJkpaJlO1aQputP83wc0= -github.com/ethereum/go-ethereum v1.13.15 h1:U7sSGYGo4SPjP6iNIifNoyIAiNjrmQkz6EwQG+/EZWo= -github.com/ethereum/go-ethereum v1.13.15/go.mod h1:TN8ZiHrdJwSe8Cb6x+p0hs5CxhJZPbqB7hHkaUXcmIU= -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/fsnotify/fsnotify v1.6.0 h1:n+5WquG0fcWoWp6xPWfHdbskMCQaFnG6PfBrh1Ky4HY= -github.com/fsnotify/fsnotify v1.6.0/go.mod h1:sl3t1tCWJFWoRz9R8WJCbQihKKwmorjAbSClcnxKAGw= -github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff h1:tY80oXqGNY4FhTFhk+o9oFHGINQ/+vhlm8HFzi6znCI= -github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff/go.mod h1:x7DCsMOv1taUwEWCzT4cmDeAkigA5/QCwUodaVOe8Ww= -github.com/gballet/go-verkle v0.1.1-0.20231031103413-a67434b50f46 h1:BAIP2GihuqhwdILrV+7GJel5lyPV3u1+PgzrWLc0TkE= -github.com/gballet/go-verkle v0.1.1-0.20231031103413-a67434b50f46/go.mod h1:QNpY22eby74jVhqH4WhDLDwxc/vqsern6pW+u2kbkpc= -github.com/go-ole/go-ole v1.2.5/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0= +github.com/deckarep/golang-set/v2 v2.8.0 h1:swm0rlPCmdWn9mESxKOjWk8hXSqoxOp+ZlfuyaAdFlQ= +github.com/deckarep/golang-set/v2 v2.8.0/go.mod h1:VAky9rY/yGXJOLEDv3OMci+7wtDpOF4IN+y82NBOac4= +github.com/decred/dcrd/crypto/blake256 v1.1.0 h1:zPMNGQCm0g4QTY27fOCorQW7EryeQ/U0x++OzVrdms8= +github.com/decred/dcrd/crypto/blake256 v1.1.0/go.mod h1:2OfgNZ5wDpcsFmHmCK5gZTPcCXqlm2ArzUIkw9czNJo= +github.com/decred/dcrd/dcrec/secp256k1/v4 v4.4.0 h1:NMZiJj8QnKe1LgsbDayM4UoHwbvwDRwnI3hwNaAHRnc= +github.com/decred/dcrd/dcrec/secp256k1/v4 v4.4.0/go.mod h1:ZXNYxsqcloTdSy/rNShjYzMhyjf0LaoftYK0p+A3h40= +github.com/distribution/reference v0.6.0 h1:0IXCQ5g4/QMHHkarYzh5l+u8T3t73zM5QvfrDyIgxBk= +github.com/distribution/reference v0.6.0/go.mod h1:BbU0aIcezP1/5jX/8MP0YiH4SdvB5Y4f/wlDRiLyi3E= +github.com/docker/docker v27.1.1+incompatible h1:hO/M4MtV36kzKldqnA37IWhebRA+LnqqcqDja6kVaKY= +github.com/docker/docker v27.1.1+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk= +github.com/docker/go-connections v0.5.0 h1:USnMq7hx7gwdVZq1L49hLXaFtUdTADjXGp+uj1Br63c= +github.com/docker/go-connections v0.5.0/go.mod h1:ov60Kzw0kKElRwhNs9UlUHAE/F9Fe6GLaXnqyDdmEXc= +github.com/docker/go-units v0.5.0 h1:69rxXcBk27SvSaaxTtLh/8llcHD8vYHT7WSdRZ/jvr4= +github.com/docker/go-units v0.5.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk= +github.com/emicklei/dot v1.8.0 h1:HnD60yAKFAevNeT+TPYr9pb8VB9bqdeSo0nzwIW6IOI= +github.com/emicklei/dot v1.8.0/go.mod h1:DeV7GvQtIw4h2u73RKBkkFdvVAz0D9fzeJrgPW6gy/s= +github.com/ethereum/c-kzg-4844/v2 v2.1.1 h1:KhzBVjmURsfr1+S3k/VE35T02+AW2qU9t9gr4R6YpSo= +github.com/ethereum/c-kzg-4844/v2 v2.1.1/go.mod h1:TC48kOKjJKPbN7C++qIgt0TJzZ70QznYR7Ob+WXl57E= +github.com/ethereum/go-ethereum v1.16.1 h1:7684NfKCb1+IChudzdKyZJ12l1Tq4ybPZOITiCDXqCk= +github.com/ethereum/go-ethereum v1.16.1/go.mod h1:ngYIvmMAYdo4sGW9cGzLvSsPGhDOOzL0jK5S5iXpj0g= +github.com/ethereum/go-verkle v0.2.2 h1:I2W0WjnrFUIzzVPwm8ykY+7pL2d4VhlsePn4j7cnFk8= +github.com/ethereum/go-verkle v0.2.2/go.mod h1:M3b90YRnzqKyyzBEWJGqj8Qff4IDeXnzFw0P9bFw3uk= +github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg= +github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U= +github.com/ferranbt/fastssz v0.1.4 h1:OCDB+dYDEQDvAgtAGnTSidK1Pe2tW3nFV40XyMkTeDY= +github.com/ferranbt/fastssz v0.1.4/go.mod h1:Ea3+oeoRGGLGm5shYAeDgu6PGUlcvQhE2fILyD9+tGg= +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.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k= +github.com/fsnotify/fsnotify v1.9.0/go.mod h1:8jBTzvmWwFyi3Pb8djgCCO5IBqzKJ/Jwo8TRcHyHii0= +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.34.1 h1:HSjc1C/OsnZttohEPrrqKH42Iud0HuLCXpv8cU1pWcw= +github.com/getsentry/sentry-go v0.34.1/go.mod h1:C55omcY9ChRQIUcVcGcs+Zdy4ZpQGvNJ7JYHIoSWOtE= +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-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= +github.com/go-logr/logr v1.2.3/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= +github.com/go-logr/logr v1.4.1 h1:pKouT5E8xu9zeFC39JXRDukb6JFQPXM5p5I91188VAQ= +github.com/go-logr/logr v1.4.1/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= +github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= +github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= +github.com/go-ole/go-ole v1.2.6/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/gofrs/flock v0.8.1 h1:+gYjHKf32LDeiEEFhQaotPbLuUXjY5ZqxKgXy7n59aw= -github.com/gofrs/flock v0.8.1/go.mod h1:F1TvTiK9OcQqauNUHlbJvyl9Qa1QvF/gOUDKA14jxHU= +github.com/gofrs/flock v0.12.1 h1:MTLVXXHf8ekldpJk3AKicLij9MdwOWkZ+a/jHHZby9E= +github.com/gofrs/flock v0.12.1/go.mod h1:9zxTsyu5xtJ9DK+1tFZyibEV7y3uwDxPPfbxeeHCoD0= 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 v3.2.2+incompatible h1:IfV12K8xAKAnZqdXVzCZ+TOjboZ2keLg81eXfW3O+oY= github.com/golang-jwt/jwt v3.2.2+incompatible/go.mod h1:8pz2t5EyA70fFQQSrl6XZXzqecmYZeUEB8OUGHkxJ+I= -github.com/golang-jwt/jwt/v4 v4.5.0 h1:7cYmW1XlMY7h7ii7UhUyChSgS5wUJEnm9uZVTGqOWzg= -github.com/golang-jwt/jwt/v4 v4.5.0/go.mod h1:m21LjoU+eqJr34lmDMbreY2eSTRJ1cv77w39/MY0Ch0= -github.com/golang/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/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= -github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/golang-jwt/jwt/v4 v4.5.2 h1:YtQM7lnr8iZ+j5q71MGKkNw9Mn7AjHM68uc9g5fXeUI= +github.com/golang-jwt/jwt/v4 v4.5.2/go.mod h1:m21LjoU+eqJr34lmDMbreY2eSTRJ1cv77w39/MY0Ch0= +github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +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.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI= +github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= +github.com/golang/snappy v1.0.0 h1:Oy607GVXHs7RtbggtPBnr2RmDArIsAefDwvrdWvRhGs= +github.com/golang/snappy v1.0.0/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= +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.5.7/go.mod h1:n+brtR0CgQNWTVd5ZUFpTBC8YFBDLK/h/bpaJ8/DtOE= +github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= +github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= 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/subcommands v1.2.0/go.mod h1:ZjhPrFU+Olkh9WazFPsl27BQ4UPiG37m3yTrtFlrHVk= 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/gorilla/websocket v1.4.2 h1:+/TMaTYc4QFitKJxsQ7Yye35DkWvkdLcvGKqM+x0Ufc= -github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= -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/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/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg= +github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= +github.com/graph-gophers/graphql-go v1.6.0 h1:tHuViEiKFvs9TSjiisqeBQAxld1mscgF0D/czoHVV30= +github.com/graph-gophers/graphql-go v1.6.0/go.mod h1:mVu5xmLns4x/D4XH7R6bepK2bMF4I4J1BBTum2VDbWU= +github.com/hashicorp/go-bexpr v0.1.14 h1:uKDeyuOhWhT1r5CiMTjdVY4Aoxdxs6EtwgTGnlosyp4= +github.com/hashicorp/go-bexpr v0.1.14/go.mod h1:gN7hRKB3s7yT+YvTdnhZVLTENejvhlkZ8UE4YVBS+Q8= +github.com/holiman/billy v0.0.0-20250707135307-f2f9b9aae7db h1:IZUYC/xb3giYwBLMnr8d0TGTzPKFGNTCGgGLoyeX330= +github.com/holiman/billy v0.0.0-20250707135307-f2f9b9aae7db/go.mod h1:xTEYN9KCHxuYHs+NmrmzFcnvHMzLLNiGFafCb1n3Mfg= 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/holiman/uint256 v1.3.2 h1:a9EgMPSC1AAaj1SZL5zIQD3WbwTuHrMGOerLjGmM/TA= +github.com/holiman/uint256 v1.3.2/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/influxdata/influxdb-client-go/v2 v2.14.0 h1:AjbBfJuq+QoaXNcrova8smSjwJdUHnwvfjMF71M1iI4= +github.com/influxdata/influxdb-client-go/v2 v2.14.0/go.mod h1:Ahpm3QXKMJslpXl3IftVLVezreAUtBOTZssDrjZEFHI= +github.com/influxdata/influxdb1-client v0.0.0-20220302092344-a9ab5670611c h1:qSHzRbhzK8RdXOsAdfDgO49TtqC1oZ+acxPrkfTxcCs= +github.com/influxdata/influxdb1-client v0.0.0-20220302092344-a9ab5670611c/go.mod h1:qj24IKcXYK6Iy9ceXlo3Tc+vtHo9lIhSX5JddghvEPo= +github.com/influxdata/line-protocol v0.0.0-20210922203350-b1ad95c89adf h1:7JTmneyiNEwVBOHSjoMxiWAqB992atOeepeFYegn5RU= +github.com/influxdata/line-protocol v0.0.0-20210922203350-b1ad95c89adf/go.mod h1:xaLFMmpvUxqXtVkUJfg9QmT88cDaCJ3ZKgdZ78oO8Qo= 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/klauspost/compress v1.16.0 h1:iULayQNOReoYUe+1qtKOqw9CwJv3aNQu8ivo7lw1HU4= -github.com/klauspost/compress v1.16.0/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE= +github.com/juju/gnuflag v0.0.0-20171113085948-2ce1bb71843d/go.mod h1:2PavIy+JPciBPrBUjwbNvtwB6RQlve+hkpll6QSNmOE= +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.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo= +github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ= +github.com/klauspost/cpuid/v2 v2.3.0 h1:S4CRMLnYUhGeDFDqkGriYKdfoFlDnMtqTiI/sFzhA9Y= +github.com/klauspost/cpuid/v2 v2.3.0/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0= github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= 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/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.17 h1:BTarxUcIeDqL27Mc+vyvdWYSL28zpIhv3RoTdsLMPng= -github.com/mattn/go-isatty v0.0.17/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= -github.com/mattn/go-runewidth v0.0.13 h1:lTGmDsbAYt5DmK6OnoV7EuIF1wEIFAcxld6ypU4OSgU= -github.com/mattn/go-runewidth v0.0.13/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w= -github.com/mitchellh/mapstructure v1.4.1 h1:CpVNEelQCZBooIPDn+AR3NpivK/TIKU8bDxdASFVQag= +github.com/leanovate/gopter v0.2.11 h1:vRjThO1EKPb/1NsDXuDrzldR28RLkBflWYcU9CvzWu4= +github.com/leanovate/gopter v0.2.11/go.mod h1:aK3tzZP/C+p1m3SPRE4SYZFGP7jjkuSI4f7Xvpt0S9c= +github.com/lmittmann/tint v1.1.2 h1:2CQzrL6rslrsyjqLDwD11bZ5OpLBPU+g3G/r5LSfS8w= +github.com/lmittmann/tint v1.1.2/go.mod h1:HIS3gSy7qNwGCj+5oRjAutErFBl4BzdQP6cJZ0NfMwE= +github.com/lufia/plan9stats v0.0.0-20211012122336-39d0f177ccd0 h1:6E+4a0GO5zZEnZ81pIr0yLvtUWk2if982qA3F3QD6H4= +github.com/lufia/plan9stats v0.0.0-20211012122336-39d0f177ccd0/go.mod h1:zJYVVT2jmtg6P3p1VtQj7WsuWi/y4VnjVBn7F8KPB3I= +github.com/magiconair/properties v1.8.7 h1:IeQXZAiQcpL9mgcAe1Nu6cX9LLw6ExEHKjN0VQdvPDY= +github.com/magiconair/properties v1.8.7/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0= +github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE= +github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8= +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.3/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU= +github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI= +github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc= +github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w= +github.com/minio/sha256-simd v1.0.1 h1:6kaan5IFmwTNynnKKpDHe6FWHohJOHhCPchzK49dzMM= +github.com/minio/sha256-simd v1.0.1/go.mod h1:Pz6AKMiUdngCLpeTL/RJY1M9rUuPMYujV5xJjtbRSN8= github.com/mitchellh/mapstructure v1.4.1/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/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.1 h1:ZhBBeX8tSlRpu/FFhXH4RC4OJzFlqsQhoHZAz4x7TIw= +github.com/mitchellh/pointerstructure v1.2.1/go.mod h1:BRAsLI5zgXmw97Lf6s25bs8ohIXc3tViBH44KcwB2g4= +github.com/moby/docker-image-spec v1.3.1 h1:jMKff3w6PgbfSa69GfNg+zN/XLhfXJGnEx3Nl2EsFP0= +github.com/moby/docker-image-spec v1.3.1/go.mod h1:eKmb5VW8vQEh/BAr2yvVNvuiJuY6UIocYsFu/DxxRpo= +github.com/moby/patternmatcher v0.6.0 h1:GmP9lR19aU5GqSSFko+5pRqHi+Ohk1O69aFiKkVGiPk= +github.com/moby/patternmatcher v0.6.0/go.mod h1:hDPoyOpDY7OrrMDLaYoY3hf52gNCR/YOUYxkhApJIxc= +github.com/moby/sys/sequential v0.5.0 h1:OPvI35Lzn9K04PBbCLW0g4LcFAJgHsvXsRyewg5lXtc= +github.com/moby/sys/sequential v0.5.0/go.mod h1:tH2cOOs5V9MlPiXcQzRC+eEyab644PWKGRYaaV5ZZlo= +github.com/moby/sys/user v0.1.0 h1:WmZ93f5Ux6het5iituh9x2zAG7NFY9Aqi49jjE1PaQg= +github.com/moby/sys/user v0.1.0/go.mod h1:fKJhFOnsCN6xZ5gSfbM6zaHGgDJMrqt9/reuj4T7MmU= +github.com/moby/term v0.5.0 h1:xt8Q1nalod/v7BqbG21f8mQPqH+xAaC9C3N3wfWbVP0= +github.com/moby/term v0.5.0/go.mod h1:8FzsFHVUBGZdbDsJw/ot+X+d5HLUbvklYLJ9uGfcI3Y= +github.com/morikuni/aec v1.0.0 h1:nP9CBfwrvYnBRgY6qfDQkygYDmYwOilePFkwzv4dU8A= +github.com/morikuni/aec v1.0.0/go.mod h1:BbKIizmSmc5MMPqRYbxO4ZU0S0+P200+tUnFx7PXmsc= +github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA= +github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= +github.com/nxadm/tail v1.4.4 h1:DQuhQpB1tVlglWS2hLQ5OV6B5r8aGxSrPc5Qo6uTN78= +github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A= +github.com/oapi-codegen/runtime v1.1.1 h1:EXLHh0DXIJnWhdRPN2w4MXAzFyE4CskzhNLUmtpMYro= +github.com/oapi-codegen/runtime v1.1.1/go.mod h1:SK9X900oXmPWilYR5/WKPzt3Kqxn/uS/+lbpREv+eCg= 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.14.0 h1:2mOpI4JVVPBN+WQRa0WKH2eXR+Ey+uK4n7Zj0aYpIQA= +github.com/onsi/ginkgo v1.14.0/go.mod h1:iSB4RoI2tjJc9BBv4NKIKWKya62Rps+oPG/Lv9klQyY= +github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY= +github.com/onsi/gomega v1.10.1 h1:o0+MgICZLuZ7xjH7Vx6zS/zcu93/BEp1VwkIW1mEXCE= +github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo= +github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8Oi/yOhh5U= +github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM= +github.com/opencontainers/image-spec v1.1.0 h1:8SG7/vwALn54lVB/0yZ/MMwhFrPYtpEHQb2IpWsCzug= +github.com/opencontainers/image-spec v1.1.0/go.mod h1:W4s4sFTMaBeK1BQLXbG4AdM2szdn85PY75RI83NrTrM= +github.com/opentracing/opentracing-go v1.2.0/go.mod h1:GxEUsuufX4nBwe+T+Wl9TAgYrxe9dPLANfrWvHYVTgc= +github.com/peterh/liner v1.2.2 h1:aJ4AOodmL+JxOZZEL2u9iJf8omNRpqHc/EbrK+3mAXw= +github.com/peterh/liner v1.2.2/go.mod h1:xFwJyiKIXJZUKItq5dGHZSTBRAuG/CpeNpWLyiNRNwI= +github.com/pingcap/errors v0.11.4 h1:lFuQV/oaUMGcD2tqt+01ROSmJs75VG1ToEOkZIZ4nE4= +github.com/pingcap/errors v0.11.4/go.mod h1:Oi8TUi2kEtXXLMJk9l1cGmz20kV3TaQ0usTwv5KuLY8= +github.com/pion/dtls/v2 v2.2.7/go.mod h1:8WiMkebSHFD0T+dIU+UeBaoV7kDhOW5oDCzZ7WZ/F9s= +github.com/pion/dtls/v2 v2.2.12 h1:KP7H5/c1EiVAAKUmXyCzPiQe5+bCJrpOeKg/L05dunk= +github.com/pion/dtls/v2 v2.2.12/go.mod h1:d9SYc9fch0CqK90mRk1dC7AkzzpwJj6u2GU3u+9pqFE= +github.com/pion/logging v0.2.2/go.mod h1:k0/tDVsRCX2Mb2ZEmTqNa7CWsQPc+YYCB7Q+5pahoms= +github.com/pion/logging v0.2.4 h1:tTew+7cmQ+Mc1pTBLKH2puKsOvhm32dROumOZ655zB8= +github.com/pion/logging v0.2.4/go.mod h1:DffhXTKYdNZU+KtJ5pyQDjvOAh/GsNSyv1lbkFbe3so= +github.com/pion/stun/v2 v2.0.0 h1:A5+wXKLAypxQri59+tmQKVs7+l6mMM+3d+eER9ifRU0= +github.com/pion/stun/v2 v2.0.0/go.mod h1:22qRSh08fSEttYUmJZGlriq9+03jtVmXNODgLccj8GQ= +github.com/pion/transport/v2 v2.2.1/go.mod h1:cXXWavvCnFF6McHTft3DWS9iic2Mftcz1Aq29pGcU5g= +github.com/pion/transport/v2 v2.2.4/go.mod h1:q2U/tf9FEfnSBGSW6w5Qp5PFWRLRj3NjLhCCgpRK4p0= +github.com/pion/transport/v2 v2.2.10 h1:ucLBLE8nuxiHfvkFKnkDQRYWYfp8ejf4YBOPfaQpw6Q= +github.com/pion/transport/v2 v2.2.10/go.mod h1:sq1kSLWs+cHW9E+2fJP95QudkzbK7wscs8yYgQToO5E= +github.com/pion/transport/v3 v3.0.1/go.mod h1:UY7kiITrlMv7/IKgd5eTUcaahZx5oUN3l9SzK5f5xE0= +github.com/pion/transport/v3 v3.0.7 h1:iRbMH05BzSNwhILHoBoAPxoB9xQgOaJk+591KC9P1o0= +github.com/pion/transport/v3 v3.0.7/go.mod h1:YleKiTZ4vqNxVwh77Z0zytYi7rXHl7j6uPLGhhz9rwo= +github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA= github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/prometheus/client_golang v1.19.0 h1:ygXvpU1AoN1MhdzckN+PyD9QJOSD4x7kmXYlnfbA6JU= -github.com/prometheus/client_golang v1.19.0/go.mod h1:ZRM9uEAypZakd+q/x7+gmsvXdURP+DABIEIjnmDdp+k= -github.com/prometheus/client_model v0.5.0 h1:VQw1hfvPvk3Uv6Qf29VrPF32JB6rtbgI6cYPYQjL0Qw= -github.com/prometheus/client_model v0.5.0/go.mod h1:dTiFglRmd66nLR9Pv9f0mZi7B7fk5Pm3gvsjB5tr+kI= -github.com/prometheus/common v0.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/power-devops/perfstat v0.0.0-20210106213030-5aafc221ea8c h1:ncq/mPwQF4JjgDlrVEn3C11VoGHZN7m8qihwgMEtzYw= +github.com/power-devops/perfstat v0.0.0-20210106213030-5aafc221ea8c/go.mod h1:OmDBASR4679mdNQnz2pUhc2G8CO2JrUAVFDRBDP/hJE= +github.com/prometheus/client_golang v1.22.0 h1:rb93p9lokFEsctTys46VnV1kLCDpVZ0a/Y92Vm0Zc6Q= +github.com/prometheus/client_golang v1.22.0/go.mod h1:R7ljNsLXhuQXYZYtw6GAE9AZg8Y7vEW5scdCXrWRXC0= +github.com/prometheus/client_model v0.6.2 h1:oBsgwpGs7iVziMvrGhE53c/GrLUsZdHnqNwqPLxwZyk= +github.com/prometheus/client_model v0.6.2/go.mod h1:y3m2F6Gdpfy6Ut/GBsUqTWZqCUvMVzSfMLjcu6wAwpE= +github.com/prometheus/common v0.65.0 h1:QDwzd+G1twt//Kwj/Ww6E9FQq1iVMmODnILtW1t2VzE= +github.com/prometheus/common v0.65.0/go.mod h1:0gZns+BLRQ3V6NdaerOhMbwwRbNh9hkGINtQAsP5GS8= +github.com/prometheus/procfs v0.17.0 h1:FuLQ+05u4ZI+SS/w9+BWEM2TXiHKsUQ9TADiRH7DuK0= +github.com/prometheus/procfs v0.17.0/go.mod h1:oPQLaDAMRbA+u8H5Pbfq+dl3VDAvHxMUOVhe0wYB2zw= +github.com/prysmaticlabs/gohashtree v0.0.4-beta h1:H/EbCuXPeTV3lpKeXGPpEV9gsUpkqOOVnWapUyeWro4= +github.com/prysmaticlabs/gohashtree v0.0.4-beta/go.mod h1:BFdtALS+Ffhg3lGQIHv9HDWuHS8cTvHZzrHWxwOtGOs= github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= -github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjRBZyWFQ= -github.com/rogpeppe/go-internal v1.10.0/go.mod h1:UQnix2H7Ngw/k4C5ijL5+65zddjncjaFoBhdsK/akog= -github.com/rs/cors v1.7.0 h1:+88SsELBHx5r+hZ8TCkggzSstaWNbDvThkVK8H6f9ik= -github.com/rs/cors v1.7.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU= +github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ= +github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88= +github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs= +github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= +github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= +github.com/rs/cors v1.11.1 h1:eU3gRzXLRK57F5rKMGMZURNdIG4EoAmX8k94r9wXWHA= +github.com/rs/cors v1.11.1/go.mod h1:XyqrcTp5zjWr1wsJ8PIRZssZ8b/WMcMf71DJnit4EMU= 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/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/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/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/supranational/blst v0.3.11 h1:LyU6FolezeWAhvQk0k6O/d49jqgO52MSDDfYgbeoEm4= -github.com/supranational/blst v0.3.11/go.mod h1:jZJtfjgudtNl4en1tzwPIV3KjUnQUvG3/j+w+fVonLw= +github.com/shirou/gopsutil v3.21.11+incompatible h1:+1+c1VGhc88SSonWP6foOcLhvnKlUeu/erjjvaPEYiI= +github.com/shirou/gopsutil v3.21.11+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA= +github.com/shirou/gopsutil/v3 v3.23.12 h1:z90NtUkp3bMtmICZKpC4+WaknU1eXtp5vtbQ11DgpE4= +github.com/shirou/gopsutil/v3 v3.23.12/go.mod h1:1FrWgea594Jp7qmjHUUPlJDTPgcsb9mGnXDxavtikzM= +github.com/shoenig/go-m1cpu v0.1.6 h1:nxdKQNcEB6vzgA2E2bvzKIYRuNj7XNJ4S/aRSwKzFtM= +github.com/shoenig/go-m1cpu v0.1.6/go.mod h1:1JJMcUBvfNwpq05QDQVAnx3gUHr9IYF7GNg9SUEw2VQ= +github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ= +github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ= +github.com/spkg/bom v0.0.0-20160624110644-59b7046e48ad/go.mod h1:qLr4V1qq6nMqFKkMo8ZTx3f+BZEkzsRUY10Xsm2mwU0= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= +github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= +github.com/stretchr/testify v1.8.3/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= +github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= +github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA= +github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= +github.com/supranational/blst v0.3.15 h1:rd9viN6tfARE5wv3KZJ9H8e1cg0jXW8syFCcsbHa76o= +github.com/supranational/blst v0.3.15/go.mod h1:jZJtfjgudtNl4en1tzwPIV3KjUnQUvG3/j+w+fVonLw= github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 h1:epCh84lMvA70Z7CTTCmYQn2CKbY8j86K7/FAIr141uY= github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7/go.mod h1:q4W45IWZaF22tdD+VEXcAWRA037jwmWEB5VWYORlTpc= -github.com/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.1 h1:8xSQ6szndafKVRmfyeUMxkNUJQMjL1F2zmsZ+qHpfho= -github.com/urfave/cli/v2 v2.27.1/go.mod h1:8qnjx1vcq5s2/wpsqoZFndg2CE5tNFyrTvS6SinrnYQ= -github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 h1:bAn7/zixMGCfxrRTfdpNzjtPYqr8smhKouy9mxVdGPU= -github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673/go.mod h1:N3UwUGtsrSj3ccvlPHLoLsHnpR27oXr4ZE984MbSER8= +github.com/testcontainers/testcontainers-go v0.35.0 h1:uADsZpTKFAtp8SLK+hMwSaa+X+JiERHtd4sQAFmXeMo= +github.com/testcontainers/testcontainers-go v0.35.0/go.mod h1:oEVBj5zrfJTrgjwONs1SsRbnBtH9OKl+IGl3UMcr2B4= +github.com/tklauser/go-sysconf v0.3.15 h1:VE89k0criAymJ/Os65CSn1IXaol+1wrsFHEB8Ol49K4= +github.com/tklauser/go-sysconf v0.3.15/go.mod h1:Dmjwr6tYFIseJw7a3dRLJfsHAMXZ3nEnL/aZY+0IuI4= +github.com/tklauser/numcpus v0.10.0 h1:18njr6LDBk1zuna922MgdjQuJFjrdppsZG60sHGfjso= +github.com/tklauser/numcpus v0.10.0/go.mod h1:BiTKazU708GQTYF4mB+cmlpT2Is1gLk7XVuEeem8LsQ= +github.com/urfave/cli/v2 v2.27.7 h1:bH59vdhbjLv3LAvIu6gd0usJHgoTTPhCFib8qqOwXYU= +github.com/urfave/cli/v2 v2.27.7/go.mod h1:CyNAG/xg+iAOg0N4MPGZqVmv2rCoP267496AOXUZjA4= +github.com/wlynxg/anet v0.0.3/go.mod h1:eay5PRQr7fIVAMbTbchTnO9gG65Hg/uYGdc7mguHxoA= +github.com/wlynxg/anet v0.0.5 h1:J3VJGi1gvo0JwZ/P1/Yc/8p63SoW98B5dHkYDmpgvvU= +github.com/wlynxg/anet v0.0.5/go.mod h1:eay5PRQr7fIVAMbTbchTnO9gG65Hg/uYGdc7mguHxoA= +github.com/xrash/smetrics v0.0.0-20250705151800-55b8f293f342 h1:FnBeRrxr7OU4VvAzt5X7s6266i6cSVkkFPS0TuXWbIg= +github.com/xrash/smetrics v0.0.0-20250705151800-55b8f293f342/go.mod h1:Ohn+xnUBiLI6FVj/9LpzZWtj1/D6lUovWYBkxHVV3aM= +github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= +github.com/yusufpapurcu/wmi v1.2.4 h1:zFUKzehAFReQwLys1b/iSMl+JQGSCSjtVqQn9bBrPo0= +github.com/yusufpapurcu/wmi v1.2.4/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.49.0 h1:jq9TW8u3so/bN+JPT166wjOI6/vQPF6Xe7nMNIltagk= +go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.49.0/go.mod h1:p8pYQP+m5XfbZm9fxtSKAbM6oIllS7s2AfxrChvc7iw= +go.opentelemetry.io/otel v1.6.3/go.mod h1:7BgNga5fNlF/iZjG06hM3yofffp0ofKCDwSXx1GC4dI= +go.opentelemetry.io/otel v1.24.0 h1:0LAOdjNmQeSTzGBzduGe/rU4tZhMwL5rWgtp9Ku5Jfo= +go.opentelemetry.io/otel v1.24.0/go.mod h1:W7b9Ozg4nkF5tWI5zsXkaKKDjdVjpD4oAt9Qi/MArHo= +go.opentelemetry.io/otel/metric v1.24.0 h1:6EhoGWWK28x1fbpA4tYTOWBkPefTDQnb8WSGXlc88kI= +go.opentelemetry.io/otel/metric v1.24.0/go.mod h1:VYhLe1rFfxuTXLgj4CBiyz+9WYBA8pNGJgDcSFRKBco= +go.opentelemetry.io/otel/trace v1.6.3/go.mod h1:GNJQusJlUgZl9/TQBPKU/Y/ty+0iVB5fjhKeJGZPGFs= +go.opentelemetry.io/otel/trace v1.24.0 h1:CsKnnL4dUAr/0llH9FKuc698G04IrpWV0MQA/Y1YELI= +go.opentelemetry.io/otel/trace v1.24.0/go.mod h1:HPc3Xr/cOApsBI154IU0OI0HJexz+aw5uPdbs3UCjNU= 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/mock v0.4.0 h1:VcM4ZOtdbR4f6VXfiOpwpVJDL6lCReaZ6mw31wqh7KU= @@ -169,37 +357,122 @@ go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0= go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y= 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.31.0 h1:ihbySMvVjLAeSH1IbfcRTkD/iNscyz8rGzjF/E5hV6U= -golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk= -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/mod v0.16.0 h1:QX4fJ0Rr5cPQCF7O9lh9Se4pmwfwskqZfq5moyldzic= -golang.org/x/mod v0.16.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= -golang.org/x/sync v0.5.0 h1:60k92dhOjHxJkrqnwsfl8KuaHbn/5dl0lUPUklKo3qE= -golang.org/x/sync v0.5.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +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-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= +golang.org/x/crypto v0.8.0/go.mod h1:mRqEX+O9/h5TFCrQhkgjo2yKi0yYA+9ecGkdQoHrywE= +golang.org/x/crypto v0.12.0/go.mod h1:NF0Gs7EO5K4qLn+Ylc+fih8BSTeIjAP05siRnAh98yw= +golang.org/x/crypto v0.18.0/go.mod h1:R0j02AL6hcrfOiy9T4ZYp/rcWeMxM3L6QYxlOuEG1mg= +golang.org/x/crypto v0.40.0 h1:r4x+VvoG5Fm+eJcxMaY8CQM7Lb0l1lsmjGBQ6s8BfKM= +golang.org/x/crypto v0.40.0/go.mod h1:Qr1vMER5WyS2dfPHAlsOj01wgLbsyWtFn/aY+5+ZdxY= +golang.org/x/exp v0.0.0-20250711185948-6ae5c78190dc h1:TS73t7x3KarrNd5qAipmspBDS1rkMcgVG/fS1aRb4Rc= +golang.org/x/exp v0.0.0-20250711185948-6ae5c78190dc/go.mod h1:A+z0yzpGtvnG90cToK5n2tu8UJVP2XUATh+r+sfOOOc= +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.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= +golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= +golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200813134508-3edf25e44fcc/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-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= +golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= +golang.org/x/net v0.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns= +golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg= +golang.org/x/net v0.14.0/go.mod h1:PpSgVXXLK0OxS0F31C1/tv6XNguvCrnXIDrFMspZIUI= +golang.org/x/net v0.20.0/go.mod h1:z8BVo6PvndSri0LbOE3hAn0apkU+1YvI6E70E9jsnvY= +golang.org/x/net v0.42.0 h1:jzkYrhi3YQWD6MLBJcsklgQsoAcw89EcZbJw8Z614hs= +golang.org/x/net v0.42.0/go.mod h1:FF1RA5d3u7nAYA4z2TkclSCKh68eSXtiFwcWQpPXdt8= +golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.16.0 h1:ycBJEhp9p4vXvUZNszeOq0kGTPghopOL8q0fq3vstxw= +golang.org/x/sync v0.16.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA= +golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-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-20220908164124-27713097b956/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200519105757-fe76b779f299/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200814200057-3d37ad5750ed/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-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211117180635-dee7805ff2e1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.7.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.28.0 h1:Fksou7UEQUWlKvIdsqzJmUmCX3cZuD2+P3XyyzwMhlA= -golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= -golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo= -golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ= -golang.org/x/time v0.3.0 h1:rg5rLMjNzMS1RkNLzCG38eapWhnYLFYXDXj2gOlr8j4= -golang.org/x/time v0.3.0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= -golang.org/x/tools v0.15.0 h1:zdAyfUGbYmuVokhzVmghFl2ZJh5QhcfebBgmVPFYA+8= -golang.org/x/tools v0.15.0/go.mod h1:hpksKq4dtpQWS1uQ61JkdqWM3LscIS6Slf+VVkm+wQk= -google.golang.org/protobuf v1.32.0 h1:pPC6BG5ex8PDFnkbrGU3EixyhKcQ2aDuBS36lqK/C7I= -google.golang.org/protobuf v1.32.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos= +golang.org/x/sys v0.16.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/sys v0.34.0 h1:H5Y5sJ2L2JRdyv7ROF1he/lPdvFsd0mJHFw2ThKHxLA= +golang.org/x/sys v0.34.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k= +golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= +golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= +golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k= +golang.org/x/term v0.7.0/go.mod h1:P32HKFT3hSsZrRxla30E9HqToFYAQPCMs/zFMBUFqPY= +golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo= +golang.org/x/term v0.11.0/go.mod h1:zC9APTIj3jG3FdV/Ons+XE1riIZXG4aZ4GTHiPZJPIU= +golang.org/x/term v0.16.0/go.mod h1:yn7UURbUtPyrVJPGPq404EukNFxcm/foM+bV/bfcDsY= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk= +golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= +golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= +golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8= +golang.org/x/text v0.12.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE= +golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= +golang.org/x/text v0.27.0 h1:4fGWRpyh641NLlecmyl4LOe6yDdfaYNrGb2zdfo4JV4= +golang.org/x/text v0.27.0/go.mod h1:1D28KMCvyooCX9hBiosv5Tz/+YLxj0j7XhWjpSUF7CU= +golang.org/x/time v0.12.0 h1:ScB/8o8olJvc+CQPWrK3fPZNfh7qgwCrY0zJmoEQLSE= +golang.org/x/time v0.12.0/go.mod h1:CDIdPxbZBQxdj6cxyCIdrNogrJKMJ7pr37NYpMcMDSg= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= +golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= +golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU= +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-20220411194840-2f41105eb62f h1:GGU+dLjvlC3qDwqYgL6UgRmHXhOOgns0bZu2Ty5mm6U= +golang.org/x/xerrors v0.0.0-20220411194840-2f41105eb62f/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +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.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= +google.golang.org/protobuf v1.36.6 h1:z1NpPI8ku2WgiWnf+t9wTPsn6eP1L7ksHUlkfLvd9xY= +google.golang.org/protobuf v1.36.6/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/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/natefinch/lumberjack.v2 v2.0.0 h1:1Lc07Kr7qY4U2YPouBjpCLxpiyxIVoxqXgkXLknAOE8= -gopkg.in/natefinch/lumberjack.v2 v2.0.0/go.mod h1:l0ndWWf7gzL7RNwBG7wST/UCcT4T24xpD6X8LsfU/+k= +gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys= +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.4/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.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -rsc.io/tmplfunc v0.0.3 h1:53XFQh69AfOa8Tw0Jm7t+GV7KZhOi6jzsCzTtKbMvzU= -rsc.io/tmplfunc v0.0.3/go.mod h1:AG3sTPzElb1Io3Yg4voV9AGZJuleGAwaVRxL9M49PhA= diff --git a/internal/flag/flags.go b/internal/flag/flags.go deleted file mode 100644 index e6545bb..0000000 --- a/internal/flag/flags.go +++ /dev/null @@ -1,106 +0,0 @@ -package flag - -import ( - "github.com/urfave/cli/v2" -) - -const ( - EncyrptedEDCSAFile = "encryptedWallet.json" -) - -var ( - KeyStorePathFlag = &cli.StringFlag{ - Name: "keystore-path", - Usage: "location of the keystore folder", - EnvVars: []string{"EO_KEYSTORE_PATH"}, - DefaultText: ".keystore", - Value: ".keystore", - } - EthRPCFlag = &cli.StringFlag{ - Name: "eth-rpc-endpoint", - Usage: "ethereum rpc url", - EnvVars: []string{"ETH_RPC_ENDPOINT"}, - } - RegistryCoordinatorFlag = &cli.StringFlag{ - Name: "registry-coordinator", - Usage: "registry coordinator contract address", - EnvVars: []string{"EO_REGISTRY_COORDINATOR"}, - } - StakeRegistryFlag = &cli.StringFlag{ - Name: "stake-registry", - Usage: "stake registry contract address", - EnvVars: []string{"EO_STAKE_REGISTRY"}, - } - EcdsaPrivateKeyFlag = &cli.StringFlag{ - Name: "ecdsa-private-key", - Usage: "ecdsa private key", - EnvVars: []string{"EO_ECDSA_PRIVATE_KEY"}, - } - BlsPrivateKeyFlag = &cli.StringFlag{ - Name: "bls-private-key", - Usage: "bls private key", - EnvVars: []string{"EO_BLS_PRIVATE_KEY"}, - } - SaltFlag = &cli.StringFlag{ - Name: "salt", - Usage: "salt", - EnvVars: []string{"EO_SALT"}, - DefaultText: "0x01", - Value: "0x01", - } - ExpiryFlag = &cli.StringFlag{ - Name: "expiry", - Usage: "expiry", - EnvVars: []string{"EO_EXPIRY"}, - DefaultText: "115792089237316195423570985008687907853269984665640564039457584007913129639935", - Value: "115792089237316195423570985008687907853269984665640564039457584007913129639935", - } - PassphraseFlag = &cli.StringFlag{ - Name: "passphrase", - Usage: "passphrase to open the encrypted private key", - EnvVars: []string{"EO_PASSPHRASE"}, - } - ValidatorRoleFlag = &cli.StringFlag{ - Name: "validator-role", - Usage: "role of the operator", - EnvVars: []string{"EO_VALIDATOR_ROLE"}, - DefaultText: "DATA_VALIDATOR", - Value: "DATA_VALIDATOR", - } - ChainValidatorG1PointSignatureFlag = &cli.StringSliceFlag{ - Name: "chain-validator-g1-point-signature", - Usage: "G1Point signature of the chain operator", - EnvVars: []string{"EO_CHAIN_VALIDATOR_G1_POINT_SIGNATURE"}, - } - QuorumNumberFlag = &cli.IntFlag{ - Name: "quorum-number", - Usage: "quorum number", - EnvVars: []string{"EO_QUORUM_NUMBER"}, - DefaultText: "0", - Value: 0, - } - EOChainEthRPCFlag = &cli.StringFlag{ - Name: "eochain-rpc-endpoint", - Usage: "eochain rpc url", - EnvVars: []string{"EO_CHAIN_RPC_ENDPOINT"}, - } - EncryptOnlyFlag = &cli.BoolFlag{ - Name: "encrypt-only", - Usage: "Indication if the key should be just encrypted", - EnvVars: []string{"EO_CHAIN_ENCRYPT_ONLY"}, - DefaultText: "False", - Value: false, - } - OverrideFlag = &cli.BoolFlag{ - Name: "alias-override", - Usage: "Indication if a new alias key should be created", - EnvVars: []string{"EO_ALIAS_OVERRIDE"}, - DefaultText: "False", - Value: false, - } - EOConfigAddressFlag = &cli.StringFlag{ - Name: "eoconfig-address", - Usage: "eoconfig contract address", - EnvVars: []string{"EO_CONFIG_ADDRESS"}, - } -) diff --git a/internal/operatorcli/operator_cli.go b/internal/operatorcli/operator_cli.go deleted file mode 100644 index 3cac462..0000000 --- a/internal/operatorcli/operator_cli.go +++ /dev/null @@ -1,853 +0,0 @@ -package operatorcli - -import ( - "context" - "crypto/ecdsa" - "encoding/hex" - "fmt" - "math/big" - "os" - "path/filepath" - "strings" - - cli "github.com/urfave/cli/v2" - - "github.com/consensys/gnark-crypto/ecc/bn254" - - "github.com/ethereum/go-ethereum/accounts/abi/bind" - gethcommon "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/crypto" - - "github.com/Layr-Labs/eigensdk-go/chainio/clients/elcontracts" - "github.com/Layr-Labs/eigensdk-go/chainio/clients/eth" - "github.com/Layr-Labs/eigensdk-go/chainio/clients/wallet" - "github.com/Layr-Labs/eigensdk-go/chainio/txmgr" - smbase "github.com/Layr-Labs/eigensdk-go/contracts/bindings/ServiceManagerBase" - eigensdkbls "github.com/Layr-Labs/eigensdk-go/crypto/bls" - eigensdkecdsa "github.com/Layr-Labs/eigensdk-go/crypto/ecdsa" - "github.com/Layr-Labs/eigensdk-go/logging" - "github.com/Layr-Labs/eigensdk-go/signerv2" - - regcoord "github.com/eodata/operator-cli/contracts/bindings/EORegistryCoordinator" - stakeregistry "github.com/eodata/operator-cli/contracts/bindings/EOStakeRegistry" - - eoconfig "github.com/eodata/operator-cli/contracts/bindings/EOConfig" - "github.com/eodata/operator-cli/internal/flag" -) - -type avsClient struct { - registryCoordinatorAddr gethcommon.Address - serviceManagerAddr gethcommon.Address - delegationManagerAddr gethcommon.Address - avsDirectoryAddr gethcommon.Address - registryCoordinator *regcoord.ContractEORegistryCoordinator - serviceManager *smbase.ContractServiceManagerBase - stakeRegistry *stakeregistry.ContractEOStakeRegistry - elReader elcontracts.ELReader -} - -func RunEncrypt(c *cli.Context) error { - passphrase := c.String(flag.PassphraseFlag.Name) - if passphrase == "" { - return cli.Exit("passphrase is required", 1) - } - - keyStorePath := c.String(flag.KeyStorePathFlag.Name) - if keyStorePath == "" { - return cli.Exit("keystore-path is required", 1) - } - - // Encrypt the ecdsa private key and save it to a file - ecdsaPair, err := crypto.HexToECDSA(c.String(flag.EcdsaPrivateKeyFlag.Name)) - if err != nil { - return cli.Exit(fmt.Sprintf("Invalid EDCSA private key %v", err), 1) - } - - if err = eigensdkecdsa.WriteKey(filepath.Join(keyStorePath, "ecdsaEncryptedWallet.json"), ecdsaPair, passphrase); err != nil { - return cli.Exit(fmt.Sprintf("Error writing the ecdsaEncryptedWallet.json file %v", err), 1) - } - fmt.Println("ecdsa address ", crypto.PubkeyToAddress(ecdsaPair.PublicKey), "saved") - - // Encrypt the bls private key and save it to a file - blsKeyPair, err := eigensdkbls.NewKeyPairFromString(c.String(flag.BlsPrivateKeyFlag.Name)) - if err != nil { - return cli.Exit(fmt.Sprintf("Invalid BLS private key %v", err), 1) - } - - if err = blsKeyPair.SaveToFile(filepath.Join(keyStorePath, "blsEncryptedWallet.json"), passphrase); err != nil { - return cli.Exit(fmt.Sprintf("Error writing the blsEncryptedWallet.json file %v", err), 1) - } - fmt.Println("bls address G1, G2 ", blsKeyPair.GetPubKeyG1().String(), ", ", blsKeyPair.GetPubKeyG2().String(), "saved") - - return nil -} - -func RunDecrypt(c *cli.Context) error { - passphrase := c.String(flag.PassphraseFlag.Name) - if passphrase == "" { - return cli.Exit("passphrase is required", 1) - } - - keyStorePath := c.String(flag.KeyStorePathFlag.Name) - if keyStorePath == "" { - return cli.Exit("keystore-path is required", 1) - } - - ecdsaPair, err := eigensdkecdsa.ReadKey(filepath.Join(keyStorePath, "ecdsaEncryptedWallet.json"), passphrase) - if err != nil { - return cli.Exit(fmt.Sprintf("Error reading the ecdsaEncryptedWallet.json file %v", err), 1) - } - fmt.Println("ecdsa address ", crypto.PubkeyToAddress(ecdsaPair.PublicKey), "private key", hex.EncodeToString(ecdsaPair.D.Bytes())) - - ecdsaEOChainPair, err := eigensdkecdsa.ReadKey(filepath.Join(keyStorePath, "ecdsaAliasedEncryptedWallet.json"), passphrase) - if err != nil { - if err == os.ErrNotExist { - fmt.Println("eochain alias was not set in the system") - return nil - } - return cli.Exit(fmt.Sprintf("Error reading the ecdsaAliasedEncryptedWallet.json file %v", err), 1) - } - fmt.Println("eochain ecdsa address ", crypto.PubkeyToAddress(ecdsaEOChainPair.PublicKey), "private key", hex.EncodeToString(ecdsaEOChainPair.D.Bytes())) - - blsKeyPair, err := eigensdkbls.ReadPrivateKeyFromFile(filepath.Join(keyStorePath, "blsEncryptedWallet.json"), passphrase) - if err != nil { - return cli.Exit(fmt.Sprintf("Error reading the blsEncryptedWallet.json file %v", err), 1) - } - fmt.Println("bls address G1, G2 ", blsKeyPair.GetPubKeyG1().String(), ", ", blsKeyPair.GetPubKeyG2().String(), "private key", blsKeyPair.PrivKey.String()) - - return nil -} - -func RunRegister(c *cli.Context) error { - passphrase := c.String(flag.PassphraseFlag.Name) - keyStorePath := c.String(flag.KeyStorePathFlag.Name) - - var ecdsaPair *ecdsa.PrivateKey - var blsKeyPair *eigensdkbls.KeyPair - var err error - - logger, err := logging.NewZapLogger(logging.Production) - if err != nil { - return cli.Exit(fmt.Sprintf("error creating logger %v", err), 1) - } - - if passphrase == "" || keyStorePath == "" { - if c.String(flag.EcdsaPrivateKeyFlag.Name) == "" || c.String(flag.BlsPrivateKeyFlag.Name) == "" { - return cli.Exit("either passphrase and keystore-path or ecdsa-private-key and bls-private-key are required", 1) - } - ecdsaPair, err = crypto.HexToECDSA(c.String(flag.EcdsaPrivateKeyFlag.Name)) - if err != nil { - return cli.Exit(fmt.Sprintf("Invalid EDCSA private key %v", err), 1) - } - blsKeyPair, err = eigensdkbls.NewKeyPairFromString(c.String(flag.BlsPrivateKeyFlag.Name)) - if err != nil { - return cli.Exit(fmt.Sprintf("Invalid BLS private key %v", err), 1) - } - } else { - ecdsaPair, err = eigensdkecdsa.ReadKey(filepath.Join(keyStorePath, "ecdsaEncryptedWallet.json"), passphrase) - if err != nil { - return cli.Exit(fmt.Sprintf("Failed to read ecdsaEncryptedWallet.json file %v", err), 1) - } - blsKeyPair, err = eigensdkbls.ReadPrivateKeyFromFile(filepath.Join(keyStorePath, "blsEncryptedWallet.json"), passphrase) - if err != nil { - return cli.Exit(fmt.Sprintf("Failed to read blsEncryptedWallet.json file %v", err), 1) - } - } - - if c.String(flag.EthRPCFlag.Name) == "" { - return cli.Exit("eth-rpc is required", 1) - } - - ethClient, err := eth.NewClient(c.String(flag.EthRPCFlag.Name)) - if err != nil { - return cli.Exit(fmt.Sprintf("Failed to create read-only Eth client %v %v", c.String(flag.EthRPCFlag.Name), err), 1) - } - - chainIDBigInt, err := ethClient.ChainID(context.Background()) - if err != nil { - return cli.Exit(fmt.Sprintf("Error getting chainId (%v): %v", c.String(flag.EthRPCFlag.Name), err), 1) - } - - signerV2, signerAddr, err := signerv2.SignerFromConfig(signerv2.Config{PrivateKey: ecdsaPair}, chainIDBigInt) - if err != nil { - return cli.Exit(fmt.Sprintf("Error creating the register transaction signer for operator %v on Ethereum mainnet/holesky (%v) %v", crypto.PubkeyToAddress(ecdsaPair.PublicKey), c.String(flag.EthRPCFlag.Name), err), 1) - } - - var saltBytes [32]byte - inputBytes, err := hex.DecodeString(strings.TrimPrefix(c.String(flag.SaltFlag.Name), "0x")) - if err != nil { - return cli.Exit(fmt.Sprintf("Invalid salt %v", err), 1) - } - copy(saltBytes[:], inputBytes) - - expiry, ok := big.NewInt(0).SetString(c.String(flag.ExpiryFlag.Name), 10) - if !ok { - return cli.Exit("Invalid expiry", 1) - } - - chainValidatorG1PointSignature := ConvertToBN254G1Point(eigensdkbls.NewG1Point(big.NewInt(0), big.NewInt(0))) - - if c.String(flag.ValidatorRoleFlag.Name) != "DATA_VALIDATOR" { - if len(c.StringSlice(flag.ChainValidatorG1PointSignatureFlag.Name)) != 2 { - return cli.Exit("chain-validator-g1-point-signature is required or has too many values", 1) - } - x, ok := new(big.Int).SetString(c.StringSlice(flag.ChainValidatorG1PointSignatureFlag.Name)[0][2:], 16) - if !ok { - return cli.Exit("Invalid chain-validator-g1-point-signature (x)", 1) - } - y, ok := new(big.Int).SetString(c.StringSlice(flag.ChainValidatorG1PointSignatureFlag.Name)[1][2:], 16) - if !ok { - return cli.Exit("Invalid chain-validator-g1-point-signature (y)", 1) - } - chainValidatorG1PointSignature = ConvertToBN254G1Point(eigensdkbls.NewG1Point(x, y)) - } - - if c.String(flag.RegistryCoordinatorFlag.Name) == "" { - return cli.Exit("registry-coordinator is required", 1) - } - registryCoordinatorAddr := gethcommon.HexToAddress(c.String(flag.RegistryCoordinatorFlag.Name)) - avsClient, err := buildAVSClient(registryCoordinatorAddr, ethClient, logger) - if err != nil { - return cli.Exit(fmt.Sprintf("Error creating AVS client %v", err), 1) - } - - g1HashedMsgToSign, err := avsClient.registryCoordinator.PubkeyRegistrationMessageHash(&bind.CallOpts{}, signerAddr) - if err != nil { - return cli.Exit(fmt.Sprintf("Error getting PubkeyRegistrationMessageHash from registryCoordinator contract %v", err), 1) - } - signedMsg := ConvertToBN254G1Point( - blsKeyPair.SignHashedToCurveMessage(ConvertBn254GethToGnark(g1HashedMsgToSign)).G1Point, - ) - - G1pubkeyBN254 := ConvertToBN254G1Point(blsKeyPair.GetPubKeyG1()) - G2pubkeyBN254 := ConvertToBN254G2Point(blsKeyPair.GetPubKeyG2()) - pubkeyRegParams := regcoord.IEOBLSApkRegistryPubkeyRegistrationParams{ - PubkeyRegistrationSignature: signedMsg, - ChainValidatorSignature: chainValidatorG1PointSignature, - PubkeyG1: G1pubkeyBN254, - PubkeyG2: G2pubkeyBN254, - } - - // Params to register operator in delegation manager's operator-avs mapping - msgToSign, err := avsClient.elReader.CalculateOperatorAVSRegistrationDigestHash( - &bind.CallOpts{}, - signerAddr, - avsClient.serviceManagerAddr, - saltBytes, - expiry, - ) - if err != nil { - return cli.Exit(fmt.Sprintf("Error generating message to sign by operator %v on Ethereum mainnet/Holeskey (%v) using CalculateOperatorAVSRegistrationDigestHash %v", crypto.PubkeyToAddress(ecdsaPair.PublicKey), c.String(flag.EthRPCFlag.Name), err), 1) - } - operatorSignature, err := crypto.Sign(msgToSign[:], ecdsaPair) - if err != nil { - return cli.Exit(fmt.Sprintf("Error signing the message using CalculateOperatorAVSRegistrationDigestHash for operator %v on Ethereum mainnet/Holeskey (%v) %v", crypto.PubkeyToAddress(ecdsaPair.PublicKey), c.String(flag.EthRPCFlag.Name), err), 1) - } - - operatorSignature[64] += 27 - operatorSignatureWithSaltAndExpiry := regcoord.ISignatureUtilsSignatureWithSaltAndExpiry{ - Signature: operatorSignature, - Salt: saltBytes, - Expiry: expiry, - } - - txSender, err := wallet.NewPrivateKeyWallet(ethClient, signerV2, signerAddr, logger) - if err != nil { - return cli.Exit(fmt.Sprintf("Error creating the register transaction sender for operator %v on Ethereum mainnet/Holesky (%v) %v", crypto.PubkeyToAddress(ecdsaPair.PublicKey), c.String(flag.EthRPCFlag.Name), err), 1) - } - txMgr := txmgr.NewSimpleTxManager(txSender, ethClient, logger, signerV2, signerAddr) - - noSendTxOpts, err := txMgr.GetNoSendTxOpts() - if err != nil { - return cli.Exit(fmt.Sprintf("error creating transaction object %v", err), 1) - } - - tx, err := avsClient.registryCoordinator.RegisterOperator( - noSendTxOpts, - []byte{0}, - pubkeyRegParams, - operatorSignatureWithSaltAndExpiry, - ) - if err != nil { - return cli.Exit(fmt.Sprintf("Error creating the register transaction for operator %v on Ethereum mainnet/Holeskey (%v) %v", crypto.PubkeyToAddress(ecdsaPair.PublicKey), c.String(flag.EthRPCFlag.Name), err), 1) - } - - ctx := context.Background() - receipt, err := txMgr.Send(ctx, tx) - if err != nil { - return cli.Exit(fmt.Sprintf("register transaction for operator %v on Ethereum mainnet/Holesky (%v) failed %v", crypto.PubkeyToAddress(ecdsaPair.PublicKey), c.String(flag.EthRPCFlag.Name), err), 1) - } - if receipt.Status != 1 { - return cli.Exit(fmt.Sprintf("register transaction %v for operator %v on Ethereum mainnet/Holesky (%v) reverted", receipt.TxHash.Hex(), crypto.PubkeyToAddress(ecdsaPair.PublicKey), c.String(flag.EthRPCFlag.Name)), 1) - } - - logger.Info("succesfully registered to EO AVS", "address", signerAddr, "tx hash", receipt.TxHash.Hex()) - - return nil -} - -func RunDeregister(c *cli.Context) error { - passphrase := c.String(flag.PassphraseFlag.Name) - keyStorePath := c.String(flag.KeyStorePathFlag.Name) - - var ecdsaPair *ecdsa.PrivateKey - var err error - - logger, err := logging.NewZapLogger(logging.Production) - if err != nil { - return cli.Exit(fmt.Sprintf("error creating logger %v", err), 1) - } - - if passphrase == "" || keyStorePath == "" { - if c.String(flag.EcdsaPrivateKeyFlag.Name) == "" { - return cli.Exit("either passphrase and keystore-path or ecdsa-private-key are required", 1) - } - ecdsaPair, err = crypto.HexToECDSA(c.String(flag.EcdsaPrivateKeyFlag.Name)) - if err != nil { - return cli.Exit(fmt.Sprintf("Invalid EDCSA private key %v", err), 1) - } - } else { - ecdsaPair, err = eigensdkecdsa.ReadKey(filepath.Join(keyStorePath, "ecdsaEncryptedWallet.json"), passphrase) - if err != nil { - return cli.Exit(fmt.Sprintf("Failed to read ecdsaEncryptedWallet.json file %v", err), 1) - } - } - - if c.String(flag.EthRPCFlag.Name) == "" { - return cli.Exit("eth-rpc is required", 1) - } - - ethClient, err := eth.NewClient(c.String(flag.EthRPCFlag.Name)) - if err != nil { - return cli.Exit(fmt.Sprintf("Failed to create Eth client %v %v", c.String(flag.EthRPCFlag.Name), err), 1) - } - - chainIDBigInt, err := ethClient.ChainID(context.Background()) - if err != nil { - return cli.Exit(fmt.Sprintf("cannot get chainId (%v): %v", c.String(flag.EthRPCFlag.Name), err), 1) - } - - if c.String(flag.RegistryCoordinatorFlag.Name) == "" { - return cli.Exit("registry-coordinator is required", 1) - } - registryCoordinatorAddr := gethcommon.HexToAddress(c.String(flag.RegistryCoordinatorFlag.Name)) - avsClient, err := buildAVSClient(registryCoordinatorAddr, ethClient, logger) - if err != nil { - return cli.Exit(fmt.Sprintf("Error creating AVS client %v", err), 1) - } - - signerV2, signerAddr, err := signerv2.SignerFromConfig(signerv2.Config{PrivateKey: ecdsaPair}, chainIDBigInt) - if err != nil { - return cli.Exit(fmt.Sprintf("Error creating the deregister transaction signer for operator %v on Ethereum mainnet/Holesky (%v) %v", crypto.PubkeyToAddress(ecdsaPair.PublicKey), c.String(flag.EthRPCFlag.Name), err), 1) - } - - txSender, err := wallet.NewPrivateKeyWallet(ethClient, signerV2, signerAddr, logger) - if err != nil { - return cli.Exit(fmt.Sprintf("Error creating the deregister transaction sender for operator %v on Ethereum mainnet/Holesky (%v) %v", crypto.PubkeyToAddress(ecdsaPair.PublicKey), c.String(flag.EthRPCFlag.Name), err), 1) - } - txMgr := txmgr.NewSimpleTxManager(txSender, ethClient, logger, signerV2, signerAddr) - - noSendTxOpts, err := txMgr.GetNoSendTxOpts() - - if err != nil { - return cli.Exit(fmt.Sprintf("Error creating transaction object %v", err), 1) - } - tx, err := avsClient.registryCoordinator.DeregisterOperator( - noSendTxOpts, - []byte{0}, - ) - if err != nil { - return cli.Exit(fmt.Sprintf("Error creating the deregister transaction for operator %v on Ethereum mainnet/Holesky (%v) %v", crypto.PubkeyToAddress(ecdsaPair.PublicKey), c.String(flag.EthRPCFlag.Name), err), 1) - } - ctx := context.Background() - receipt, err := txMgr.Send(ctx, tx) - if err != nil { - return cli.Exit(fmt.Sprintf("deregister transaction for operator %v on Ethereum mainnet/Holesky (%v) failed %v", crypto.PubkeyToAddress(ecdsaPair.PublicKey), c.String(flag.EthRPCFlag.Name), err), 1) - } - if receipt.Status != 1 { - return cli.Exit(fmt.Sprintf("deregister transaction %v for operator %v on Ethereum mainnet/Holesky (%v) reverted", receipt.TxHash.Hex(), crypto.PubkeyToAddress(ecdsaPair.PublicKey), c.String(flag.EthRPCFlag.Name)), 1) - } - logger.Info("DeregisterOperator", "gas", receipt.GasUsed, "txHash", receipt.TxHash.Hex()) - - logger.Info("succesfully deregistered from EO AVS", "address", signerAddr, "tx hash", receipt.TxHash.Hex()) - - return nil -} - -func RunPrintStatus(c *cli.Context) error { - passphrase := c.String(flag.PassphraseFlag.Name) - keyStorePath := c.String(flag.KeyStorePathFlag.Name) - - var ecdsaOperatorPair *ecdsa.PrivateKey - var ecdsaAliasPair *ecdsa.PrivateKey - operatorIsEOA := true - var err error - - logger, err := logging.NewZapLogger(logging.Production) - if err != nil { - return cli.Exit(fmt.Sprintf("error creating logger %v", err), 1) - } - - if passphrase == "" || keyStorePath == "" { - return cli.Exit("passphrase and keystore-path are required", 1) - } - ecdsaOperatorPair, err = eigensdkecdsa.ReadKey(filepath.Join(keyStorePath, "ecdsaEncryptedWallet.json"), passphrase) - if err != nil { - return cli.Exit(fmt.Sprintf("Failed to read ecdsaEncryptedWallet.json file %v", err), 1) - } - operatorAddress := crypto.PubkeyToAddress(ecdsaOperatorPair.PublicKey) - - ecdsaAliasPair, err = eigensdkecdsa.ReadKey(filepath.Join(keyStorePath, "ecdsaAliasedEncryptedWallet.json"), passphrase) - if err != nil { - return cli.Exit(fmt.Sprintf("Failed to read ecdsaAliasedEncryptedWallet.json file %v", err), 1) - } - operatorAliasAddress := crypto.PubkeyToAddress(ecdsaAliasPair.PublicKey) - - if c.String(flag.EthRPCFlag.Name) == "" { - return cli.Exit("eth-rpc is required", 1) - } - - ethClient, err := eth.NewClient(c.String(flag.EthRPCFlag.Name)) - if err != nil { - return cli.Exit(fmt.Sprintf("Failed to create Eth client %v %v", c.String(flag.EthRPCFlag.Name), err), 1) - } - - if c.String(flag.RegistryCoordinatorFlag.Name) == "" { - return cli.Exit("registry-coordinator is required", 1) - } - registryCoordinatorAddr := gethcommon.HexToAddress(c.String(flag.RegistryCoordinatorFlag.Name)) - - avsClient, err := buildAVSClient(registryCoordinatorAddr, ethClient, logger) - if err != nil { - return cli.Exit(fmt.Sprintf("Failed to create AVS client %v", err), 1) - } - - code, err := ethClient.CodeAt(context.Background(), operatorAddress, nil) - if err == nil && len(code) > 0 { - operatorIsEOA = false - } - - if c.String(flag.EOChainEthRPCFlag.Name) == "" { - return cli.Exit("eochain-rpc-endpoint is required", 1) - } - - eochainEthClient, err := eth.NewClient(c.String(flag.EOChainEthRPCFlag.Name)) - if err != nil { - return cli.Exit(fmt.Sprintf("Failed to create EOChain Eth client %v %v", c.String(flag.EOChainEthRPCFlag.Name), err), 1) - } - - eoConfigAddr := gethcommon.HexToAddress(c.String(flag.EOConfigAddressFlag.Name)) - contractEOConfig, err := eoconfig.NewEoconfig(eoConfigAddr, eochainEthClient) - if err != nil { - return cli.Exit(fmt.Sprintf("Failed to load EOConfig contract %v", err), 1) - } - - operatorAlias, err := contractEOConfig.OperatorToAlias(&bind.CallOpts{Context: context.Background()}, operatorAddress) - if (err != nil) || (operatorAlias == (gethcommon.Address{})) { - return cli.Exit(fmt.Sprintf("Failed to get operator %v alias %v", operatorAddress, err), 1) - } - logger.Info("operator details", "operator address", operatorAddress, "alias address", operatorAliasAddress, "operator is EOA", operatorIsEOA) - - if operatorAlias != operatorAliasAddress { - return cli.Exit(fmt.Sprintf("Operator (%v) alias (%v) does not match the expected alias (%v)", operatorAddress, operatorAlias, operatorAliasAddress), 1) - } - - var zeroID [32]byte - id, err := avsClient.registryCoordinator.GetOperatorId(&bind.CallOpts{Context: context.Background()}, operatorAddress) - if (err != nil) || (id == zeroID) { - cli.Exit(fmt.Sprintf("Error while GetOperatorId %v", err), 1) - } - - status, err := avsClient.registryCoordinator.GetOperatorStatus(&bind.CallOpts{Context: context.Background()}, operatorAddress) - if err != nil { - cli.Exit(fmt.Sprintf("Error while GetOperatorStatus %v", err), 1) - } - - switch status { - case 0: - logger.Info("Operator Status", "status", "NEVER REGISTERED") - case 1: - logger.Info("Operator Status", "status", "REGISTERED") - case 2: - logger.Info("Operator Status", "status", "DEREGISTERED") - default: - cli.Exit(fmt.Sprintf("Unknown operator status %v", status), 1) - } - - stake, err := avsClient.stakeRegistry.GetLatestStakeUpdate(&bind.CallOpts{Context: context.Background()}, id, uint8(c.Int(flag.QuorumNumberFlag.Name))) - if err != nil { - cli.Exit(fmt.Sprintf("Error while GetLatestStakeUpdate %v", err), 1) - } - logger.Info("Operator stake update", "stake", stake.Stake, "block number", stake.UpdateBlockNumber) - - balance, err := eochainEthClient.BalanceAt(context.Background(), operatorAddress, nil) - if err != nil { - cli.Exit(fmt.Sprintf("Error-7 while getting the operator balance %v", err), 1) - } - balanceInEth := new(big.Float).Quo(new(big.Float).SetInt(balance), new(big.Float).SetInt(big.NewInt(1e18))) - logger.Info("Operator balance is expected", "operator address", operatorAddress.Hex(), "balance", balanceInEth.String()) - - balance, err = eochainEthClient.BalanceAt(context.Background(), operatorAliasAddress, nil) - if err != nil { - cli.Exit(fmt.Sprintf("Error-8 while getting the operator alias balance %v", err), 1) - } - balanceInEth = new(big.Float).Quo(new(big.Float).SetInt(balance), new(big.Float).SetInt(big.NewInt(1e18))) - logger.Info("Operator alias balance is expected", "operator alias address", operatorAliasAddress.Hex(), "balance", balanceInEth.String()) - - return nil -} - -func RunGenerateBLSKey(c *cli.Context) error { - keyPair, err := eigensdkbls.GenRandomBlsKeys() - if err != nil { - return cli.Exit(fmt.Sprintf("Failed to generate BLS key pair %v", err), 1) - } - fmt.Println("BLS private key", keyPair.PrivKey.String()) - fmt.Println("BLS public key G1", keyPair.GetPubKeyG1().String()) - fmt.Println("BLS public key G2", keyPair.GetPubKeyG2().String()) - return nil -} - -func RunGenerateAlias(c *cli.Context) error { - passphrase := c.String(flag.PassphraseFlag.Name) - if passphrase == "" { - return cli.Exit("passphrase is required", 1) - } - - keyStorePath := c.String(flag.KeyStorePathFlag.Name) - if keyStorePath == "" { - return cli.Exit("keystore-path is required", 1) - } - - // The following summarizes the logic of setting the alias in the eochain - // An alias exists | specified as argument | override flag | expected behavior - // yes | no | no | use the existing value - // yes | no | yes | use the existing value - // yes | yes | no | return an error - // yes | yes | yes | use the value from the cli - // no | no | no | generate a new value - // no | no | yes | generate a new value - // no | yes | no | use the value from the cli - // no | yes | yes | use the value from the cli - - var err error - var aliasEcdsaPair *ecdsa.PrivateKey - aliasEcdsaPair, err = eigensdkecdsa.ReadKey(filepath.Join(keyStorePath, "ecdsaAliasedEncryptedWallet.json"), passphrase) - if err != nil { - // there was an error reading the alias key (either the file doesn't exist or it is corrupted), consider as if the alias doesn't exist - if c.String(flag.EcdsaPrivateKeyFlag.Name) != "" { - // Use the private key passed in the command line - aliasEcdsaPair, err = crypto.HexToECDSA(c.String(flag.EcdsaPrivateKeyFlag.Name)) - if err != nil { - return cli.Exit(fmt.Sprintf("Invalid EDCSA private key %v", err), 1) - } - } else { - // Generate a new key - aliasEcdsaPair, err = crypto.GenerateKey() - if err != nil { - return cli.Exit(fmt.Sprintf("Failed to generate ECDSA key %v", err), 1) - } - fmt.Println("a new alias ecdsa was generated address ", crypto.PubkeyToAddress(aliasEcdsaPair.PublicKey), "private key", hex.EncodeToString(aliasEcdsaPair.D.Bytes())) - } - } else { - if c.String(flag.EcdsaPrivateKeyFlag.Name) != "" { - if !c.Bool(flag.OverrideFlag.Name) { - return cli.Exit("The alias key already exists, cannot override", 1) - } - // Use the private key passed in the command line - aliasEcdsaPair, err = crypto.HexToECDSA(c.String(flag.EcdsaPrivateKeyFlag.Name)) - if err != nil { - return cli.Exit(fmt.Sprintf("Invalid EDCSA private key %v", err), 1) - } - } - } - - // Save the private key to a file - if err = eigensdkecdsa.WriteKey(filepath.Join(keyStorePath, "ecdsaAliasedEncryptedWallet.json"), aliasEcdsaPair, passphrase); err != nil { - return cli.Exit(fmt.Sprintf("Error writing the ecdsaAliasedEncryptedWallet.json file %v", err), 1) - } - - fmt.Println("alias ecdsa address ", crypto.PubkeyToAddress(aliasEcdsaPair.PublicKey), "encrpyted and saved") - - return nil -} - -func RunDeclareAlias(c *cli.Context) error { - logger, err := logging.NewZapLogger(logging.Production) - if err != nil { - return cli.Exit(fmt.Sprintf("Error creating logger %v", err), 1) - } - - passphrase := c.String(flag.PassphraseFlag.Name) - if passphrase == "" { - return cli.Exit("passphrase is required", 1) - } - - keyStorePath := c.String(flag.KeyStorePathFlag.Name) - if keyStorePath == "" { - return cli.Exit("keystore-path is required", 1) - } - - ethEcdsaPair, err := eigensdkecdsa.ReadKey(filepath.Join(keyStorePath, "ecdsaEncryptedWallet.json"), passphrase) - if err != nil { - return cli.Exit(fmt.Sprintf("Failed to read ecdsaEncryptedWallet.json file %v", err), 1) - } - - aliasEcdsaPair, err := eigensdkecdsa.ReadKey(filepath.Join(keyStorePath, "ecdsaAliasedEncryptedWallet.json"), passphrase) - if err != nil { - return cli.Exit(fmt.Sprintf("Failed to read ecdsaAliasedEncryptedWallet.json file %v", err), 1) - } - - if c.String(flag.EOChainEthRPCFlag.Name) == "" { - return cli.Exit("eochain-eth-rpc is required", 1) - } - - if c.String(flag.EOConfigAddressFlag.Name) == "" { - return cli.Exit("eoconfig is required", 1) - } - eoConfigAddr := gethcommon.HexToAddress(c.String(flag.EOConfigAddressFlag.Name)) - - ethClient, err := eth.NewClient(c.String(flag.EOChainEthRPCFlag.Name)) - if err != nil { - return cli.Exit(fmt.Sprintf("Failed to create Eth client %v %v", c.String(flag.EOChainEthRPCFlag.Name), err), 1) - } - - chainIDBigInt, err := ethClient.ChainID(context.Background()) - if err != nil { - return cli.Exit(fmt.Sprintf("cannot get chainId (%v): %v", c.String(flag.EOChainEthRPCFlag.Name), err), 1) - } - - contractEOConfig, err := eoconfig.NewEoconfig(eoConfigAddr, ethClient) - if err != nil { - return cli.Exit(fmt.Sprintf("Failed to bind the eoconfig contract %v", err), 1) - } - - signerV2, signerAddr, err := signerv2.SignerFromConfig(signerv2.Config{PrivateKey: ethEcdsaPair}, chainIDBigInt) - if err != nil { - return cli.Exit(fmt.Sprintf("Error creating the signer function for %v %v", crypto.PubkeyToAddress(ethEcdsaPair.PublicKey), err), 1) - } - - txSender, err := wallet.NewPrivateKeyWallet(ethClient, signerV2, signerAddr, logger) - if err != nil { - return cli.Exit(fmt.Sprintf("Failed to create transaction sender for declaring alias of operator %v on eoChain (%v) %v", crypto.PubkeyToAddress(ethEcdsaPair.PublicKey), c.String(flag.EOChainEthRPCFlag.Name), err), 1) - } - txMgr := txmgr.NewSimpleTxManager(txSender, ethClient, logger, signerV2, signerAddr) - - noSendTxOpts, err := txMgr.GetNoSendTxOpts() - if err != nil { - return cli.Exit(fmt.Sprintf("Error creating transaction object %v", err), 1) - } - - tx, err := contractEOConfig.DeclareAlias( - noSendTxOpts, - crypto.PubkeyToAddress(aliasEcdsaPair.PublicKey), - ) - if err != nil { - return cli.Exit(fmt.Sprintf("Failed to create EOConfig.declareAlias transaction %v", err), 1) - } - - ctx := context.Background() - receipt, err := txMgr.Send(ctx, tx) - if err != nil { - return cli.Exit(fmt.Sprintf("declareAlias transaction failed %s", err), 1) - } - - if receipt.Status != 1 { - return cli.Exit(fmt.Sprintf("declareAlias transaction %v for operator %v on Ethereum mainnet/Holesky (%v) reverted", receipt.TxHash.Hex(), crypto.PubkeyToAddress(ethEcdsaPair.PublicKey), c.String(flag.EOChainEthRPCFlag.Name)), 1) - } - - logger.Info("succesfully declared an alias in the eochain", "Ethereum address", crypto.PubkeyToAddress(ethEcdsaPair.PublicKey), "eochain address", crypto.PubkeyToAddress(aliasEcdsaPair.PublicKey), "tx hash", receipt.TxHash.Hex()) - return nil -} - -func RunResetConfiguration(c *cli.Context) error { - passphrase := c.String(flag.PassphraseFlag.Name) - keyStorePath := c.String(flag.KeyStorePathFlag.Name) - - var ecdsaOperatorPair *ecdsa.PrivateKey - var ecdsaAliasPair *ecdsa.PrivateKey - operatorIsEOA := true - var err error - - logger, err := logging.NewZapLogger(logging.Production) - if err != nil { - return cli.Exit(fmt.Sprintf("error creating logger %v", err), 1) - } - - if passphrase == "" || keyStorePath == "" { - return cli.Exit("passphrase and keystore-path are required", 1) - } - ecdsaOperatorPair, err = eigensdkecdsa.ReadKey(filepath.Join(keyStorePath, "ecdsaEncryptedWallet.json"), passphrase) - if err != nil { - return cli.Exit(fmt.Sprintf("Failed to read ecdsaEncryptedWallet.json file %v", err), 1) - } - operatorAddress := crypto.PubkeyToAddress(ecdsaOperatorPair.PublicKey) - - ecdsaAliasPair, err = eigensdkecdsa.ReadKey(filepath.Join(keyStorePath, "ecdsaAliasedEncryptedWallet.json"), passphrase) - if err != nil { - return cli.Exit(fmt.Sprintf("Failed to read ecdsaAliasedEncryptedWallet.json file %v", err), 1) - } - operatorAliasAddress := crypto.PubkeyToAddress(ecdsaAliasPair.PublicKey) - - if c.String(flag.EOChainEthRPCFlag.Name) == "" { - return cli.Exit("eochain-rpc-endpoint is required", 1) - } - - eochainEthClient, err := eth.NewClient(c.String(flag.EOChainEthRPCFlag.Name)) - if err != nil { - return cli.Exit(fmt.Sprintf("Failed to create EOChain Eth client %v %v", c.String(flag.EOChainEthRPCFlag.Name), err), 1) - } - - eochainChainIDBigInt, err := eochainEthClient.ChainID(context.Background()) - if err != nil { - return cli.Exit(fmt.Sprintf("Error getting chainId (%v): %v", c.String(flag.EOChainEthRPCFlag.Name), err), 1) - } - - eoConfigAddr := gethcommon.HexToAddress(c.String(flag.EOConfigAddressFlag.Name)) - contractEOConfig, err := eoconfig.NewEoconfig(eoConfigAddr, eochainEthClient) - if err != nil { - return cli.Exit(fmt.Sprintf("Failed to load EOConfig contract %v", err), 1) - } - - operatorAlias, err := contractEOConfig.OperatorToAlias(&bind.CallOpts{Context: context.Background()}, operatorAddress) - if (err != nil) || (operatorAlias == (gethcommon.Address{})) { - return cli.Exit(fmt.Sprintf("Failed to get operator %v alias %v", operatorAddress, err), 1) - } - logger.Info("operator details", "operator address", operatorAddress.Hex(), "alias address", operatorAliasAddress.Hex(), "operator is EOA", operatorIsEOA) - - if operatorAlias != operatorAliasAddress { - return cli.Exit(fmt.Sprintf("Operator (%v) alias (%v) does not match the expected alias (%v), please contact EO support", operatorAddress.Hex(), operatorAlias.Hex(), operatorAliasAddress.Hex()), 1) - } - - if operatorIsEOA { - balance, err := eochainEthClient.BalanceAt(context.Background(), operatorAddress, nil) - if err != nil { - cli.Exit(fmt.Sprintf("Error while getting the operator (%v) balance %v on eoChain", operatorAddress, err), 1) - } - - if balance.Cmp(big.NewInt(500000000000000000)) > 0 { - returnBalance := balance.Sub(balance, big.NewInt(500000000000000000)) - signerV2, signerAddr, err := signerv2.SignerFromConfig(signerv2.Config{PrivateKey: ecdsaOperatorPair}, eochainChainIDBigInt) - if err != nil { - return cli.Exit(fmt.Sprintf("Error creating the signer function for operator %v on eoChain (%v) %v", crypto.PubkeyToAddress(ecdsaOperatorPair.PublicKey), c.String(flag.EOChainEthRPCFlag.Name), err), 1) - } - - txSender, err := wallet.NewPrivateKeyWallet(eochainEthClient, signerV2, signerAddr, logger) - if err != nil { - return cli.Exit(fmt.Sprintf("Error creating the transaction sender for operator %v on eoChain (%v) %v", crypto.PubkeyToAddress(ecdsaOperatorPair.PublicKey), c.String(flag.EOChainEthRPCFlag.Name), err), 1) - } - txMgr := txmgr.NewSimpleTxManager(txSender, eochainEthClient, logger, signerV2, signerAddr) - txOpts, err := txMgr.GetNoSendTxOpts() - if err != nil { - return cli.Exit(fmt.Sprintf("Error generating transaction for resetting eochain gas balance of operator %v on eoChain (%v) %v", operatorAddress.Hex(), c.String(flag.EOChainEthRPCFlag.Name), err), 1) - } - txOpts.Value = returnBalance - - contractEOConfigRaw := eoconfig.EoconfigRaw{Contract: contractEOConfig} - tx, err := contractEOConfigRaw.Transfer(txOpts) - if err != nil { - return cli.Exit(fmt.Sprintf("Error reseting the operator %v balance on eochain (%v) %v", operatorAddress.Hex(), c.String(flag.EOChainEthRPCFlag.Name), err), 1) - } - - ctx := context.Background() - receipt, err := txMgr.Send(ctx, tx) - if err != nil { - return cli.Exit(fmt.Sprintf("Error sending the reset balance transaction of operator %v on eochain (%v) %v", operatorAddress.Hex(), c.String(flag.EOChainEthRPCFlag.Name), err), 1) - } - - if receipt.Status != 1 { - return cli.Exit(fmt.Sprintf("The transaction %v to reset the operator %v balance on eochain (%v) reverted", receipt.TxHash.Hex(), operatorAddress.Hex(), c.String(flag.EOChainEthRPCFlag.Name)), 1) - } - - balance, err = eochainEthClient.BalanceAt(context.Background(), operatorAddress, nil) - if err != nil { - cli.Exit(fmt.Sprintf("Error while getting the operator (%v) balance %v on eoChain", operatorAddress, err), 1) - } - } - balanceInEth := new(big.Float).Quo(new(big.Float).SetInt(balance), new(big.Float).SetInt(big.NewInt(1e18))) - logger.Info("Operator balance", "operator address", operatorAddress.Hex(), "balance", balanceInEth.String()) - } else { - logger.Info("Operator is not an EOA, skipping reset configuration") - } - - return nil -} - -func buildAVSClient( - registryCoordinatorAddr gethcommon.Address, - ethClient eth.Client, - logger logging.Logger, -) (*avsClient, error) { - - avsClient := &avsClient{ - registryCoordinatorAddr: registryCoordinatorAddr, - } - - registryCoordinator, err := regcoord.NewContractEORegistryCoordinator(registryCoordinatorAddr, ethClient) - if err != nil { - return nil, fmt.Errorf(fmt.Sprintf("Failed to create RegistryCoordinator contract %v", err)) - } - avsClient.registryCoordinator = registryCoordinator - - serviceManagerAddr, err := registryCoordinator.ServiceManager(&bind.CallOpts{}) - if err != nil { - return nil, fmt.Errorf(fmt.Sprintf("Failed to get ServiceManager from registryCoordinator contract %v", err)) - } - avsClient.serviceManagerAddr = serviceManagerAddr - - serviceManager, err := smbase.NewContractServiceManagerBase(serviceManagerAddr, ethClient) - if err != nil { - return nil, fmt.Errorf(fmt.Sprintf("Failed to create serviceManager contract %v", err)) - } - avsClient.serviceManager = serviceManager - - stakeRegistryAddr, err := registryCoordinator.StakeRegistry(&bind.CallOpts{}) - if err != nil { - return nil, fmt.Errorf(fmt.Sprintf("Failed to get stakeRegistryAddr %v", err)) - } - stakeRegistry, err := stakeregistry.NewContractEOStakeRegistry(stakeRegistryAddr, ethClient) - if err != nil { - return nil, fmt.Errorf(fmt.Sprintf("Failed to create stakeRegistry contract %v", err)) - } - avsClient.stakeRegistry = stakeRegistry - - delegationManagerAddr, err := stakeRegistry.Delegation(&bind.CallOpts{}) - if err != nil { - return nil, fmt.Errorf(fmt.Sprintf("Failed to get delegationManagerAddr %v", err)) - } - avsClient.delegationManagerAddr = delegationManagerAddr - - avsDirectoryAddr, err := serviceManager.AvsDirectory(&bind.CallOpts{}) - if err != nil { - return nil, fmt.Errorf(fmt.Sprintf("Failed to get avsDirectoryAddr %v", err)) - } - avsClient.avsDirectoryAddr = avsDirectoryAddr - - elReader, err := elcontracts.BuildELChainReader(delegationManagerAddr, avsDirectoryAddr, ethClient, logger) - if err != nil { - return nil, fmt.Errorf(fmt.Sprintf("Failed to create ELChainReader %v", err)) - } - avsClient.elReader = elReader - - return avsClient, nil -} - -func ConvertBn254GethToGnark(input regcoord.BN254G1Point) *bn254.G1Affine { - return eigensdkbls.NewG1Point(input.X, input.Y).G1Affine -} - -func ConvertToBN254G1Point(input *eigensdkbls.G1Point) regcoord.BN254G1Point { - output := regcoord.BN254G1Point{ - X: input.X.BigInt(big.NewInt(0)), - Y: input.Y.BigInt(big.NewInt(0)), - } - return output -} - -func ConvertToBN254G2Point(input *eigensdkbls.G2Point) regcoord.BN254G2Point { - output := regcoord.BN254G2Point{ - X: [2]*big.Int{input.X.A1.BigInt(big.NewInt(0)), input.X.A0.BigInt(big.NewInt(0))}, - Y: [2]*big.Int{input.Y.A1.BigInt(big.NewInt(0)), input.Y.A0.BigInt(big.NewInt(0))}, - } - return output -} diff --git a/main.go b/main.go new file mode 100644 index 0000000..6fc6742 --- /dev/null +++ b/main.go @@ -0,0 +1,32 @@ +package main + +import ( + "fmt" + "os" + + "github.com/eodata/operator-cli/cmd" + "github.com/urfave/cli/v2" +) + +func main() { + app := cli.NewApp() + app.Name = "operatorCli" + app.Description = "Eoracle generate operator signature and message for registration" + app.Usage = "Used to create operator signature and message for registration" + app.Commands = []*cli.Command{ + cmd.NewEncryptCommand(), + cmd.NewDecryptCommand(), + cmd.NewRegisterCommand(), + cmd.NewDeregisterCommand(), + cmd.NewPrintStatusCommand(), + cmd.NewGenerateBLSKeyCommand(), + cmd.NewGenerateAliasCommand(), + cmd.NewDeclareAliasCommand(), + cmd.NewResetConfigurationCommand(), + } + + if err := app.Run(os.Args); err != nil { + fmt.Println("Error: ", err) + os.Exit(1) + } +}