From a1e7469f7347eda54b67908a931da2d87562f8b9 Mon Sep 17 00:00:00 2001 From: Sulejman Sarajlija <3107367+Sulejman@users.noreply.github.com> Date: Fri, 2 Aug 2024 04:50:21 +0200 Subject: [PATCH] Cold Sync Enabled --- .env.example | 6 + Dockerfile | 28 + README.md | 40 + build-docker.sh | 1 + build.sh | 4 + cmd/main.go | 19 + config/settings.go | 64 + go.mod | 40 + go.sum | 214 ++ pkgs/common/alerts.go | 45 + pkgs/constants.go | 8 + pkgs/contract/abi.json | 2830 +++++++++++++++++ pkgs/contract/contract.go | 6226 +++++++++++++++++++++++++++++++++++++ pkgs/prost/contract.go | 152 + pkgs/redis/client.go | 98 + pkgs/redis/keys.go | 13 + pkgs/utils/logger.go | 48 + run-dev.sh | 17 + run.sh | 1 + 19 files changed, 9854 insertions(+) create mode 100644 .env.example create mode 100644 Dockerfile create mode 100644 README.md create mode 100755 build-docker.sh create mode 100644 build.sh create mode 100644 cmd/main.go create mode 100644 config/settings.go create mode 100644 go.mod create mode 100644 go.sum create mode 100644 pkgs/common/alerts.go create mode 100644 pkgs/constants.go create mode 100644 pkgs/contract/abi.json create mode 100644 pkgs/contract/contract.go create mode 100644 pkgs/prost/contract.go create mode 100644 pkgs/redis/client.go create mode 100644 pkgs/redis/keys.go create mode 100644 pkgs/utils/logger.go create mode 100755 run-dev.sh create mode 100644 run.sh diff --git a/.env.example b/.env.example new file mode 100644 index 0000000..eb5b0c5 --- /dev/null +++ b/.env.example @@ -0,0 +1,6 @@ +PROST_RPC_URL=http://127.0.0.1:8545 +PROTOCOL_STATE_CONTRACT=0xCf7Ed3AccA5a467e9e704C703E8D87F634fB0Fc9 +REDIS_HOST=127.0.0.1 +REDIS_PORT=6379 +DATA_MARKET_ADDRESS=0xCafac3dD18aC6c6e92c921884f9E4176737C052c +SLACK_REPORTING_URL= \ No newline at end of file diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..d7c92a2 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,28 @@ +# Use the official Golang image as the build environment +FROM golang:1.20 as builder + +# Set the working directory inside the container +WORKDIR /app + +# Copy go.mod and go.sum files to the working directory +COPY go.mod go.sum ./ + +# Download the dependencies +RUN go mod download + +# Copy the rest of the application code to the working directory +COPY . . + +# Build the Go application +RUN CGO_ENABLED=0 GOOS=linux go build -o /contract-listener ./cmd/main.go + +# Use a minimal base image +FROM scratch + +# Copy the binary from the builder stage +COPY --from=builder /contract-listener /contract-listener + +# Expose port 9000 + +# Command to run the application +CMD ["/contract-listener"] diff --git a/README.md b/README.md new file mode 100644 index 0000000..d0515ee --- /dev/null +++ b/README.md @@ -0,0 +1,40 @@ +# Libp2p-submission-sequencer-listener Deployment +Scripts to deploy Sequencer-listener + +## Requirements + +1. Latest version of `docker` (`>= 20.10.21`) and `docker-compose` (`>= v2.13.0`) +2. At least 4 core CPU, 8GB RAM and 50GB SSD - make sure to choose the correct spec when deploying to Github Codespaces. + +## Running the Sequencer Node + +Clone the repository against the testnet branch. + +`git clone https://github.com/PowerLoom/libp2p-submission-sequencer-listener.git --single-branch powerloom_sequencer_listener && cd powerloom_sequencer_listener` + + +### Deployment steps + +1. Copy `env.example` to `.env`. + - Ensure the following required variables are filled: + - `RENDEZVOUS_POINT`: The identifier for locating all relayer peers which are the only way to access the sequencer and submit snapshots. + - `PROTOCOL_STATE_CONTRACT`: The contract address for the protocol state. + - `PROST_RPC_URL`: The URL for the PROST RPC service. + - `DATA_MARKET_ADDRESS`: The contract address of data market this listener is for. + + - Optionally, you may also set the following variables: + - `REDIS_HOST` & `REDIS_PORT`: The redis server connection url (if you wish to use a separate one). + - `SLACK_REPORTING_URL`: The reporting url for sending alert notifications. + +2. Build the image + + `./build-docker.sh` + +3. Run the following command (ideally in a `screen`) and follow instructions + + `./run.sh` + +## Troubleshooting +### To be added +### Stopping and Resetting +1. To shutdown services, just press `Ctrl+C` (and again to force).# protocol-state-cacher diff --git a/build-docker.sh b/build-docker.sh new file mode 100755 index 0000000..a2662d3 --- /dev/null +++ b/build-docker.sh @@ -0,0 +1 @@ +docker build -t proto-snapshot-listener . --no-cache diff --git a/build.sh b/build.sh new file mode 100644 index 0000000..ffd97f1 --- /dev/null +++ b/build.sh @@ -0,0 +1,4 @@ +#bash scripts/generate.sh +cd cmd +go build . +#docker-compose -f docker-compose.yaml up diff --git a/cmd/main.go b/cmd/main.go new file mode 100644 index 0000000..51d9fb9 --- /dev/null +++ b/cmd/main.go @@ -0,0 +1,19 @@ +package main + +import ( + "protocol-state-cacher/config" + "protocol-state-cacher/pkgs/prost" + "protocol-state-cacher/pkgs/redis" + "protocol-state-cacher/pkgs/utils" +) + +func main() { + utils.InitLogger() + config.LoadConfig() + + prost.ConfigureClient() + prost.ConfigureContractInstance() + redis.RedisClient = redis.NewRedisClient() + + prost.ColdSync() +} diff --git a/config/settings.go b/config/settings.go new file mode 100644 index 0000000..6b5b183 --- /dev/null +++ b/config/settings.go @@ -0,0 +1,64 @@ +package config + +import ( + log "github.com/sirupsen/logrus" + "os" +) + +var SettingsObj *Settings + +type Settings struct { + ClientUrl string + ContractAddress string + RedisHost string + RedisPort string + SlackReportingUrl string + DataMarketAddress string +} + +func LoadConfig() { + config := Settings{ + ClientUrl: getEnv("PROST_RPC_URL", ""), + ContractAddress: getEnv("PROTOCOL_STATE_CONTRACT", ""), + RedisHost: getEnv("REDIS_HOST", ""), + RedisPort: getEnv("REDIS_PORT", ""), + SlackReportingUrl: getEnv("SLACK_REPORTING_URL", ""), + DataMarketAddress: getEnv("DATA_MARKET_ADDRESS", ""), + } + + // Check for any missing required environment variables and log errors + missingEnvVars := []string{} + if config.ClientUrl == "" { + missingEnvVars = append(missingEnvVars, "PROST_RPC_URL") + } + if config.ContractAddress == "" { + missingEnvVars = append(missingEnvVars, "PROTOCOL_STATE_CONTRACT") + } + if config.DataMarketAddress == "" { + missingEnvVars = append(missingEnvVars, "DATA_MARKET_ADDRESS") + } + + if len(missingEnvVars) > 0 { + log.Fatalf("Missing required environment variables: %v", missingEnvVars) + } + + checkOptionalEnvVar(config.SlackReportingUrl, "SLACK_REPORTING_URL") + checkOptionalEnvVar(config.RedisHost, "REDIS_HOST") + checkOptionalEnvVar(config.RedisPort, "REDIS_PORT") + + SettingsObj = &config +} + +func getEnv(key, defaultValue string) string { + value := os.Getenv(key) + if value == "" { + return defaultValue + } + return value +} + +func checkOptionalEnvVar(value, key string) { + if value == "" { + log.Warnf("Optional environment variable %s is not set", key) + } +} diff --git a/go.mod b/go.mod new file mode 100644 index 0000000..11713a4 --- /dev/null +++ b/go.mod @@ -0,0 +1,40 @@ +module protocol-state-cacher + +go 1.22 + +require ( + github.com/cenkalti/backoff/v4 v4.3.0 + github.com/ethereum/go-ethereum v1.14.7 + github.com/go-redis/redis/v8 v8.11.5 + github.com/sirupsen/logrus v1.9.3 +) + +require ( + github.com/Microsoft/go-winio v0.6.2 // indirect + github.com/StackExchange/wmi v1.2.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.3.0 // indirect + github.com/consensys/bavard v0.1.13 // indirect + github.com/consensys/gnark-crypto v0.12.1 // indirect + github.com/crate-crypto/go-kzg-4844 v1.0.0 // indirect + github.com/deckarep/golang-set/v2 v2.6.0 // indirect + github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1 // indirect + github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect + github.com/ethereum/c-kzg-4844 v1.0.0 // indirect + github.com/fsnotify/fsnotify v1.6.0 // indirect + github.com/go-ole/go-ole v1.3.0 // indirect + github.com/google/uuid v1.3.0 // indirect + github.com/gorilla/websocket v1.4.2 // indirect + github.com/holiman/uint256 v1.3.0 // indirect + github.com/mmcloughlin/addchain v0.4.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 + golang.org/x/crypto v0.22.0 // indirect + golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa // indirect + golang.org/x/sync v0.7.0 // indirect + golang.org/x/sys v0.20.0 // indirect + rsc.io/tmplfunc v0.0.3 // indirect +) diff --git a/go.sum b/go.sum new file mode 100644 index 0000000..3d070fc --- /dev/null +++ b/go.sum @@ -0,0 +1,214 @@ +github.com/DataDog/zstd v1.4.5 h1:EndNeuB0l9syBZhut0wns3gV1hL8zX8LIu6ZiVHWLIQ= +github.com/DataDog/zstd v1.4.5/go.mod h1:1jcaCB/ufaK+sKp1NBhlGmpz41jOoPQ35bpF36t7BBo= +github.com/Microsoft/go-winio v0.6.2 h1:F2VQgta7ecxGYO8k3ZZz3RS8fVIXVxONVUPlNERoyfY= +github.com/Microsoft/go-winio v0.6.2/go.mod h1:yd8OoFMLzJbo9gZq8j5qaps8bJ9aShtEA8Ipt1oGCvU= +github.com/StackExchange/wmi v1.2.1 h1:VIkavFPXSjcnS+O8yTq7NI32k0R5Aj+v39y29VYDOSA= +github.com/StackExchange/wmi v1.2.1/go.mod h1:rcmrprowKIVzvc+NUiLncP2uuArMWLCbu9SBzvHz7e8= +github.com/VictoriaMetrics/fastcache v1.12.2 h1:N0y9ASrJ0F6h0QaC3o6uJb3NIZ9VKLjCM7NQbSmF7WI= +github.com/VictoriaMetrics/fastcache v1.12.2/go.mod h1:AmC+Nzz1+3G2eCPapF6UcsnkThDcMsQicp4xDukwJYI= +github.com/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/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.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= +github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/cockroachdb/errors v1.11.3 h1:5bA+k2Y6r+oz/6Z/RFlNeVCesGARKuC6YymtcDrbC/I= +github.com/cockroachdb/errors v1.11.3/go.mod h1:m4UIW4CDjx+R5cybPsNrRbreomiFqt8o1h1wUVazSd8= +github.com/cockroachdb/fifo v0.0.0-20240606204812-0bbfbd93a7ce h1:giXvy4KSc/6g/esnpM7Geqxka4WSqI1SZc7sMJFd3y4= +github.com/cockroachdb/fifo v0.0.0-20240606204812-0bbfbd93a7ce/go.mod h1:9/y3cnZ5GKakj/H4y9r9GTjCvAFta7KLgSHPJJYc52M= +github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b h1:r6VH0faHjZeQy818SGhaone5OnYfxFR/+AzdY3sf5aE= +github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b/go.mod h1:Vz9DsVWQQhf3vs21MhPMZpMGSht7O/2vFW2xusFUVOs= +github.com/cockroachdb/pebble v1.1.1 h1:XnKU22oiCLy2Xn8vp1re67cXg4SAasg/WDt1NtcRFaw= +github.com/cockroachdb/pebble v1.1.1/go.mod h1:4exszw1r40423ZsmkG/09AFEG83I0uDgfujJdbL6kYU= +github.com/cockroachdb/redact v1.1.5 h1:u1PMllDkdFfPWaNGMyLD1+so+aq3uUItthCFqzwPJ30= +github.com/cockroachdb/redact v1.1.5/go.mod h1:BVNblN9mBWFyMyqK1k3AAiSxhvhfK2oOZZ2lK+dpvRg= +github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06 h1:zuQyyAKVxetITBuuhv3BI9cMrmStnpT18zmgmTxunpo= +github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06/go.mod h1:7nc4anLGjupUW/PeY5qiNYsdNXj7zopG+eqsS7To5IQ= +github.com/consensys/bavard v0.1.13 h1:oLhMLOFGTLdlda/kma4VOJazblc7IM5y5QPd2A/YjhQ= +github.com/consensys/bavard v0.1.13/go.mod h1:9ItSMtA/dXMAiL7BG6bqW2m3NdSEObYWoH223nGHukI= +github.com/consensys/gnark-crypto v0.12.1 h1:lHH39WuuFgVHONRl3J0LRBtuYdQTumFSDtJF7HpyG8M= +github.com/consensys/gnark-crypto v0.12.1/go.mod h1:v2Gy7L/4ZRosZ7Ivs+9SfUDr0f5UlG+EM5t7MPHiLuY= +github.com/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-20240223125850-b1e8a79f509c h1:uQYC5Z1mdLRPrZhHjHxufI8+2UG/i25QG92j0Er9p6I= +github.com/crate-crypto/go-ipa v0.0.0-20240223125850-b1e8a79f509c/go.mod h1:geZJZH3SzKCqnz5VT0q/DyIG/tvu/dZk+VIfXicupJs= +github.com/crate-crypto/go-kzg-4844 v1.0.0 h1:TsSgHwrkTKecKJ4kadtHi4b3xHW5dCFUDFnUp1TsawI= +github.com/crate-crypto/go-kzg-4844 v1.0.0/go.mod h1:1kMhvPgI0Ky3yIa+9lFySEBUBXkYxeOi8ZF1sYioxhc= +github.com/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.6.0 h1:XfcQbWM1LlMB8BsJ8N9vW5ehnnPVIw0je80NsVHagjM= +github.com/deckarep/golang-set/v2 v2.6.0/go.mod h1:VAky9rY/yGXJOLEDv3OMci+7wtDpOF4IN+y82NBOac4= +github.com/decred/dcrd/crypto/blake256 v1.0.0 h1:/8DMNYp9SGi5f0w7uCm6d6M4OU2rGFK09Y2A4Xv7EE0= +github.com/decred/dcrd/crypto/blake256 v1.0.0/go.mod h1:sQl2p6Y26YV+ZOcSTP6thNdn47hh8kt6rqSlvmrXFAc= +github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1 h1:YLtO71vCjJRCBcrPMtQ9nqBsqpA1m5sE92cU+pd5Mcc= +github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1/go.mod h1:hyedUtir6IdtD/7lIxGeCxkaw7y45JueMRL4DIyJDKs= +github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78= +github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc= +github.com/ethereum/c-kzg-4844 v1.0.0 h1:0X1LBXxaEtYD9xsyj9B9ctQEZIpnvVDeoBx8aHEwTNA= +github.com/ethereum/c-kzg-4844 v1.0.0/go.mod h1:VewdlzQmpT5QSrVhbBuGoCdFJkpaJlO1aQputP83wc0= +github.com/ethereum/go-ethereum v1.14.7 h1:EHpv3dE8evQmpVEQ/Ne2ahB06n2mQptdwqaMNhAT29g= +github.com/ethereum/go-ethereum v1.14.7/go.mod h1:Mq0biU2jbdmKSZoqOj29017ygFrMnB5/Rifwp980W4o= +github.com/ethereum/go-verkle v0.1.1-0.20240306133620-7d920df305f0 h1:KrE8I4reeVvf7C1tm8elRjj4BdscTYzz/WAbYyf/JI4= +github.com/ethereum/go-verkle v0.1.1-0.20240306133620-7d920df305f0/go.mod h1:D9AJLVXSyZQXJQVk8oh1EwjISE+sJTn2duYIZC0dy3w= +github.com/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/getsentry/sentry-go v0.27.0 h1:Pv98CIbtB3LkMWmXi4Joa5OOcwbmnX88sF5qbK3r3Ps= +github.com/getsentry/sentry-go v0.27.0/go.mod h1:lc76E2QywIyW8WuBnwl8Lc4bkmQH4+w1gwTf25trprY= +github.com/go-ole/go-ole v1.2.5/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0= +github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE= +github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78= +github.com/go-redis/redis/v8 v8.11.5 h1:AcZZR7igkdvfVmQTPnu9WE37LRrO/YrBH5zWyjDC0oI= +github.com/go-redis/redis/v8 v8.11.5/go.mod h1:gREzHqY1hg6oD9ngVRbLStwAWKhA0FEgq8Jd4h5lpwo= +github.com/gofrs/flock v0.8.1 h1:+gYjHKf32LDeiEEFhQaotPbLuUXjY5ZqxKgXy7n59aw= +github.com/gofrs/flock v0.8.1/go.mod h1:F1TvTiK9OcQqauNUHlbJvyl9Qa1QvF/gOUDKA14jxHU= +github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= +github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= +github.com/golang-jwt/jwt/v4 v4.5.0 h1:7cYmW1XlMY7h7ii7UhUyChSgS5wUJEnm9uZVTGqOWzg= +github.com/golang-jwt/jwt/v4 v4.5.0/go.mod h1:m21LjoU+eqJr34lmDMbreY2eSTRJ1cv77w39/MY0Ch0= +github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek= +github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps= +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/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.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I= +github.com/google/uuid v1.3.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/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.3.0 h1:4wdcm/tnd0xXdu7iS3ruNvxkWwrb4aeBQv19ayYn8F4= +github.com/holiman/uint256 v1.3.0/go.mod h1:EOMSn4q6Nyt9P6efbI3bueV4e1b3dGlUCXeiRV4ng7E= +github.com/huin/goupnp v1.3.0 h1:UvLUlWDNpoUdYzb2TCn+MuTWtcjXKSza2n6CBdQ0xXc= +github.com/huin/goupnp v1.3.0/go.mod h1:gnGPsThkYa7bFi/KWmEysQRf48l2dvR5bxr2OFckNX8= +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/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.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.13 h1:lTGmDsbAYt5DmK6OnoV7EuIF1wEIFAcxld6ypU4OSgU= +github.com/mattn/go-runewidth v0.0.13/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w= +github.com/matttproud/golang_protobuf_extensions v1.0.2-0.20181231171920-c182affec369 h1:I0XW9+e1XWDxdcEniV4rQAIOPUGDq67JSCiRCgGCZLI= +github.com/matttproud/golang_protobuf_extensions v1.0.2-0.20181231171920-c182affec369/go.mod h1:BSXmuO+STAnVfrANrmjBb36TMTDstsz7MSK+HVaYKv4= +github.com/mitchellh/mapstructure v1.4.1 h1:CpVNEelQCZBooIPDn+AR3NpivK/TIKU8bDxdASFVQag= +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/nxadm/tail v1.4.8 h1:nPr65rt6Y5JFSKQO7qToXr7pePgD6Gwiw05lkbyAQTE= +github.com/nxadm/tail v1.4.8/go.mod h1:+ncqLTQzXmGhMZNUePPaPqPvBxHAIsmXswZKocGu+AU= +github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec= +github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY= +github.com/onsi/ginkgo v1.16.5 h1:8xi0RTUf59SOSfEtZMvwTvXYMzG4gV23XVHOZiXNtnE= +github.com/onsi/ginkgo v1.16.5/go.mod h1:+E8gABHa3K6zRBolWtd+ROzc/U5bkGt0FwiG042wbpU= +github.com/onsi/gomega v1.18.1 h1:M1GfJqGRrBrrGGsbxzV5dqM2U2ApXefZCQpkukxYRLE= +github.com/onsi/gomega v1.18.1/go.mod h1:0q+aL8jAiMXy9hbwj2mr5GziHiwhAIQpFmmtT5hitRs= +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.12.0 h1:C+UIj/QWtmqY13Arb8kwMt5j34/0Z2iKamrJ+ryC0Gg= +github.com/prometheus/client_golang v1.12.0/go.mod h1:3Z9XVyYiZYEO+YQWt3RD2R3jrbd179Rt297l4aS6nDY= +github.com/prometheus/client_model v0.2.1-0.20210607210712-147c58e9608a h1:CmF68hwI0XsOQ5UwlBopMi2Ow4Pbg32akc4KIVCOm+Y= +github.com/prometheus/client_model v0.2.1-0.20210607210712-147c58e9608a/go.mod h1:LDGWKZIo7rky3hgvBe+caln+Dr3dPggB5dvjtD7w9+w= +github.com/prometheus/common v0.32.1 h1:hWIdL3N2HoUx3B8j3YN9mWor0qhY/NlEKZEaXxuIRh4= +github.com/prometheus/common v0.32.1/go.mod h1:vu+V0TpY+O6vW9J44gczi3Ap/oXXR10b+M/gUGO4Hls= +github.com/prometheus/procfs v0.7.3 h1:4jVXhlkAyzOScmCkXBTOLRLTz8EeU+eyjrwB/EPq0VU= +github.com/prometheus/procfs v0.7.3/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA= +github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY= +github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= +github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8= +github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs= +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/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/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ= +github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ= +github.com/status-im/keycard-go v0.2.0 h1:QDLFswOQu1r5jsycloeQh3bVU8n/NatHHaZobtDnDzA= +github.com/status-im/keycard-go v0.2.0/go.mod h1:wlp8ZLbsmrF6g6WjugPAx+IzoLrkdf9+mHxBEeo3Hbg= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +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/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.25.7 h1:VAzn5oq403l5pHjc4OhD54+XGO9cdKVL/7lDjF+iKUs= +github.com/urfave/cli/v2 v2.25.7/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= +golang.org/x/crypto v0.22.0 h1:g1v0xeRhjcugydODzvb3mEM9SQ0HGp9s/nh3COQ/C30= +golang.org/x/crypto v0.22.0/go.mod h1:vr6Su+7cTlO45qkww3VDJlzDn0ctJvRgYbC2NvXHt+M= +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/net v0.24.0 h1:1PcaxkF854Fu3+lvBIx5SYn9wRlBzzcnHZSiaFFAb0w= +golang.org/x/net v0.24.0/go.mod h1:2Q7sJY5mzlzWjKtYUEXSlBWCdyaioyXzRB2RtU8KVE8= +golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M= +golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= +golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20220908164124-27713097b956/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.1.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.20.0 h1:Od9JTbYCk261bKm4M/mw7AklTlFYIa0bIp9BgSm1S8Y= +golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ= +golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= +golang.org/x/time v0.5.0 h1:o7cqy6amK/52YcAKIPlM3a+Fpj35zvRj2TP+e1xFSfk= +golang.org/x/time v0.5.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM= +google.golang.org/protobuf v1.33.0 h1:uNO2rsAINq/JlFpSdYEKIZ0uKD/R9cpdv0T+yoGwGmI= +google.golang.org/protobuf v1.33.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +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.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/pkgs/common/alerts.go b/pkgs/common/alerts.go new file mode 100644 index 0000000..6e60802 --- /dev/null +++ b/pkgs/common/alerts.go @@ -0,0 +1,45 @@ +package common + +import ( + "fmt" + log "github.com/sirupsen/logrus" +) + +//{ +// "timestamp": "Example text", +// "process_name": "Example text", +// "error_msg": "Example text", +// "severity": "Example text" +//} + +type SequencerAlert struct { + ProcessName string `json:"process_name"` + ErrorMsg string `json:"error_msg"` + Timestamp string `json:"timestamp"` + Severity string `json:"severity"` +} + +func (s SequencerAlert) String() string { + return fmt.Sprintf("ProcessName: %s, ErrorMsg: %s, Timestamp: %s, Severity: %s", + s.ProcessName, s.ErrorMsg, s.Timestamp, s.Severity) +} + +// These issues should not be common but best to allow high volumes +var SequencerAlertsChannel = make(chan SequencerAlert, 10000) + +func SendFailureNotification(processName, errorMsg, timestamp, severity string) { + var issue SequencerAlert + issue = SequencerAlert{ + processName, + errorMsg, + timestamp, + severity, + } + + select { + case SequencerAlertsChannel <- issue: + log.Debugln("Issue sent to channel: ", issue) + default: + log.Errorln("Issue channel is full, dropping issue: ", issue) + } +} diff --git a/pkgs/constants.go b/pkgs/constants.go new file mode 100644 index 0000000..e2a9238 --- /dev/null +++ b/pkgs/constants.go @@ -0,0 +1,8 @@ +package pkgs + +const ( + CurrentEpoch = "CurrentEpoch" + CurrentBatchId = "CurrentBatchId" + EpochsInADay = "EpochsInADay" + SlotCounter = "SlotCounter" +) diff --git a/pkgs/contract/abi.json b/pkgs/contract/abi.json new file mode 100644 index 0000000..9ca9721 --- /dev/null +++ b/pkgs/contract/abi.json @@ -0,0 +1,2830 @@ +[ + { + "inputs": [], + "stateMutability": "nonpayable", + "type": "constructor" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "target", + "type": "address" + } + ], + "name": "AddressEmptyCode", + "type": "error" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "implementation", + "type": "address" + } + ], + "name": "ERC1967InvalidImplementation", + "type": "error" + }, + { + "inputs": [], + "name": "ERC1967NonPayable", + "type": "error" + }, + { + "inputs": [], + "name": "FailedInnerCall", + "type": "error" + }, + { + "inputs": [], + "name": "InvalidInitialization", + "type": "error" + }, + { + "inputs": [], + "name": "NotInitializing", + "type": "error" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "owner", + "type": "address" + } + ], + "name": "OwnableInvalidOwner", + "type": "error" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "OwnableUnauthorizedAccount", + "type": "error" + }, + { + "inputs": [], + "name": "UUPSUnauthorizedCallContext", + "type": "error" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "slot", + "type": "bytes32" + } + ], + "name": "UUPSUnsupportedProxiableUUID", + "type": "error" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "dataMarketAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "adminAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "bool", + "name": "allowed", + "type": "bool" + } + ], + "name": "AdminsUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "dataMarketAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "uint256", + "name": "epochId", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "timestamp", + "type": "uint256" + } + ], + "name": "BatchSubmissionsCompleted", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "dataMarketAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "snapshotterAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "slotId", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "dayId", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "timestamp", + "type": "uint256" + } + ], + "name": "DailyTaskCompletedEvent", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "ownerAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint8", + "name": "epochSize", + "type": "uint8" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "sourceChainId", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "sourceChainBlockTime", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "bool", + "name": "useBlockNumberAsEpochId", + "type": "bool" + }, + { + "indexed": false, + "internalType": "address", + "name": "protocolState", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "dataMarketAddress", + "type": "address" + } + ], + "name": "DataMarketCreated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "dataMarketAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "dayId", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "timestamp", + "type": "uint256" + } + ], + "name": "DayStartedEvent", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "dataMarketAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "batchId", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "uint256", + "name": "epochId", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "timestamp", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "validatorAddr", + "type": "address" + } + ], + "name": "DelayedAttestationSubmitted", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "dataMarketAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "batchId", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "string", + "name": "batchCid", + "type": "string" + }, + { + "indexed": true, + "internalType": "uint256", + "name": "epochId", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "timestamp", + "type": "uint256" + } + ], + "name": "DelayedBatchSubmitted", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "dataMarketAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "snapshotterAddr", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "slotId", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "string", + "name": "snapshotCid", + "type": "string" + }, + { + "indexed": true, + "internalType": "uint256", + "name": "epochId", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "string", + "name": "projectId", + "type": "string" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "timestamp", + "type": "uint256" + } + ], + "name": "DelayedSnapshotSubmitted", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "dataMarketAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "uint256", + "name": "epochId", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "begin", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "end", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "timestamp", + "type": "uint256" + } + ], + "name": "EpochReleased", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "uint64", + "name": "version", + "type": "uint64" + } + ], + "name": "Initialized", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "previousOwner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "OwnershipTransferred", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "dataMarketAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "string", + "name": "projectType", + "type": "string" + }, + { + "indexed": false, + "internalType": "bool", + "name": "allowed", + "type": "bool" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "enableEpochId", + "type": "uint256" + } + ], + "name": "ProjectTypeUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "dataMarketAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "string[]", + "name": "projects", + "type": "string[]" + }, + { + "indexed": false, + "internalType": "bool[]", + "name": "status", + "type": "bool[]" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "enableEpochId", + "type": "uint256" + } + ], + "name": "ProjectsUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "dataMarketAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "sequencerAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "bool", + "name": "allowed", + "type": "bool" + } + ], + "name": "SequencersUpdated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "dataMarketAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "batchId", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "uint256", + "name": "epochId", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "timestamp", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "validatorAddr", + "type": "address" + } + ], + "name": "SnapshotBatchAttestationSubmitted", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "dataMarketAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "uint256", + "name": "epochId", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "uint256", + "name": "batchId", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "timestamp", + "type": "uint256" + } + ], + "name": "SnapshotBatchFinalized", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "dataMarketAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "batchId", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "string", + "name": "batchCid", + "type": "string" + }, + { + "indexed": true, + "internalType": "uint256", + "name": "epochId", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "timestamp", + "type": "uint256" + } + ], + "name": "SnapshotBatchSubmitted", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "dataMarketAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "uint256", + "name": "epochId", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "epochEnd", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "string", + "name": "projectId", + "type": "string" + }, + { + "indexed": false, + "internalType": "string", + "name": "snapshotCid", + "type": "string" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "timestamp", + "type": "uint256" + } + ], + "name": "SnapshotFinalized", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "dataMarketAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "uint256", + "name": "epochId", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "uint256", + "name": "batchId", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "timestamp", + "type": "uint256" + } + ], + "name": "TriggerBatchResubmission", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "implementation", + "type": "address" + } + ], + "name": "Upgraded", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "dataMarketAddress", + "type": "address" + }, + { + "indexed": true, + "internalType": "uint256", + "name": "epochId", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "uint256", + "name": "batchId", + "type": "uint256" + }, + { + "indexed": false, + "internalType": "address", + "name": "validator", + "type": "address" + }, + { + "indexed": false, + "internalType": "uint256", + "name": "timestamp", + "type": "uint256" + } + ], + "name": "ValidatorAttestationsInvalidated", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "dataMarketAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "validatorAddress", + "type": "address" + }, + { + "indexed": false, + "internalType": "bool", + "name": "allowed", + "type": "bool" + } + ], + "name": "ValidatorsUpdated", + "type": "event" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + } + ], + "name": "EPOCH_SIZE", + "outputs": [ + { + "internalType": "uint8", + "name": "", + "type": "uint8" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + } + ], + "name": "SOURCE_CHAIN_BLOCK_TIME", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + } + ], + "name": "SOURCE_CHAIN_ID", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "UPGRADE_INTERFACE_VERSION", + "outputs": [ + { + "internalType": "string", + "name": "", + "type": "string" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + } + ], + "name": "USE_BLOCK_NUMBER_AS_EPOCH_ID", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "addr", + "type": "address" + } + ], + "name": "allSnapshotters", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + }, + { + "internalType": "string", + "name": "projectType", + "type": "string" + } + ], + "name": "allowedProjectTypes", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256[]", + "name": "_slotIds", + "type": "uint256[]" + }, + { + "internalType": "address[]", + "name": "_snapshotterAddresses", + "type": "address[]" + } + ], + "name": "assignSnapshotterToSlots", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + } + ], + "name": "attestationSubmissionWindow", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + }, + { + "internalType": "uint256", + "name": "batchId", + "type": "uint256" + }, + { + "internalType": "address", + "name": "validator", + "type": "address" + } + ], + "name": "attestationsReceived", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + }, + { + "internalType": "uint256", + "name": "batchId", + "type": "uint256" + }, + { + "internalType": "bytes32", + "name": "finalizedCidsRootHash", + "type": "bytes32" + } + ], + "name": "attestationsReceivedCount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + }, + { + "internalType": "uint256", + "name": "batchId", + "type": "uint256" + } + ], + "name": "batchIdAttestationStatus", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + }, + { + "internalType": "uint256", + "name": "batchId", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "idx", + "type": "uint256" + } + ], + "name": "batchIdDivergentValidators", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + }, + { + "internalType": "uint256", + "name": "batchId", + "type": "uint256" + } + ], + "name": "batchIdSequencerAttestation", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + }, + { + "internalType": "uint256", + "name": "batchId", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "idx", + "type": "uint256" + } + ], + "name": "batchIdToProjects", + "outputs": [ + { + "internalType": "string", + "name": "", + "type": "string" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + } + ], + "name": "batchSubmissionWindow", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + }, + { + "internalType": "uint256", + "name": "batchId", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "epochId", + "type": "uint256" + } + ], + "name": "checkDynamicConsensusAttestations", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + }, + { + "internalType": "uint256", + "name": "slotId", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "day", + "type": "uint256" + } + ], + "name": "checkSlotTaskStatusForDay", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "ownerAddress", + "type": "address" + }, + { + "internalType": "uint8", + "name": "epochSize", + "type": "uint8" + }, + { + "internalType": "uint256", + "name": "sourceChainId", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "sourceChainBlockTime", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "useBlockNumberAsEpochId", + "type": "bool" + } + ], + "name": "createDataMarket", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + } + ], + "name": "currentBatchId", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + } + ], + "name": "currentEpoch", + "outputs": [ + { + "internalType": "uint256", + "name": "begin", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "end", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "epochId", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + } + ], + "name": "dailySnapshotQuota", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "dataMarketCount", + "outputs": [ + { + "internalType": "uint8", + "name": "", + "type": "uint8" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "dataMarketAddress", + "type": "address" + } + ], + "name": "dataMarketEnabled", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "dataMarketFactory", + "outputs": [ + { + "internalType": "contract DataMarketFactory", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint8", + "name": "dataMarketId", + "type": "uint8" + } + ], + "name": "dataMarketIdToAddress", + "outputs": [ + { + "internalType": "address", + "name": "dataMarketAddress", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "name": "dataMarkets", + "outputs": [ + { + "internalType": "address", + "name": "ownerAddress", + "type": "address" + }, + { + "internalType": "uint8", + "name": "epochSize", + "type": "uint8" + }, + { + "internalType": "uint256", + "name": "sourceChainId", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "sourceChainBlockTime", + "type": "uint256" + }, + { + "internalType": "bool", + "name": "useBlockNumberAsEpochId", + "type": "bool" + }, + { + "internalType": "bool", + "name": "enabled", + "type": "bool" + }, + { + "internalType": "address", + "name": "dataMarketAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "createdAt", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + } + ], + "name": "dayCounter", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + } + ], + "name": "deploymentBlockNumber", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + }, + { + "internalType": "uint256", + "name": "epochId", + "type": "uint256" + } + ], + "name": "endBatchSubmissions", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + }, + { + "internalType": "uint256", + "name": "epochId", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "idx", + "type": "uint256" + } + ], + "name": "epochIdToBatchIds", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + }, + { + "internalType": "uint256", + "name": "epochId", + "type": "uint256" + } + ], + "name": "epochInfo", + "outputs": [ + { + "internalType": "uint256", + "name": "timestamp", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "blocknumber", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "epochEnd", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + } + ], + "name": "epochManager", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + } + ], + "name": "epochsInADay", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + }, + { + "internalType": "uint256", + "name": "batchId", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "epochId", + "type": "uint256" + } + ], + "name": "forceCompleteConsensusAttestations", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + }, + { + "internalType": "uint256", + "name": "begin", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "end", + "type": "uint256" + } + ], + "name": "forceSkipEpoch", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + } + ], + "name": "getEpochManager", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + } + ], + "name": "getSequencerId", + "outputs": [ + { + "internalType": "string", + "name": "", + "type": "string" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + } + ], + "name": "getSequencers", + "outputs": [ + { + "internalType": "address[]", + "name": "", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + }, + { + "internalType": "uint256", + "name": "slotId", + "type": "uint256" + } + ], + "name": "getSlotInfo", + "outputs": [ + { + "components": [ + { + "internalType": "uint256", + "name": "slotId", + "type": "uint256" + }, + { + "internalType": "address", + "name": "snapshotterAddress", + "type": "address" + }, + { + "internalType": "uint256", + "name": "rewardPoints", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "currentDaySnapshotCount", + "type": "uint256" + } + ], + "internalType": "struct PowerloomDataMarket.SlotInfo", + "name": "", + "type": "tuple" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "slotId", + "type": "uint256" + } + ], + "name": "getSlotRewards", + "outputs": [ + { + "internalType": "uint256", + "name": "rewards", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + } + ], + "name": "getTotalSequencersCount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "getTotalSnapshotterCount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + } + ], + "name": "getTotalValidatorsCount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + } + ], + "name": "getValidators", + "outputs": [ + { + "internalType": "address[]", + "name": "", + "type": "address[]" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "initialOwner", + "type": "address" + } + ], + "name": "initialize", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + }, + { + "internalType": "string", + "name": "projectId", + "type": "string" + } + ], + "name": "lastFinalizedSnapshot", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + }, + { + "internalType": "uint256", + "name": "_dayCounter", + "type": "uint256" + } + ], + "name": "loadCurrentDay", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + }, + { + "internalType": "uint256", + "name": "slotId", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "dayId", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "snapshotCount", + "type": "uint256" + } + ], + "name": "loadSlotSubmissions", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + }, + { + "internalType": "uint256", + "name": "batchId", + "type": "uint256" + } + ], + "name": "maxAttestationFinalizedRootHash", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + }, + { + "internalType": "uint256", + "name": "batchId", + "type": "uint256" + } + ], + "name": "maxAttestationsCount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + }, + { + "internalType": "string", + "name": "projectId", + "type": "string" + }, + { + "internalType": "uint256", + "name": "epochId", + "type": "uint256" + } + ], + "name": "maxSnapshotsCid", + "outputs": [ + { + "internalType": "string", + "name": "", + "type": "string" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + } + ], + "name": "minAttestationsForConsensus", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + } + ], + "name": "minSubmissionsForConsensus", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "owner", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + }, + { + "internalType": "string", + "name": "projectId", + "type": "string" + } + ], + "name": "projectFirstEpochId", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "proxiableUUID", + "outputs": [ + { + "internalType": "bytes32", + "name": "", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + }, + { + "internalType": "uint256", + "name": "begin", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "end", + "type": "uint256" + } + ], + "name": "releaseEpoch", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "renounceOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + } + ], + "name": "rewardBasePoints", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + } + ], + "name": "rewardsEnabled", + "outputs": [ + { + "internalType": "bool", + "name": "", + "type": "bool" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + }, + { + "internalType": "string", + "name": "_sequencerId", + "type": "string" + } + ], + "name": "setSequencerId", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "slotCounter", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + }, + { + "internalType": "uint256", + "name": "slotId", + "type": "uint256" + } + ], + "name": "slotRewardPoints", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "name": "slotRewards", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "slotId", + "type": "uint256" + } + ], + "name": "slotSnapshotterMapping", + "outputs": [ + { + "internalType": "address", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + }, + { + "internalType": "uint256", + "name": "slotId", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "dayId", + "type": "uint256" + } + ], + "name": "slotSubmissionCount", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + }, + { + "internalType": "string", + "name": "projectId", + "type": "string" + }, + { + "internalType": "uint256", + "name": "epochId", + "type": "uint256" + } + ], + "name": "snapshotStatus", + "outputs": [ + { + "internalType": "enum PowerloomDataMarket.SnapshotStatus", + "name": "status", + "type": "uint8" + }, + { + "internalType": "string", + "name": "snapshotCid", + "type": "string" + }, + { + "internalType": "uint256", + "name": "timestamp", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + } + ], + "name": "snapshotSubmissionWindow", + "outputs": [ + { + "internalType": "uint256", + "name": "", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "snapshotterState", + "outputs": [ + { + "internalType": "contract SnapshotterState", + "name": "", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + }, + { + "internalType": "uint256", + "name": "batchId", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "epochId", + "type": "uint256" + }, + { + "internalType": "bytes32", + "name": "finalizedCidsRootHash", + "type": "bytes32" + } + ], + "name": "submitBatchAttestation", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + }, + { + "internalType": "uint256", + "name": "slotId", + "type": "uint256" + }, + { + "internalType": "string", + "name": "snapshotCid", + "type": "string" + }, + { + "internalType": "uint256", + "name": "epochId", + "type": "uint256" + }, + { + "internalType": "string", + "name": "projectId", + "type": "string" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "slotId", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "deadline", + "type": "uint256" + }, + { + "internalType": "string", + "name": "snapshotCid", + "type": "string" + }, + { + "internalType": "uint256", + "name": "epochId", + "type": "uint256" + }, + { + "internalType": "string", + "name": "projectId", + "type": "string" + } + ], + "internalType": "struct PowerloomDataMarket.Request", + "name": "request", + "type": "tuple" + }, + { + "internalType": "bytes", + "name": "signature", + "type": "bytes" + } + ], + "name": "submitSnapshot", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + }, + { + "internalType": "string", + "name": "batchCid", + "type": "string" + }, + { + "internalType": "uint256", + "name": "batchId", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "epochId", + "type": "uint256" + }, + { + "internalType": "string[]", + "name": "projectIds", + "type": "string[]" + }, + { + "internalType": "string[]", + "name": "snapshotCids", + "type": "string[]" + }, + { + "internalType": "bytes32", + "name": "finalizedCidsRootHash", + "type": "bytes32" + } + ], + "name": "submitSubmissionBatch", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "dataMarketAddress", + "type": "address" + }, + { + "internalType": "bool", + "name": "enabled", + "type": "bool" + } + ], + "name": "toggleDataMarket", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + } + ], + "name": "toggleFallback", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + } + ], + "name": "toggleRewards", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + }, + { + "internalType": "enum PowerloomDataMarket.Role", + "name": "role", + "type": "uint8" + }, + { + "internalType": "address[]", + "name": "_addresses", + "type": "address[]" + }, + { + "internalType": "bool[]", + "name": "_status", + "type": "bool[]" + } + ], + "name": "updateAddresses", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + }, + { + "internalType": "string", + "name": "_projectType", + "type": "string" + }, + { + "internalType": "bool", + "name": "_status", + "type": "bool" + } + ], + "name": "updateAllowedProjectType", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + }, + { + "internalType": "uint256", + "name": "newattestationSubmissionWindow", + "type": "uint256" + } + ], + "name": "updateAttestationSubmissionWindow", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + }, + { + "internalType": "uint256", + "name": "newbatchSubmissionWindow", + "type": "uint256" + } + ], + "name": "updateBatchSubmissionWindow", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + }, + { + "internalType": "uint256", + "name": "dailySnapshotQuota", + "type": "uint256" + } + ], + "name": "updateDailySnapshotQuota", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_address", + "type": "address" + } + ], + "name": "updateDataMarketFactory", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + }, + { + "internalType": "address", + "name": "_address", + "type": "address" + } + ], + "name": "updateEpochManager", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + }, + { + "internalType": "address[]", + "name": "_fallbackNodes", + "type": "address[]" + }, + { + "internalType": "bool[]", + "name": "_status", + "type": "bool[]" + } + ], + "name": "updateFallbackNodes", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + }, + { + "internalType": "uint256", + "name": "_minAttestationsForConsensus", + "type": "uint256" + } + ], + "name": "updateMinAttestationsForConsensus", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + }, + { + "internalType": "uint256", + "name": "_minSubmissionsForConsensus", + "type": "uint256" + } + ], + "name": "updateMinSnapshottersForConsensus", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + }, + { + "internalType": "string[]", + "name": "_projects", + "type": "string[]" + }, + { + "internalType": "bool[]", + "name": "_status", + "type": "bool[]" + } + ], + "name": "updateProjects", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + }, + { + "internalType": "uint256", + "name": "newRewardBasePoints", + "type": "uint256" + } + ], + "name": "updateRewardBasePoints", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + }, + { + "internalType": "uint256[]", + "name": "slotIds", + "type": "uint256[]" + }, + { + "internalType": "uint256[]", + "name": "submissionsList", + "type": "uint256[]" + }, + { + "internalType": "uint256", + "name": "day", + "type": "uint256" + } + ], + "name": "updateRewards", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "contract PowerloomDataMarket", + "name": "dataMarket", + "type": "address" + }, + { + "internalType": "uint256", + "name": "newsnapshotSubmissionWindow", + "type": "uint256" + } + ], + "name": "updateSnapshotSubmissionWindow", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "_address", + "type": "address" + } + ], + "name": "updateSnapshotterState", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "newImplementation", + "type": "address" + }, + { + "internalType": "bytes", + "name": "data", + "type": "bytes" + } + ], + "name": "upgradeToAndCall", + "outputs": [], + "stateMutability": "payable", + "type": "function" + } +] \ No newline at end of file diff --git a/pkgs/contract/contract.go b/pkgs/contract/contract.go new file mode 100644 index 0000000..6e74a70 --- /dev/null +++ b/pkgs/contract/contract.go @@ -0,0 +1,6226 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package contract + +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 +) + +// PowerloomDataMarketRequest is an auto generated low-level Go binding around an user-defined struct. +type PowerloomDataMarketRequest struct { + SlotId *big.Int + Deadline *big.Int + SnapshotCid string + EpochId *big.Int + ProjectId string +} + +// PowerloomDataMarketSlotInfo is an auto generated low-level Go binding around an user-defined struct. +type PowerloomDataMarketSlotInfo struct { + SlotId *big.Int + SnapshotterAddress common.Address + RewardPoints *big.Int + CurrentDaySnapshotCount *big.Int +} + +// ContractMetaData contains all meta data concerning the Contract contract. +var ContractMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"AddressEmptyCode\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"ERC1967InvalidImplementation\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ERC1967NonPayable\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FailedInnerCall\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidInitialization\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotInitializing\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"OwnableInvalidOwner\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"OwnableUnauthorizedAccount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"UUPSUnauthorizedCallContext\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"slot\",\"type\":\"bytes32\"}],\"name\":\"UUPSUnsupportedProxiableUUID\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"dataMarketAddress\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"adminAddress\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"allowed\",\"type\":\"bool\"}],\"name\":\"AdminsUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"dataMarketAddress\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"epochId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"timestamp\",\"type\":\"uint256\"}],\"name\":\"BatchSubmissionsCompleted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"dataMarketAddress\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"snapshotterAddress\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"slotId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"dayId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"timestamp\",\"type\":\"uint256\"}],\"name\":\"DailyTaskCompletedEvent\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"ownerAddress\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"epochSize\",\"type\":\"uint8\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"sourceChainId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"sourceChainBlockTime\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"useBlockNumberAsEpochId\",\"type\":\"bool\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"protocolState\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"dataMarketAddress\",\"type\":\"address\"}],\"name\":\"DataMarketCreated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"dataMarketAddress\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"dayId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"timestamp\",\"type\":\"uint256\"}],\"name\":\"DayStartedEvent\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"dataMarketAddress\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"batchId\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"epochId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"timestamp\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"validatorAddr\",\"type\":\"address\"}],\"name\":\"DelayedAttestationSubmitted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"dataMarketAddress\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"batchId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"batchCid\",\"type\":\"string\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"epochId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"timestamp\",\"type\":\"uint256\"}],\"name\":\"DelayedBatchSubmitted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"dataMarketAddress\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"snapshotterAddr\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"slotId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"snapshotCid\",\"type\":\"string\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"epochId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"projectId\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"timestamp\",\"type\":\"uint256\"}],\"name\":\"DelayedSnapshotSubmitted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"dataMarketAddress\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"epochId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"begin\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"end\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"timestamp\",\"type\":\"uint256\"}],\"name\":\"EpochReleased\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"version\",\"type\":\"uint64\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"dataMarketAddress\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"projectType\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"allowed\",\"type\":\"bool\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"enableEpochId\",\"type\":\"uint256\"}],\"name\":\"ProjectTypeUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"dataMarketAddress\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"string[]\",\"name\":\"projects\",\"type\":\"string[]\"},{\"indexed\":false,\"internalType\":\"bool[]\",\"name\":\"status\",\"type\":\"bool[]\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"enableEpochId\",\"type\":\"uint256\"}],\"name\":\"ProjectsUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"dataMarketAddress\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sequencerAddress\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"allowed\",\"type\":\"bool\"}],\"name\":\"SequencersUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"dataMarketAddress\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"batchId\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"epochId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"timestamp\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"validatorAddr\",\"type\":\"address\"}],\"name\":\"SnapshotBatchAttestationSubmitted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"dataMarketAddress\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"epochId\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"batchId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"timestamp\",\"type\":\"uint256\"}],\"name\":\"SnapshotBatchFinalized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"dataMarketAddress\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"batchId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"batchCid\",\"type\":\"string\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"epochId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"timestamp\",\"type\":\"uint256\"}],\"name\":\"SnapshotBatchSubmitted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"dataMarketAddress\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"epochId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"epochEnd\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"projectId\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"snapshotCid\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"timestamp\",\"type\":\"uint256\"}],\"name\":\"SnapshotFinalized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"dataMarketAddress\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"epochId\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"batchId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"timestamp\",\"type\":\"uint256\"}],\"name\":\"TriggerBatchResubmission\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"dataMarketAddress\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"epochId\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"batchId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"validator\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"timestamp\",\"type\":\"uint256\"}],\"name\":\"ValidatorAttestationsInvalidated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"dataMarketAddress\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"validatorAddress\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"allowed\",\"type\":\"bool\"}],\"name\":\"ValidatorsUpdated\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"}],\"name\":\"EPOCH_SIZE\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"}],\"name\":\"SOURCE_CHAIN_BLOCK_TIME\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"}],\"name\":\"SOURCE_CHAIN_ID\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"UPGRADE_INTERFACE_VERSION\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"}],\"name\":\"USE_BLOCK_NUMBER_AS_EPOCH_ID\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"}],\"name\":\"allSnapshotters\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"projectType\",\"type\":\"string\"}],\"name\":\"allowedProjectTypes\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256[]\",\"name\":\"_slotIds\",\"type\":\"uint256[]\"},{\"internalType\":\"address[]\",\"name\":\"_snapshotterAddresses\",\"type\":\"address[]\"}],\"name\":\"assignSnapshotterToSlots\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"}],\"name\":\"attestationSubmissionWindow\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"batchId\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"validator\",\"type\":\"address\"}],\"name\":\"attestationsReceived\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"batchId\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"finalizedCidsRootHash\",\"type\":\"bytes32\"}],\"name\":\"attestationsReceivedCount\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"batchId\",\"type\":\"uint256\"}],\"name\":\"batchIdAttestationStatus\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"batchId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"idx\",\"type\":\"uint256\"}],\"name\":\"batchIdDivergentValidators\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"batchId\",\"type\":\"uint256\"}],\"name\":\"batchIdSequencerAttestation\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"batchId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"idx\",\"type\":\"uint256\"}],\"name\":\"batchIdToProjects\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"}],\"name\":\"batchSubmissionWindow\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"batchId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"epochId\",\"type\":\"uint256\"}],\"name\":\"checkDynamicConsensusAttestations\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"slotId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"day\",\"type\":\"uint256\"}],\"name\":\"checkSlotTaskStatusForDay\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"ownerAddress\",\"type\":\"address\"},{\"internalType\":\"uint8\",\"name\":\"epochSize\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"sourceChainId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"sourceChainBlockTime\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"useBlockNumberAsEpochId\",\"type\":\"bool\"}],\"name\":\"createDataMarket\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"}],\"name\":\"currentBatchId\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"}],\"name\":\"currentEpoch\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"begin\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"end\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"epochId\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"}],\"name\":\"dailySnapshotQuota\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"dataMarketCount\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"dataMarketAddress\",\"type\":\"address\"}],\"name\":\"dataMarketEnabled\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"dataMarketFactory\",\"outputs\":[{\"internalType\":\"contractDataMarketFactory\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint8\",\"name\":\"dataMarketId\",\"type\":\"uint8\"}],\"name\":\"dataMarketIdToAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"dataMarketAddress\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"dataMarkets\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"ownerAddress\",\"type\":\"address\"},{\"internalType\":\"uint8\",\"name\":\"epochSize\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"sourceChainId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"sourceChainBlockTime\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"useBlockNumberAsEpochId\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"enabled\",\"type\":\"bool\"},{\"internalType\":\"address\",\"name\":\"dataMarketAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"createdAt\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"}],\"name\":\"dayCounter\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"}],\"name\":\"deploymentBlockNumber\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"epochId\",\"type\":\"uint256\"}],\"name\":\"endBatchSubmissions\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"epochId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"idx\",\"type\":\"uint256\"}],\"name\":\"epochIdToBatchIds\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"epochId\",\"type\":\"uint256\"}],\"name\":\"epochInfo\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"timestamp\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"blocknumber\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"epochEnd\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"}],\"name\":\"epochManager\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"}],\"name\":\"epochsInADay\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"batchId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"epochId\",\"type\":\"uint256\"}],\"name\":\"forceCompleteConsensusAttestations\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"begin\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"end\",\"type\":\"uint256\"}],\"name\":\"forceSkipEpoch\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"}],\"name\":\"getEpochManager\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"}],\"name\":\"getSequencerId\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"}],\"name\":\"getSequencers\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"slotId\",\"type\":\"uint256\"}],\"name\":\"getSlotInfo\",\"outputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"slotId\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"snapshotterAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"rewardPoints\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"currentDaySnapshotCount\",\"type\":\"uint256\"}],\"internalType\":\"structPowerloomDataMarket.SlotInfo\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"slotId\",\"type\":\"uint256\"}],\"name\":\"getSlotRewards\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"rewards\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"}],\"name\":\"getTotalSequencersCount\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getTotalSnapshotterCount\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"}],\"name\":\"getTotalValidatorsCount\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"}],\"name\":\"getValidators\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"initialOwner\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"projectId\",\"type\":\"string\"}],\"name\":\"lastFinalizedSnapshot\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_dayCounter\",\"type\":\"uint256\"}],\"name\":\"loadCurrentDay\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"slotId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"dayId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"snapshotCount\",\"type\":\"uint256\"}],\"name\":\"loadSlotSubmissions\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"batchId\",\"type\":\"uint256\"}],\"name\":\"maxAttestationFinalizedRootHash\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"batchId\",\"type\":\"uint256\"}],\"name\":\"maxAttestationsCount\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"projectId\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"epochId\",\"type\":\"uint256\"}],\"name\":\"maxSnapshotsCid\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"}],\"name\":\"minAttestationsForConsensus\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"}],\"name\":\"minSubmissionsForConsensus\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"projectId\",\"type\":\"string\"}],\"name\":\"projectFirstEpochId\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"begin\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"end\",\"type\":\"uint256\"}],\"name\":\"releaseEpoch\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"}],\"name\":\"rewardBasePoints\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"}],\"name\":\"rewardsEnabled\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"_sequencerId\",\"type\":\"string\"}],\"name\":\"setSequencerId\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"slotCounter\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"slotId\",\"type\":\"uint256\"}],\"name\":\"slotRewardPoints\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"slotRewards\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"slotId\",\"type\":\"uint256\"}],\"name\":\"slotSnapshotterMapping\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"slotId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"dayId\",\"type\":\"uint256\"}],\"name\":\"slotSubmissionCount\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"projectId\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"epochId\",\"type\":\"uint256\"}],\"name\":\"snapshotStatus\",\"outputs\":[{\"internalType\":\"enumPowerloomDataMarket.SnapshotStatus\",\"name\":\"status\",\"type\":\"uint8\"},{\"internalType\":\"string\",\"name\":\"snapshotCid\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"timestamp\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"}],\"name\":\"snapshotSubmissionWindow\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"snapshotterState\",\"outputs\":[{\"internalType\":\"contractSnapshotterState\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"batchId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"epochId\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"finalizedCidsRootHash\",\"type\":\"bytes32\"}],\"name\":\"submitBatchAttestation\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"slotId\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"snapshotCid\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"epochId\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"projectId\",\"type\":\"string\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"slotId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"deadline\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"snapshotCid\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"epochId\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"projectId\",\"type\":\"string\"}],\"internalType\":\"structPowerloomDataMarket.Request\",\"name\":\"request\",\"type\":\"tuple\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"name\":\"submitSnapshot\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"batchCid\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"batchId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"epochId\",\"type\":\"uint256\"},{\"internalType\":\"string[]\",\"name\":\"projectIds\",\"type\":\"string[]\"},{\"internalType\":\"string[]\",\"name\":\"snapshotCids\",\"type\":\"string[]\"},{\"internalType\":\"bytes32\",\"name\":\"finalizedCidsRootHash\",\"type\":\"bytes32\"}],\"name\":\"submitSubmissionBatch\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"dataMarketAddress\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"enabled\",\"type\":\"bool\"}],\"name\":\"toggleDataMarket\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"}],\"name\":\"toggleFallback\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"}],\"name\":\"toggleRewards\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"},{\"internalType\":\"enumPowerloomDataMarket.Role\",\"name\":\"role\",\"type\":\"uint8\"},{\"internalType\":\"address[]\",\"name\":\"_addresses\",\"type\":\"address[]\"},{\"internalType\":\"bool[]\",\"name\":\"_status\",\"type\":\"bool[]\"}],\"name\":\"updateAddresses\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"_projectType\",\"type\":\"string\"},{\"internalType\":\"bool\",\"name\":\"_status\",\"type\":\"bool\"}],\"name\":\"updateAllowedProjectType\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"newattestationSubmissionWindow\",\"type\":\"uint256\"}],\"name\":\"updateAttestationSubmissionWindow\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"newbatchSubmissionWindow\",\"type\":\"uint256\"}],\"name\":\"updateBatchSubmissionWindow\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"dailySnapshotQuota\",\"type\":\"uint256\"}],\"name\":\"updateDailySnapshotQuota\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_address\",\"type\":\"address\"}],\"name\":\"updateDataMarketFactory\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_address\",\"type\":\"address\"}],\"name\":\"updateEpochManager\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"},{\"internalType\":\"address[]\",\"name\":\"_fallbackNodes\",\"type\":\"address[]\"},{\"internalType\":\"bool[]\",\"name\":\"_status\",\"type\":\"bool[]\"}],\"name\":\"updateFallbackNodes\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_minAttestationsForConsensus\",\"type\":\"uint256\"}],\"name\":\"updateMinAttestationsForConsensus\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_minSubmissionsForConsensus\",\"type\":\"uint256\"}],\"name\":\"updateMinSnapshottersForConsensus\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"},{\"internalType\":\"string[]\",\"name\":\"_projects\",\"type\":\"string[]\"},{\"internalType\":\"bool[]\",\"name\":\"_status\",\"type\":\"bool[]\"}],\"name\":\"updateProjects\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"newRewardBasePoints\",\"type\":\"uint256\"}],\"name\":\"updateRewardBasePoints\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"},{\"internalType\":\"uint256[]\",\"name\":\"slotIds\",\"type\":\"uint256[]\"},{\"internalType\":\"uint256[]\",\"name\":\"submissionsList\",\"type\":\"uint256[]\"},{\"internalType\":\"uint256\",\"name\":\"day\",\"type\":\"uint256\"}],\"name\":\"updateRewards\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contractPowerloomDataMarket\",\"name\":\"dataMarket\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"newsnapshotSubmissionWindow\",\"type\":\"uint256\"}],\"name\":\"updateSnapshotSubmissionWindow\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_address\",\"type\":\"address\"}],\"name\":\"updateSnapshotterState\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"}]", +} + +// ContractABI is the input ABI used to generate the binding from. +// Deprecated: Use ContractMetaData.ABI instead. +var ContractABI = ContractMetaData.ABI + +// Contract is an auto generated Go binding around an Ethereum contract. +type Contract struct { + ContractCaller // Read-only binding to the contract + ContractTransactor // Write-only binding to the contract + ContractFilterer // Log filterer for contract events +} + +// ContractCaller is an auto generated read-only Go binding around an Ethereum contract. +type ContractCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ContractTransactor is an auto generated write-only Go binding around an Ethereum contract. +type ContractTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ContractFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type ContractFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ContractSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type ContractSession struct { + Contract *Contract // 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 +} + +// ContractCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type ContractCallerSession struct { + Contract *ContractCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// ContractTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type ContractTransactorSession struct { + Contract *ContractTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ContractRaw is an auto generated low-level Go binding around an Ethereum contract. +type ContractRaw struct { + Contract *Contract // Generic contract binding to access the raw methods on +} + +// ContractCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type ContractCallerRaw struct { + Contract *ContractCaller // Generic read-only contract binding to access the raw methods on +} + +// ContractTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type ContractTransactorRaw struct { + Contract *ContractTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewContract creates a new instance of Contract, bound to a specific deployed contract. +func NewContract(address common.Address, backend bind.ContractBackend) (*Contract, error) { + contract, err := bindContract(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &Contract{ContractCaller: ContractCaller{contract: contract}, ContractTransactor: ContractTransactor{contract: contract}, ContractFilterer: ContractFilterer{contract: contract}}, nil +} + +// NewContractCaller creates a new read-only instance of Contract, bound to a specific deployed contract. +func NewContractCaller(address common.Address, caller bind.ContractCaller) (*ContractCaller, error) { + contract, err := bindContract(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &ContractCaller{contract: contract}, nil +} + +// NewContractTransactor creates a new write-only instance of Contract, bound to a specific deployed contract. +func NewContractTransactor(address common.Address, transactor bind.ContractTransactor) (*ContractTransactor, error) { + contract, err := bindContract(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &ContractTransactor{contract: contract}, nil +} + +// NewContractFilterer creates a new log filterer instance of Contract, bound to a specific deployed contract. +func NewContractFilterer(address common.Address, filterer bind.ContractFilterer) (*ContractFilterer, error) { + contract, err := bindContract(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &ContractFilterer{contract: contract}, nil +} + +// bindContract binds a generic wrapper to an already deployed contract. +func bindContract(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := ContractMetaData.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 (_Contract *ContractRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Contract.Contract.ContractCaller.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 (_Contract *ContractRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Contract.Contract.ContractTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Contract *ContractRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Contract.Contract.ContractTransactor.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 (_Contract *ContractCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Contract.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 (_Contract *ContractTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Contract.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Contract *ContractTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Contract.Contract.contract.Transact(opts, method, params...) +} + +// EPOCHSIZE is a free data retrieval call binding the contract method 0xc12c2aa9. +// +// Solidity: function EPOCH_SIZE(address dataMarket) view returns(uint8) +func (_Contract *ContractCaller) EPOCHSIZE(opts *bind.CallOpts, dataMarket common.Address) (uint8, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "EPOCH_SIZE", dataMarket) + + if err != nil { + return *new(uint8), err + } + + out0 := *abi.ConvertType(out[0], new(uint8)).(*uint8) + + return out0, err + +} + +// EPOCHSIZE is a free data retrieval call binding the contract method 0xc12c2aa9. +// +// Solidity: function EPOCH_SIZE(address dataMarket) view returns(uint8) +func (_Contract *ContractSession) EPOCHSIZE(dataMarket common.Address) (uint8, error) { + return _Contract.Contract.EPOCHSIZE(&_Contract.CallOpts, dataMarket) +} + +// EPOCHSIZE is a free data retrieval call binding the contract method 0xc12c2aa9. +// +// Solidity: function EPOCH_SIZE(address dataMarket) view returns(uint8) +func (_Contract *ContractCallerSession) EPOCHSIZE(dataMarket common.Address) (uint8, error) { + return _Contract.Contract.EPOCHSIZE(&_Contract.CallOpts, dataMarket) +} + +// SOURCECHAINBLOCKTIME is a free data retrieval call binding the contract method 0x0f34e6a9. +// +// Solidity: function SOURCE_CHAIN_BLOCK_TIME(address dataMarket) view returns(uint256) +func (_Contract *ContractCaller) SOURCECHAINBLOCKTIME(opts *bind.CallOpts, dataMarket common.Address) (*big.Int, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "SOURCE_CHAIN_BLOCK_TIME", dataMarket) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// SOURCECHAINBLOCKTIME is a free data retrieval call binding the contract method 0x0f34e6a9. +// +// Solidity: function SOURCE_CHAIN_BLOCK_TIME(address dataMarket) view returns(uint256) +func (_Contract *ContractSession) SOURCECHAINBLOCKTIME(dataMarket common.Address) (*big.Int, error) { + return _Contract.Contract.SOURCECHAINBLOCKTIME(&_Contract.CallOpts, dataMarket) +} + +// SOURCECHAINBLOCKTIME is a free data retrieval call binding the contract method 0x0f34e6a9. +// +// Solidity: function SOURCE_CHAIN_BLOCK_TIME(address dataMarket) view returns(uint256) +func (_Contract *ContractCallerSession) SOURCECHAINBLOCKTIME(dataMarket common.Address) (*big.Int, error) { + return _Contract.Contract.SOURCECHAINBLOCKTIME(&_Contract.CallOpts, dataMarket) +} + +// SOURCECHAINID is a free data retrieval call binding the contract method 0x40e29707. +// +// Solidity: function SOURCE_CHAIN_ID(address dataMarket) view returns(uint256) +func (_Contract *ContractCaller) SOURCECHAINID(opts *bind.CallOpts, dataMarket common.Address) (*big.Int, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "SOURCE_CHAIN_ID", dataMarket) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// SOURCECHAINID is a free data retrieval call binding the contract method 0x40e29707. +// +// Solidity: function SOURCE_CHAIN_ID(address dataMarket) view returns(uint256) +func (_Contract *ContractSession) SOURCECHAINID(dataMarket common.Address) (*big.Int, error) { + return _Contract.Contract.SOURCECHAINID(&_Contract.CallOpts, dataMarket) +} + +// SOURCECHAINID is a free data retrieval call binding the contract method 0x40e29707. +// +// Solidity: function SOURCE_CHAIN_ID(address dataMarket) view returns(uint256) +func (_Contract *ContractCallerSession) SOURCECHAINID(dataMarket common.Address) (*big.Int, error) { + return _Contract.Contract.SOURCECHAINID(&_Contract.CallOpts, dataMarket) +} + +// UPGRADEINTERFACEVERSION is a free data retrieval call binding the contract method 0xad3cb1cc. +// +// Solidity: function UPGRADE_INTERFACE_VERSION() view returns(string) +func (_Contract *ContractCaller) UPGRADEINTERFACEVERSION(opts *bind.CallOpts) (string, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "UPGRADE_INTERFACE_VERSION") + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// UPGRADEINTERFACEVERSION is a free data retrieval call binding the contract method 0xad3cb1cc. +// +// Solidity: function UPGRADE_INTERFACE_VERSION() view returns(string) +func (_Contract *ContractSession) UPGRADEINTERFACEVERSION() (string, error) { + return _Contract.Contract.UPGRADEINTERFACEVERSION(&_Contract.CallOpts) +} + +// UPGRADEINTERFACEVERSION is a free data retrieval call binding the contract method 0xad3cb1cc. +// +// Solidity: function UPGRADE_INTERFACE_VERSION() view returns(string) +func (_Contract *ContractCallerSession) UPGRADEINTERFACEVERSION() (string, error) { + return _Contract.Contract.UPGRADEINTERFACEVERSION(&_Contract.CallOpts) +} + +// USEBLOCKNUMBERASEPOCHID is a free data retrieval call binding the contract method 0x865fb4eb. +// +// Solidity: function USE_BLOCK_NUMBER_AS_EPOCH_ID(address dataMarket) view returns(bool) +func (_Contract *ContractCaller) USEBLOCKNUMBERASEPOCHID(opts *bind.CallOpts, dataMarket common.Address) (bool, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "USE_BLOCK_NUMBER_AS_EPOCH_ID", dataMarket) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// USEBLOCKNUMBERASEPOCHID is a free data retrieval call binding the contract method 0x865fb4eb. +// +// Solidity: function USE_BLOCK_NUMBER_AS_EPOCH_ID(address dataMarket) view returns(bool) +func (_Contract *ContractSession) USEBLOCKNUMBERASEPOCHID(dataMarket common.Address) (bool, error) { + return _Contract.Contract.USEBLOCKNUMBERASEPOCHID(&_Contract.CallOpts, dataMarket) +} + +// USEBLOCKNUMBERASEPOCHID is a free data retrieval call binding the contract method 0x865fb4eb. +// +// Solidity: function USE_BLOCK_NUMBER_AS_EPOCH_ID(address dataMarket) view returns(bool) +func (_Contract *ContractCallerSession) USEBLOCKNUMBERASEPOCHID(dataMarket common.Address) (bool, error) { + return _Contract.Contract.USEBLOCKNUMBERASEPOCHID(&_Contract.CallOpts, dataMarket) +} + +// AllSnapshotters is a free data retrieval call binding the contract method 0x3d15d0f4. +// +// Solidity: function allSnapshotters(address addr) view returns(bool) +func (_Contract *ContractCaller) AllSnapshotters(opts *bind.CallOpts, addr common.Address) (bool, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "allSnapshotters", addr) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// AllSnapshotters is a free data retrieval call binding the contract method 0x3d15d0f4. +// +// Solidity: function allSnapshotters(address addr) view returns(bool) +func (_Contract *ContractSession) AllSnapshotters(addr common.Address) (bool, error) { + return _Contract.Contract.AllSnapshotters(&_Contract.CallOpts, addr) +} + +// AllSnapshotters is a free data retrieval call binding the contract method 0x3d15d0f4. +// +// Solidity: function allSnapshotters(address addr) view returns(bool) +func (_Contract *ContractCallerSession) AllSnapshotters(addr common.Address) (bool, error) { + return _Contract.Contract.AllSnapshotters(&_Contract.CallOpts, addr) +} + +// AllowedProjectTypes is a free data retrieval call binding the contract method 0xc17b3434. +// +// Solidity: function allowedProjectTypes(address dataMarket, string projectType) view returns(bool) +func (_Contract *ContractCaller) AllowedProjectTypes(opts *bind.CallOpts, dataMarket common.Address, projectType string) (bool, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "allowedProjectTypes", dataMarket, projectType) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// AllowedProjectTypes is a free data retrieval call binding the contract method 0xc17b3434. +// +// Solidity: function allowedProjectTypes(address dataMarket, string projectType) view returns(bool) +func (_Contract *ContractSession) AllowedProjectTypes(dataMarket common.Address, projectType string) (bool, error) { + return _Contract.Contract.AllowedProjectTypes(&_Contract.CallOpts, dataMarket, projectType) +} + +// AllowedProjectTypes is a free data retrieval call binding the contract method 0xc17b3434. +// +// Solidity: function allowedProjectTypes(address dataMarket, string projectType) view returns(bool) +func (_Contract *ContractCallerSession) AllowedProjectTypes(dataMarket common.Address, projectType string) (bool, error) { + return _Contract.Contract.AllowedProjectTypes(&_Contract.CallOpts, dataMarket, projectType) +} + +// AttestationSubmissionWindow is a free data retrieval call binding the contract method 0xe1d5fbce. +// +// Solidity: function attestationSubmissionWindow(address dataMarket) view returns(uint256) +func (_Contract *ContractCaller) AttestationSubmissionWindow(opts *bind.CallOpts, dataMarket common.Address) (*big.Int, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "attestationSubmissionWindow", dataMarket) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// AttestationSubmissionWindow is a free data retrieval call binding the contract method 0xe1d5fbce. +// +// Solidity: function attestationSubmissionWindow(address dataMarket) view returns(uint256) +func (_Contract *ContractSession) AttestationSubmissionWindow(dataMarket common.Address) (*big.Int, error) { + return _Contract.Contract.AttestationSubmissionWindow(&_Contract.CallOpts, dataMarket) +} + +// AttestationSubmissionWindow is a free data retrieval call binding the contract method 0xe1d5fbce. +// +// Solidity: function attestationSubmissionWindow(address dataMarket) view returns(uint256) +func (_Contract *ContractCallerSession) AttestationSubmissionWindow(dataMarket common.Address) (*big.Int, error) { + return _Contract.Contract.AttestationSubmissionWindow(&_Contract.CallOpts, dataMarket) +} + +// AttestationsReceived is a free data retrieval call binding the contract method 0xb09c5e2f. +// +// Solidity: function attestationsReceived(address dataMarket, uint256 batchId, address validator) view returns(bool) +func (_Contract *ContractCaller) AttestationsReceived(opts *bind.CallOpts, dataMarket common.Address, batchId *big.Int, validator common.Address) (bool, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "attestationsReceived", dataMarket, batchId, validator) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// AttestationsReceived is a free data retrieval call binding the contract method 0xb09c5e2f. +// +// Solidity: function attestationsReceived(address dataMarket, uint256 batchId, address validator) view returns(bool) +func (_Contract *ContractSession) AttestationsReceived(dataMarket common.Address, batchId *big.Int, validator common.Address) (bool, error) { + return _Contract.Contract.AttestationsReceived(&_Contract.CallOpts, dataMarket, batchId, validator) +} + +// AttestationsReceived is a free data retrieval call binding the contract method 0xb09c5e2f. +// +// Solidity: function attestationsReceived(address dataMarket, uint256 batchId, address validator) view returns(bool) +func (_Contract *ContractCallerSession) AttestationsReceived(dataMarket common.Address, batchId *big.Int, validator common.Address) (bool, error) { + return _Contract.Contract.AttestationsReceived(&_Contract.CallOpts, dataMarket, batchId, validator) +} + +// AttestationsReceivedCount is a free data retrieval call binding the contract method 0x97b0b79f. +// +// Solidity: function attestationsReceivedCount(address dataMarket, uint256 batchId, bytes32 finalizedCidsRootHash) view returns(uint256) +func (_Contract *ContractCaller) AttestationsReceivedCount(opts *bind.CallOpts, dataMarket common.Address, batchId *big.Int, finalizedCidsRootHash [32]byte) (*big.Int, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "attestationsReceivedCount", dataMarket, batchId, finalizedCidsRootHash) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// AttestationsReceivedCount is a free data retrieval call binding the contract method 0x97b0b79f. +// +// Solidity: function attestationsReceivedCount(address dataMarket, uint256 batchId, bytes32 finalizedCidsRootHash) view returns(uint256) +func (_Contract *ContractSession) AttestationsReceivedCount(dataMarket common.Address, batchId *big.Int, finalizedCidsRootHash [32]byte) (*big.Int, error) { + return _Contract.Contract.AttestationsReceivedCount(&_Contract.CallOpts, dataMarket, batchId, finalizedCidsRootHash) +} + +// AttestationsReceivedCount is a free data retrieval call binding the contract method 0x97b0b79f. +// +// Solidity: function attestationsReceivedCount(address dataMarket, uint256 batchId, bytes32 finalizedCidsRootHash) view returns(uint256) +func (_Contract *ContractCallerSession) AttestationsReceivedCount(dataMarket common.Address, batchId *big.Int, finalizedCidsRootHash [32]byte) (*big.Int, error) { + return _Contract.Contract.AttestationsReceivedCount(&_Contract.CallOpts, dataMarket, batchId, finalizedCidsRootHash) +} + +// BatchIdAttestationStatus is a free data retrieval call binding the contract method 0xd4e1a3d1. +// +// Solidity: function batchIdAttestationStatus(address dataMarket, uint256 batchId) view returns(bool) +func (_Contract *ContractCaller) BatchIdAttestationStatus(opts *bind.CallOpts, dataMarket common.Address, batchId *big.Int) (bool, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "batchIdAttestationStatus", dataMarket, batchId) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// BatchIdAttestationStatus is a free data retrieval call binding the contract method 0xd4e1a3d1. +// +// Solidity: function batchIdAttestationStatus(address dataMarket, uint256 batchId) view returns(bool) +func (_Contract *ContractSession) BatchIdAttestationStatus(dataMarket common.Address, batchId *big.Int) (bool, error) { + return _Contract.Contract.BatchIdAttestationStatus(&_Contract.CallOpts, dataMarket, batchId) +} + +// BatchIdAttestationStatus is a free data retrieval call binding the contract method 0xd4e1a3d1. +// +// Solidity: function batchIdAttestationStatus(address dataMarket, uint256 batchId) view returns(bool) +func (_Contract *ContractCallerSession) BatchIdAttestationStatus(dataMarket common.Address, batchId *big.Int) (bool, error) { + return _Contract.Contract.BatchIdAttestationStatus(&_Contract.CallOpts, dataMarket, batchId) +} + +// BatchIdDivergentValidators is a free data retrieval call binding the contract method 0x52ec368a. +// +// Solidity: function batchIdDivergentValidators(address dataMarket, uint256 batchId, uint256 idx) view returns(address) +func (_Contract *ContractCaller) BatchIdDivergentValidators(opts *bind.CallOpts, dataMarket common.Address, batchId *big.Int, idx *big.Int) (common.Address, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "batchIdDivergentValidators", dataMarket, batchId, idx) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// BatchIdDivergentValidators is a free data retrieval call binding the contract method 0x52ec368a. +// +// Solidity: function batchIdDivergentValidators(address dataMarket, uint256 batchId, uint256 idx) view returns(address) +func (_Contract *ContractSession) BatchIdDivergentValidators(dataMarket common.Address, batchId *big.Int, idx *big.Int) (common.Address, error) { + return _Contract.Contract.BatchIdDivergentValidators(&_Contract.CallOpts, dataMarket, batchId, idx) +} + +// BatchIdDivergentValidators is a free data retrieval call binding the contract method 0x52ec368a. +// +// Solidity: function batchIdDivergentValidators(address dataMarket, uint256 batchId, uint256 idx) view returns(address) +func (_Contract *ContractCallerSession) BatchIdDivergentValidators(dataMarket common.Address, batchId *big.Int, idx *big.Int) (common.Address, error) { + return _Contract.Contract.BatchIdDivergentValidators(&_Contract.CallOpts, dataMarket, batchId, idx) +} + +// BatchIdSequencerAttestation is a free data retrieval call binding the contract method 0x2564a9a6. +// +// Solidity: function batchIdSequencerAttestation(address dataMarket, uint256 batchId) view returns(bytes32) +func (_Contract *ContractCaller) BatchIdSequencerAttestation(opts *bind.CallOpts, dataMarket common.Address, batchId *big.Int) ([32]byte, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "batchIdSequencerAttestation", dataMarket, batchId) + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// BatchIdSequencerAttestation is a free data retrieval call binding the contract method 0x2564a9a6. +// +// Solidity: function batchIdSequencerAttestation(address dataMarket, uint256 batchId) view returns(bytes32) +func (_Contract *ContractSession) BatchIdSequencerAttestation(dataMarket common.Address, batchId *big.Int) ([32]byte, error) { + return _Contract.Contract.BatchIdSequencerAttestation(&_Contract.CallOpts, dataMarket, batchId) +} + +// BatchIdSequencerAttestation is a free data retrieval call binding the contract method 0x2564a9a6. +// +// Solidity: function batchIdSequencerAttestation(address dataMarket, uint256 batchId) view returns(bytes32) +func (_Contract *ContractCallerSession) BatchIdSequencerAttestation(dataMarket common.Address, batchId *big.Int) ([32]byte, error) { + return _Contract.Contract.BatchIdSequencerAttestation(&_Contract.CallOpts, dataMarket, batchId) +} + +// BatchIdToProjects is a free data retrieval call binding the contract method 0x474cfea6. +// +// Solidity: function batchIdToProjects(address dataMarket, uint256 batchId, uint256 idx) view returns(string) +func (_Contract *ContractCaller) BatchIdToProjects(opts *bind.CallOpts, dataMarket common.Address, batchId *big.Int, idx *big.Int) (string, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "batchIdToProjects", dataMarket, batchId, idx) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// BatchIdToProjects is a free data retrieval call binding the contract method 0x474cfea6. +// +// Solidity: function batchIdToProjects(address dataMarket, uint256 batchId, uint256 idx) view returns(string) +func (_Contract *ContractSession) BatchIdToProjects(dataMarket common.Address, batchId *big.Int, idx *big.Int) (string, error) { + return _Contract.Contract.BatchIdToProjects(&_Contract.CallOpts, dataMarket, batchId, idx) +} + +// BatchIdToProjects is a free data retrieval call binding the contract method 0x474cfea6. +// +// Solidity: function batchIdToProjects(address dataMarket, uint256 batchId, uint256 idx) view returns(string) +func (_Contract *ContractCallerSession) BatchIdToProjects(dataMarket common.Address, batchId *big.Int, idx *big.Int) (string, error) { + return _Contract.Contract.BatchIdToProjects(&_Contract.CallOpts, dataMarket, batchId, idx) +} + +// BatchSubmissionWindow is a free data retrieval call binding the contract method 0x4d9c25d4. +// +// Solidity: function batchSubmissionWindow(address dataMarket) view returns(uint256) +func (_Contract *ContractCaller) BatchSubmissionWindow(opts *bind.CallOpts, dataMarket common.Address) (*big.Int, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "batchSubmissionWindow", dataMarket) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// BatchSubmissionWindow is a free data retrieval call binding the contract method 0x4d9c25d4. +// +// Solidity: function batchSubmissionWindow(address dataMarket) view returns(uint256) +func (_Contract *ContractSession) BatchSubmissionWindow(dataMarket common.Address) (*big.Int, error) { + return _Contract.Contract.BatchSubmissionWindow(&_Contract.CallOpts, dataMarket) +} + +// BatchSubmissionWindow is a free data retrieval call binding the contract method 0x4d9c25d4. +// +// Solidity: function batchSubmissionWindow(address dataMarket) view returns(uint256) +func (_Contract *ContractCallerSession) BatchSubmissionWindow(dataMarket common.Address) (*big.Int, error) { + return _Contract.Contract.BatchSubmissionWindow(&_Contract.CallOpts, dataMarket) +} + +// CheckDynamicConsensusAttestations is a free data retrieval call binding the contract method 0x20cfff83. +// +// Solidity: function checkDynamicConsensusAttestations(address dataMarket, uint256 batchId, uint256 epochId) view returns(bool) +func (_Contract *ContractCaller) CheckDynamicConsensusAttestations(opts *bind.CallOpts, dataMarket common.Address, batchId *big.Int, epochId *big.Int) (bool, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "checkDynamicConsensusAttestations", dataMarket, batchId, epochId) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// CheckDynamicConsensusAttestations is a free data retrieval call binding the contract method 0x20cfff83. +// +// Solidity: function checkDynamicConsensusAttestations(address dataMarket, uint256 batchId, uint256 epochId) view returns(bool) +func (_Contract *ContractSession) CheckDynamicConsensusAttestations(dataMarket common.Address, batchId *big.Int, epochId *big.Int) (bool, error) { + return _Contract.Contract.CheckDynamicConsensusAttestations(&_Contract.CallOpts, dataMarket, batchId, epochId) +} + +// CheckDynamicConsensusAttestations is a free data retrieval call binding the contract method 0x20cfff83. +// +// Solidity: function checkDynamicConsensusAttestations(address dataMarket, uint256 batchId, uint256 epochId) view returns(bool) +func (_Contract *ContractCallerSession) CheckDynamicConsensusAttestations(dataMarket common.Address, batchId *big.Int, epochId *big.Int) (bool, error) { + return _Contract.Contract.CheckDynamicConsensusAttestations(&_Contract.CallOpts, dataMarket, batchId, epochId) +} + +// CheckSlotTaskStatusForDay is a free data retrieval call binding the contract method 0xc00d0f9c. +// +// Solidity: function checkSlotTaskStatusForDay(address dataMarket, uint256 slotId, uint256 day) view returns(bool) +func (_Contract *ContractCaller) CheckSlotTaskStatusForDay(opts *bind.CallOpts, dataMarket common.Address, slotId *big.Int, day *big.Int) (bool, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "checkSlotTaskStatusForDay", dataMarket, slotId, day) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// CheckSlotTaskStatusForDay is a free data retrieval call binding the contract method 0xc00d0f9c. +// +// Solidity: function checkSlotTaskStatusForDay(address dataMarket, uint256 slotId, uint256 day) view returns(bool) +func (_Contract *ContractSession) CheckSlotTaskStatusForDay(dataMarket common.Address, slotId *big.Int, day *big.Int) (bool, error) { + return _Contract.Contract.CheckSlotTaskStatusForDay(&_Contract.CallOpts, dataMarket, slotId, day) +} + +// CheckSlotTaskStatusForDay is a free data retrieval call binding the contract method 0xc00d0f9c. +// +// Solidity: function checkSlotTaskStatusForDay(address dataMarket, uint256 slotId, uint256 day) view returns(bool) +func (_Contract *ContractCallerSession) CheckSlotTaskStatusForDay(dataMarket common.Address, slotId *big.Int, day *big.Int) (bool, error) { + return _Contract.Contract.CheckSlotTaskStatusForDay(&_Contract.CallOpts, dataMarket, slotId, day) +} + +// CurrentBatchId is a free data retrieval call binding the contract method 0x5edba3d3. +// +// Solidity: function currentBatchId(address dataMarket) view returns(uint256) +func (_Contract *ContractCaller) CurrentBatchId(opts *bind.CallOpts, dataMarket common.Address) (*big.Int, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "currentBatchId", dataMarket) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// CurrentBatchId is a free data retrieval call binding the contract method 0x5edba3d3. +// +// Solidity: function currentBatchId(address dataMarket) view returns(uint256) +func (_Contract *ContractSession) CurrentBatchId(dataMarket common.Address) (*big.Int, error) { + return _Contract.Contract.CurrentBatchId(&_Contract.CallOpts, dataMarket) +} + +// CurrentBatchId is a free data retrieval call binding the contract method 0x5edba3d3. +// +// Solidity: function currentBatchId(address dataMarket) view returns(uint256) +func (_Contract *ContractCallerSession) CurrentBatchId(dataMarket common.Address) (*big.Int, error) { + return _Contract.Contract.CurrentBatchId(&_Contract.CallOpts, dataMarket) +} + +// CurrentEpoch is a free data retrieval call binding the contract method 0x0736e19f. +// +// Solidity: function currentEpoch(address dataMarket) view returns(uint256 begin, uint256 end, uint256 epochId) +func (_Contract *ContractCaller) CurrentEpoch(opts *bind.CallOpts, dataMarket common.Address) (struct { + Begin *big.Int + End *big.Int + EpochId *big.Int +}, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "currentEpoch", dataMarket) + + outstruct := new(struct { + Begin *big.Int + End *big.Int + EpochId *big.Int + }) + if err != nil { + return *outstruct, err + } + + outstruct.Begin = *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + outstruct.End = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) + outstruct.EpochId = *abi.ConvertType(out[2], new(*big.Int)).(**big.Int) + + return *outstruct, err + +} + +// CurrentEpoch is a free data retrieval call binding the contract method 0x0736e19f. +// +// Solidity: function currentEpoch(address dataMarket) view returns(uint256 begin, uint256 end, uint256 epochId) +func (_Contract *ContractSession) CurrentEpoch(dataMarket common.Address) (struct { + Begin *big.Int + End *big.Int + EpochId *big.Int +}, error) { + return _Contract.Contract.CurrentEpoch(&_Contract.CallOpts, dataMarket) +} + +// CurrentEpoch is a free data retrieval call binding the contract method 0x0736e19f. +// +// Solidity: function currentEpoch(address dataMarket) view returns(uint256 begin, uint256 end, uint256 epochId) +func (_Contract *ContractCallerSession) CurrentEpoch(dataMarket common.Address) (struct { + Begin *big.Int + End *big.Int + EpochId *big.Int +}, error) { + return _Contract.Contract.CurrentEpoch(&_Contract.CallOpts, dataMarket) +} + +// DailySnapshotQuota is a free data retrieval call binding the contract method 0x095cb210. +// +// Solidity: function dailySnapshotQuota(address dataMarket) view returns(uint256) +func (_Contract *ContractCaller) DailySnapshotQuota(opts *bind.CallOpts, dataMarket common.Address) (*big.Int, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "dailySnapshotQuota", dataMarket) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// DailySnapshotQuota is a free data retrieval call binding the contract method 0x095cb210. +// +// Solidity: function dailySnapshotQuota(address dataMarket) view returns(uint256) +func (_Contract *ContractSession) DailySnapshotQuota(dataMarket common.Address) (*big.Int, error) { + return _Contract.Contract.DailySnapshotQuota(&_Contract.CallOpts, dataMarket) +} + +// DailySnapshotQuota is a free data retrieval call binding the contract method 0x095cb210. +// +// Solidity: function dailySnapshotQuota(address dataMarket) view returns(uint256) +func (_Contract *ContractCallerSession) DailySnapshotQuota(dataMarket common.Address) (*big.Int, error) { + return _Contract.Contract.DailySnapshotQuota(&_Contract.CallOpts, dataMarket) +} + +// DataMarketCount is a free data retrieval call binding the contract method 0xef829a3d. +// +// Solidity: function dataMarketCount() view returns(uint8) +func (_Contract *ContractCaller) DataMarketCount(opts *bind.CallOpts) (uint8, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "dataMarketCount") + + if err != nil { + return *new(uint8), err + } + + out0 := *abi.ConvertType(out[0], new(uint8)).(*uint8) + + return out0, err + +} + +// DataMarketCount is a free data retrieval call binding the contract method 0xef829a3d. +// +// Solidity: function dataMarketCount() view returns(uint8) +func (_Contract *ContractSession) DataMarketCount() (uint8, error) { + return _Contract.Contract.DataMarketCount(&_Contract.CallOpts) +} + +// DataMarketCount is a free data retrieval call binding the contract method 0xef829a3d. +// +// Solidity: function dataMarketCount() view returns(uint8) +func (_Contract *ContractCallerSession) DataMarketCount() (uint8, error) { + return _Contract.Contract.DataMarketCount(&_Contract.CallOpts) +} + +// DataMarketEnabled is a free data retrieval call binding the contract method 0x75fd5c7c. +// +// Solidity: function dataMarketEnabled(address dataMarketAddress) view returns(bool) +func (_Contract *ContractCaller) DataMarketEnabled(opts *bind.CallOpts, dataMarketAddress common.Address) (bool, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "dataMarketEnabled", dataMarketAddress) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// DataMarketEnabled is a free data retrieval call binding the contract method 0x75fd5c7c. +// +// Solidity: function dataMarketEnabled(address dataMarketAddress) view returns(bool) +func (_Contract *ContractSession) DataMarketEnabled(dataMarketAddress common.Address) (bool, error) { + return _Contract.Contract.DataMarketEnabled(&_Contract.CallOpts, dataMarketAddress) +} + +// DataMarketEnabled is a free data retrieval call binding the contract method 0x75fd5c7c. +// +// Solidity: function dataMarketEnabled(address dataMarketAddress) view returns(bool) +func (_Contract *ContractCallerSession) DataMarketEnabled(dataMarketAddress common.Address) (bool, error) { + return _Contract.Contract.DataMarketEnabled(&_Contract.CallOpts, dataMarketAddress) +} + +// DataMarketFactory is a free data retrieval call binding the contract method 0x5a5c908b. +// +// Solidity: function dataMarketFactory() view returns(address) +func (_Contract *ContractCaller) DataMarketFactory(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "dataMarketFactory") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// DataMarketFactory is a free data retrieval call binding the contract method 0x5a5c908b. +// +// Solidity: function dataMarketFactory() view returns(address) +func (_Contract *ContractSession) DataMarketFactory() (common.Address, error) { + return _Contract.Contract.DataMarketFactory(&_Contract.CallOpts) +} + +// DataMarketFactory is a free data retrieval call binding the contract method 0x5a5c908b. +// +// Solidity: function dataMarketFactory() view returns(address) +func (_Contract *ContractCallerSession) DataMarketFactory() (common.Address, error) { + return _Contract.Contract.DataMarketFactory(&_Contract.CallOpts) +} + +// DataMarketIdToAddress is a free data retrieval call binding the contract method 0x0857b13f. +// +// Solidity: function dataMarketIdToAddress(uint8 dataMarketId) view returns(address dataMarketAddress) +func (_Contract *ContractCaller) DataMarketIdToAddress(opts *bind.CallOpts, dataMarketId uint8) (common.Address, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "dataMarketIdToAddress", dataMarketId) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// DataMarketIdToAddress is a free data retrieval call binding the contract method 0x0857b13f. +// +// Solidity: function dataMarketIdToAddress(uint8 dataMarketId) view returns(address dataMarketAddress) +func (_Contract *ContractSession) DataMarketIdToAddress(dataMarketId uint8) (common.Address, error) { + return _Contract.Contract.DataMarketIdToAddress(&_Contract.CallOpts, dataMarketId) +} + +// DataMarketIdToAddress is a free data retrieval call binding the contract method 0x0857b13f. +// +// Solidity: function dataMarketIdToAddress(uint8 dataMarketId) view returns(address dataMarketAddress) +func (_Contract *ContractCallerSession) DataMarketIdToAddress(dataMarketId uint8) (common.Address, error) { + return _Contract.Contract.DataMarketIdToAddress(&_Contract.CallOpts, dataMarketId) +} + +// DataMarkets is a free data retrieval call binding the contract method 0x5f9abf70. +// +// Solidity: function dataMarkets(address ) view returns(address ownerAddress, uint8 epochSize, uint256 sourceChainId, uint256 sourceChainBlockTime, bool useBlockNumberAsEpochId, bool enabled, address dataMarketAddress, uint256 createdAt) +func (_Contract *ContractCaller) DataMarkets(opts *bind.CallOpts, arg0 common.Address) (struct { + OwnerAddress common.Address + EpochSize uint8 + SourceChainId *big.Int + SourceChainBlockTime *big.Int + UseBlockNumberAsEpochId bool + Enabled bool + DataMarketAddress common.Address + CreatedAt *big.Int +}, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "dataMarkets", arg0) + + outstruct := new(struct { + OwnerAddress common.Address + EpochSize uint8 + SourceChainId *big.Int + SourceChainBlockTime *big.Int + UseBlockNumberAsEpochId bool + Enabled bool + DataMarketAddress common.Address + CreatedAt *big.Int + }) + if err != nil { + return *outstruct, err + } + + outstruct.OwnerAddress = *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + outstruct.EpochSize = *abi.ConvertType(out[1], new(uint8)).(*uint8) + outstruct.SourceChainId = *abi.ConvertType(out[2], new(*big.Int)).(**big.Int) + outstruct.SourceChainBlockTime = *abi.ConvertType(out[3], new(*big.Int)).(**big.Int) + outstruct.UseBlockNumberAsEpochId = *abi.ConvertType(out[4], new(bool)).(*bool) + outstruct.Enabled = *abi.ConvertType(out[5], new(bool)).(*bool) + outstruct.DataMarketAddress = *abi.ConvertType(out[6], new(common.Address)).(*common.Address) + outstruct.CreatedAt = *abi.ConvertType(out[7], new(*big.Int)).(**big.Int) + + return *outstruct, err + +} + +// DataMarkets is a free data retrieval call binding the contract method 0x5f9abf70. +// +// Solidity: function dataMarkets(address ) view returns(address ownerAddress, uint8 epochSize, uint256 sourceChainId, uint256 sourceChainBlockTime, bool useBlockNumberAsEpochId, bool enabled, address dataMarketAddress, uint256 createdAt) +func (_Contract *ContractSession) DataMarkets(arg0 common.Address) (struct { + OwnerAddress common.Address + EpochSize uint8 + SourceChainId *big.Int + SourceChainBlockTime *big.Int + UseBlockNumberAsEpochId bool + Enabled bool + DataMarketAddress common.Address + CreatedAt *big.Int +}, error) { + return _Contract.Contract.DataMarkets(&_Contract.CallOpts, arg0) +} + +// DataMarkets is a free data retrieval call binding the contract method 0x5f9abf70. +// +// Solidity: function dataMarkets(address ) view returns(address ownerAddress, uint8 epochSize, uint256 sourceChainId, uint256 sourceChainBlockTime, bool useBlockNumberAsEpochId, bool enabled, address dataMarketAddress, uint256 createdAt) +func (_Contract *ContractCallerSession) DataMarkets(arg0 common.Address) (struct { + OwnerAddress common.Address + EpochSize uint8 + SourceChainId *big.Int + SourceChainBlockTime *big.Int + UseBlockNumberAsEpochId bool + Enabled bool + DataMarketAddress common.Address + CreatedAt *big.Int +}, error) { + return _Contract.Contract.DataMarkets(&_Contract.CallOpts, arg0) +} + +// DayCounter is a free data retrieval call binding the contract method 0x02143405. +// +// Solidity: function dayCounter(address dataMarket) view returns(uint256) +func (_Contract *ContractCaller) DayCounter(opts *bind.CallOpts, dataMarket common.Address) (*big.Int, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "dayCounter", dataMarket) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// DayCounter is a free data retrieval call binding the contract method 0x02143405. +// +// Solidity: function dayCounter(address dataMarket) view returns(uint256) +func (_Contract *ContractSession) DayCounter(dataMarket common.Address) (*big.Int, error) { + return _Contract.Contract.DayCounter(&_Contract.CallOpts, dataMarket) +} + +// DayCounter is a free data retrieval call binding the contract method 0x02143405. +// +// Solidity: function dayCounter(address dataMarket) view returns(uint256) +func (_Contract *ContractCallerSession) DayCounter(dataMarket common.Address) (*big.Int, error) { + return _Contract.Contract.DayCounter(&_Contract.CallOpts, dataMarket) +} + +// DeploymentBlockNumber is a free data retrieval call binding the contract method 0x06b8d494. +// +// Solidity: function deploymentBlockNumber(address dataMarket) view returns(uint256) +func (_Contract *ContractCaller) DeploymentBlockNumber(opts *bind.CallOpts, dataMarket common.Address) (*big.Int, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "deploymentBlockNumber", dataMarket) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// DeploymentBlockNumber is a free data retrieval call binding the contract method 0x06b8d494. +// +// Solidity: function deploymentBlockNumber(address dataMarket) view returns(uint256) +func (_Contract *ContractSession) DeploymentBlockNumber(dataMarket common.Address) (*big.Int, error) { + return _Contract.Contract.DeploymentBlockNumber(&_Contract.CallOpts, dataMarket) +} + +// DeploymentBlockNumber is a free data retrieval call binding the contract method 0x06b8d494. +// +// Solidity: function deploymentBlockNumber(address dataMarket) view returns(uint256) +func (_Contract *ContractCallerSession) DeploymentBlockNumber(dataMarket common.Address) (*big.Int, error) { + return _Contract.Contract.DeploymentBlockNumber(&_Contract.CallOpts, dataMarket) +} + +// EpochIdToBatchIds is a free data retrieval call binding the contract method 0x07a23063. +// +// Solidity: function epochIdToBatchIds(address dataMarket, uint256 epochId, uint256 idx) view returns(uint256) +func (_Contract *ContractCaller) EpochIdToBatchIds(opts *bind.CallOpts, dataMarket common.Address, epochId *big.Int, idx *big.Int) (*big.Int, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "epochIdToBatchIds", dataMarket, epochId, idx) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// EpochIdToBatchIds is a free data retrieval call binding the contract method 0x07a23063. +// +// Solidity: function epochIdToBatchIds(address dataMarket, uint256 epochId, uint256 idx) view returns(uint256) +func (_Contract *ContractSession) EpochIdToBatchIds(dataMarket common.Address, epochId *big.Int, idx *big.Int) (*big.Int, error) { + return _Contract.Contract.EpochIdToBatchIds(&_Contract.CallOpts, dataMarket, epochId, idx) +} + +// EpochIdToBatchIds is a free data retrieval call binding the contract method 0x07a23063. +// +// Solidity: function epochIdToBatchIds(address dataMarket, uint256 epochId, uint256 idx) view returns(uint256) +func (_Contract *ContractCallerSession) EpochIdToBatchIds(dataMarket common.Address, epochId *big.Int, idx *big.Int) (*big.Int, error) { + return _Contract.Contract.EpochIdToBatchIds(&_Contract.CallOpts, dataMarket, epochId, idx) +} + +// EpochInfo is a free data retrieval call binding the contract method 0xc9ab0c83. +// +// Solidity: function epochInfo(address dataMarket, uint256 epochId) view returns(uint256 timestamp, uint256 blocknumber, uint256 epochEnd) +func (_Contract *ContractCaller) EpochInfo(opts *bind.CallOpts, dataMarket common.Address, epochId *big.Int) (struct { + Timestamp *big.Int + Blocknumber *big.Int + EpochEnd *big.Int +}, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "epochInfo", dataMarket, epochId) + + outstruct := new(struct { + Timestamp *big.Int + Blocknumber *big.Int + EpochEnd *big.Int + }) + if err != nil { + return *outstruct, err + } + + outstruct.Timestamp = *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + outstruct.Blocknumber = *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) + outstruct.EpochEnd = *abi.ConvertType(out[2], new(*big.Int)).(**big.Int) + + return *outstruct, err + +} + +// EpochInfo is a free data retrieval call binding the contract method 0xc9ab0c83. +// +// Solidity: function epochInfo(address dataMarket, uint256 epochId) view returns(uint256 timestamp, uint256 blocknumber, uint256 epochEnd) +func (_Contract *ContractSession) EpochInfo(dataMarket common.Address, epochId *big.Int) (struct { + Timestamp *big.Int + Blocknumber *big.Int + EpochEnd *big.Int +}, error) { + return _Contract.Contract.EpochInfo(&_Contract.CallOpts, dataMarket, epochId) +} + +// EpochInfo is a free data retrieval call binding the contract method 0xc9ab0c83. +// +// Solidity: function epochInfo(address dataMarket, uint256 epochId) view returns(uint256 timestamp, uint256 blocknumber, uint256 epochEnd) +func (_Contract *ContractCallerSession) EpochInfo(dataMarket common.Address, epochId *big.Int) (struct { + Timestamp *big.Int + Blocknumber *big.Int + EpochEnd *big.Int +}, error) { + return _Contract.Contract.EpochInfo(&_Contract.CallOpts, dataMarket, epochId) +} + +// EpochManager is a free data retrieval call binding the contract method 0x0d5a7a52. +// +// Solidity: function epochManager(address dataMarket) view returns(address) +func (_Contract *ContractCaller) EpochManager(opts *bind.CallOpts, dataMarket common.Address) (common.Address, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "epochManager", dataMarket) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// EpochManager is a free data retrieval call binding the contract method 0x0d5a7a52. +// +// Solidity: function epochManager(address dataMarket) view returns(address) +func (_Contract *ContractSession) EpochManager(dataMarket common.Address) (common.Address, error) { + return _Contract.Contract.EpochManager(&_Contract.CallOpts, dataMarket) +} + +// EpochManager is a free data retrieval call binding the contract method 0x0d5a7a52. +// +// Solidity: function epochManager(address dataMarket) view returns(address) +func (_Contract *ContractCallerSession) EpochManager(dataMarket common.Address) (common.Address, error) { + return _Contract.Contract.EpochManager(&_Contract.CallOpts, dataMarket) +} + +// EpochsInADay is a free data retrieval call binding the contract method 0x0a1b7227. +// +// Solidity: function epochsInADay(address dataMarket) view returns(uint256) +func (_Contract *ContractCaller) EpochsInADay(opts *bind.CallOpts, dataMarket common.Address) (*big.Int, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "epochsInADay", dataMarket) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// EpochsInADay is a free data retrieval call binding the contract method 0x0a1b7227. +// +// Solidity: function epochsInADay(address dataMarket) view returns(uint256) +func (_Contract *ContractSession) EpochsInADay(dataMarket common.Address) (*big.Int, error) { + return _Contract.Contract.EpochsInADay(&_Contract.CallOpts, dataMarket) +} + +// EpochsInADay is a free data retrieval call binding the contract method 0x0a1b7227. +// +// Solidity: function epochsInADay(address dataMarket) view returns(uint256) +func (_Contract *ContractCallerSession) EpochsInADay(dataMarket common.Address) (*big.Int, error) { + return _Contract.Contract.EpochsInADay(&_Contract.CallOpts, dataMarket) +} + +// GetEpochManager is a free data retrieval call binding the contract method 0x6ce4f26c. +// +// Solidity: function getEpochManager(address dataMarket) view returns(address) +func (_Contract *ContractCaller) GetEpochManager(opts *bind.CallOpts, dataMarket common.Address) (common.Address, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "getEpochManager", dataMarket) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// GetEpochManager is a free data retrieval call binding the contract method 0x6ce4f26c. +// +// Solidity: function getEpochManager(address dataMarket) view returns(address) +func (_Contract *ContractSession) GetEpochManager(dataMarket common.Address) (common.Address, error) { + return _Contract.Contract.GetEpochManager(&_Contract.CallOpts, dataMarket) +} + +// GetEpochManager is a free data retrieval call binding the contract method 0x6ce4f26c. +// +// Solidity: function getEpochManager(address dataMarket) view returns(address) +func (_Contract *ContractCallerSession) GetEpochManager(dataMarket common.Address) (common.Address, error) { + return _Contract.Contract.GetEpochManager(&_Contract.CallOpts, dataMarket) +} + +// GetSequencerId is a free data retrieval call binding the contract method 0x1c7d13a6. +// +// Solidity: function getSequencerId(address dataMarket) view returns(string) +func (_Contract *ContractCaller) GetSequencerId(opts *bind.CallOpts, dataMarket common.Address) (string, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "getSequencerId", dataMarket) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// GetSequencerId is a free data retrieval call binding the contract method 0x1c7d13a6. +// +// Solidity: function getSequencerId(address dataMarket) view returns(string) +func (_Contract *ContractSession) GetSequencerId(dataMarket common.Address) (string, error) { + return _Contract.Contract.GetSequencerId(&_Contract.CallOpts, dataMarket) +} + +// GetSequencerId is a free data retrieval call binding the contract method 0x1c7d13a6. +// +// Solidity: function getSequencerId(address dataMarket) view returns(string) +func (_Contract *ContractCallerSession) GetSequencerId(dataMarket common.Address) (string, error) { + return _Contract.Contract.GetSequencerId(&_Contract.CallOpts, dataMarket) +} + +// GetSequencers is a free data retrieval call binding the contract method 0x6b0ad9ac. +// +// Solidity: function getSequencers(address dataMarket) view returns(address[]) +func (_Contract *ContractCaller) GetSequencers(opts *bind.CallOpts, dataMarket common.Address) ([]common.Address, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "getSequencers", dataMarket) + + if err != nil { + return *new([]common.Address), err + } + + out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address) + + return out0, err + +} + +// GetSequencers is a free data retrieval call binding the contract method 0x6b0ad9ac. +// +// Solidity: function getSequencers(address dataMarket) view returns(address[]) +func (_Contract *ContractSession) GetSequencers(dataMarket common.Address) ([]common.Address, error) { + return _Contract.Contract.GetSequencers(&_Contract.CallOpts, dataMarket) +} + +// GetSequencers is a free data retrieval call binding the contract method 0x6b0ad9ac. +// +// Solidity: function getSequencers(address dataMarket) view returns(address[]) +func (_Contract *ContractCallerSession) GetSequencers(dataMarket common.Address) ([]common.Address, error) { + return _Contract.Contract.GetSequencers(&_Contract.CallOpts, dataMarket) +} + +// GetSlotInfo is a free data retrieval call binding the contract method 0xc367e244. +// +// Solidity: function getSlotInfo(address dataMarket, uint256 slotId) view returns((uint256,address,uint256,uint256)) +func (_Contract *ContractCaller) GetSlotInfo(opts *bind.CallOpts, dataMarket common.Address, slotId *big.Int) (PowerloomDataMarketSlotInfo, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "getSlotInfo", dataMarket, slotId) + + if err != nil { + return *new(PowerloomDataMarketSlotInfo), err + } + + out0 := *abi.ConvertType(out[0], new(PowerloomDataMarketSlotInfo)).(*PowerloomDataMarketSlotInfo) + + return out0, err + +} + +// GetSlotInfo is a free data retrieval call binding the contract method 0xc367e244. +// +// Solidity: function getSlotInfo(address dataMarket, uint256 slotId) view returns((uint256,address,uint256,uint256)) +func (_Contract *ContractSession) GetSlotInfo(dataMarket common.Address, slotId *big.Int) (PowerloomDataMarketSlotInfo, error) { + return _Contract.Contract.GetSlotInfo(&_Contract.CallOpts, dataMarket, slotId) +} + +// GetSlotInfo is a free data retrieval call binding the contract method 0xc367e244. +// +// Solidity: function getSlotInfo(address dataMarket, uint256 slotId) view returns((uint256,address,uint256,uint256)) +func (_Contract *ContractCallerSession) GetSlotInfo(dataMarket common.Address, slotId *big.Int) (PowerloomDataMarketSlotInfo, error) { + return _Contract.Contract.GetSlotInfo(&_Contract.CallOpts, dataMarket, slotId) +} + +// GetSlotRewards is a free data retrieval call binding the contract method 0x9ab1013d. +// +// Solidity: function getSlotRewards(uint256 slotId) view returns(uint256 rewards) +func (_Contract *ContractCaller) GetSlotRewards(opts *bind.CallOpts, slotId *big.Int) (*big.Int, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "getSlotRewards", slotId) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// GetSlotRewards is a free data retrieval call binding the contract method 0x9ab1013d. +// +// Solidity: function getSlotRewards(uint256 slotId) view returns(uint256 rewards) +func (_Contract *ContractSession) GetSlotRewards(slotId *big.Int) (*big.Int, error) { + return _Contract.Contract.GetSlotRewards(&_Contract.CallOpts, slotId) +} + +// GetSlotRewards is a free data retrieval call binding the contract method 0x9ab1013d. +// +// Solidity: function getSlotRewards(uint256 slotId) view returns(uint256 rewards) +func (_Contract *ContractCallerSession) GetSlotRewards(slotId *big.Int) (*big.Int, error) { + return _Contract.Contract.GetSlotRewards(&_Contract.CallOpts, slotId) +} + +// GetTotalSequencersCount is a free data retrieval call binding the contract method 0x665ebe8c. +// +// Solidity: function getTotalSequencersCount(address dataMarket) view returns(uint256) +func (_Contract *ContractCaller) GetTotalSequencersCount(opts *bind.CallOpts, dataMarket common.Address) (*big.Int, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "getTotalSequencersCount", dataMarket) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// GetTotalSequencersCount is a free data retrieval call binding the contract method 0x665ebe8c. +// +// Solidity: function getTotalSequencersCount(address dataMarket) view returns(uint256) +func (_Contract *ContractSession) GetTotalSequencersCount(dataMarket common.Address) (*big.Int, error) { + return _Contract.Contract.GetTotalSequencersCount(&_Contract.CallOpts, dataMarket) +} + +// GetTotalSequencersCount is a free data retrieval call binding the contract method 0x665ebe8c. +// +// Solidity: function getTotalSequencersCount(address dataMarket) view returns(uint256) +func (_Contract *ContractCallerSession) GetTotalSequencersCount(dataMarket common.Address) (*big.Int, error) { + return _Contract.Contract.GetTotalSequencersCount(&_Contract.CallOpts, dataMarket) +} + +// GetTotalSnapshotterCount is a free data retrieval call binding the contract method 0x92ae6f66. +// +// Solidity: function getTotalSnapshotterCount() view returns(uint256) +func (_Contract *ContractCaller) GetTotalSnapshotterCount(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "getTotalSnapshotterCount") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// GetTotalSnapshotterCount is a free data retrieval call binding the contract method 0x92ae6f66. +// +// Solidity: function getTotalSnapshotterCount() view returns(uint256) +func (_Contract *ContractSession) GetTotalSnapshotterCount() (*big.Int, error) { + return _Contract.Contract.GetTotalSnapshotterCount(&_Contract.CallOpts) +} + +// GetTotalSnapshotterCount is a free data retrieval call binding the contract method 0x92ae6f66. +// +// Solidity: function getTotalSnapshotterCount() view returns(uint256) +func (_Contract *ContractCallerSession) GetTotalSnapshotterCount() (*big.Int, error) { + return _Contract.Contract.GetTotalSnapshotterCount(&_Contract.CallOpts) +} + +// GetTotalValidatorsCount is a free data retrieval call binding the contract method 0xc2acc6a3. +// +// Solidity: function getTotalValidatorsCount(address dataMarket) view returns(uint256) +func (_Contract *ContractCaller) GetTotalValidatorsCount(opts *bind.CallOpts, dataMarket common.Address) (*big.Int, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "getTotalValidatorsCount", dataMarket) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// GetTotalValidatorsCount is a free data retrieval call binding the contract method 0xc2acc6a3. +// +// Solidity: function getTotalValidatorsCount(address dataMarket) view returns(uint256) +func (_Contract *ContractSession) GetTotalValidatorsCount(dataMarket common.Address) (*big.Int, error) { + return _Contract.Contract.GetTotalValidatorsCount(&_Contract.CallOpts, dataMarket) +} + +// GetTotalValidatorsCount is a free data retrieval call binding the contract method 0xc2acc6a3. +// +// Solidity: function getTotalValidatorsCount(address dataMarket) view returns(uint256) +func (_Contract *ContractCallerSession) GetTotalValidatorsCount(dataMarket common.Address) (*big.Int, error) { + return _Contract.Contract.GetTotalValidatorsCount(&_Contract.CallOpts, dataMarket) +} + +// GetValidators is a free data retrieval call binding the contract method 0xff8744a6. +// +// Solidity: function getValidators(address dataMarket) view returns(address[]) +func (_Contract *ContractCaller) GetValidators(opts *bind.CallOpts, dataMarket common.Address) ([]common.Address, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "getValidators", dataMarket) + + if err != nil { + return *new([]common.Address), err + } + + out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address) + + return out0, err + +} + +// GetValidators is a free data retrieval call binding the contract method 0xff8744a6. +// +// Solidity: function getValidators(address dataMarket) view returns(address[]) +func (_Contract *ContractSession) GetValidators(dataMarket common.Address) ([]common.Address, error) { + return _Contract.Contract.GetValidators(&_Contract.CallOpts, dataMarket) +} + +// GetValidators is a free data retrieval call binding the contract method 0xff8744a6. +// +// Solidity: function getValidators(address dataMarket) view returns(address[]) +func (_Contract *ContractCallerSession) GetValidators(dataMarket common.Address) ([]common.Address, error) { + return _Contract.Contract.GetValidators(&_Contract.CallOpts, dataMarket) +} + +// LastFinalizedSnapshot is a free data retrieval call binding the contract method 0xded2465b. +// +// Solidity: function lastFinalizedSnapshot(address dataMarket, string projectId) view returns(uint256) +func (_Contract *ContractCaller) LastFinalizedSnapshot(opts *bind.CallOpts, dataMarket common.Address, projectId string) (*big.Int, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "lastFinalizedSnapshot", dataMarket, projectId) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// LastFinalizedSnapshot is a free data retrieval call binding the contract method 0xded2465b. +// +// Solidity: function lastFinalizedSnapshot(address dataMarket, string projectId) view returns(uint256) +func (_Contract *ContractSession) LastFinalizedSnapshot(dataMarket common.Address, projectId string) (*big.Int, error) { + return _Contract.Contract.LastFinalizedSnapshot(&_Contract.CallOpts, dataMarket, projectId) +} + +// LastFinalizedSnapshot is a free data retrieval call binding the contract method 0xded2465b. +// +// Solidity: function lastFinalizedSnapshot(address dataMarket, string projectId) view returns(uint256) +func (_Contract *ContractCallerSession) LastFinalizedSnapshot(dataMarket common.Address, projectId string) (*big.Int, error) { + return _Contract.Contract.LastFinalizedSnapshot(&_Contract.CallOpts, dataMarket, projectId) +} + +// MaxAttestationFinalizedRootHash is a free data retrieval call binding the contract method 0x320eeed2. +// +// Solidity: function maxAttestationFinalizedRootHash(address dataMarket, uint256 batchId) view returns(bytes32) +func (_Contract *ContractCaller) MaxAttestationFinalizedRootHash(opts *bind.CallOpts, dataMarket common.Address, batchId *big.Int) ([32]byte, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "maxAttestationFinalizedRootHash", dataMarket, batchId) + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// MaxAttestationFinalizedRootHash is a free data retrieval call binding the contract method 0x320eeed2. +// +// Solidity: function maxAttestationFinalizedRootHash(address dataMarket, uint256 batchId) view returns(bytes32) +func (_Contract *ContractSession) MaxAttestationFinalizedRootHash(dataMarket common.Address, batchId *big.Int) ([32]byte, error) { + return _Contract.Contract.MaxAttestationFinalizedRootHash(&_Contract.CallOpts, dataMarket, batchId) +} + +// MaxAttestationFinalizedRootHash is a free data retrieval call binding the contract method 0x320eeed2. +// +// Solidity: function maxAttestationFinalizedRootHash(address dataMarket, uint256 batchId) view returns(bytes32) +func (_Contract *ContractCallerSession) MaxAttestationFinalizedRootHash(dataMarket common.Address, batchId *big.Int) ([32]byte, error) { + return _Contract.Contract.MaxAttestationFinalizedRootHash(&_Contract.CallOpts, dataMarket, batchId) +} + +// MaxAttestationsCount is a free data retrieval call binding the contract method 0x3230df83. +// +// Solidity: function maxAttestationsCount(address dataMarket, uint256 batchId) view returns(uint256) +func (_Contract *ContractCaller) MaxAttestationsCount(opts *bind.CallOpts, dataMarket common.Address, batchId *big.Int) (*big.Int, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "maxAttestationsCount", dataMarket, batchId) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// MaxAttestationsCount is a free data retrieval call binding the contract method 0x3230df83. +// +// Solidity: function maxAttestationsCount(address dataMarket, uint256 batchId) view returns(uint256) +func (_Contract *ContractSession) MaxAttestationsCount(dataMarket common.Address, batchId *big.Int) (*big.Int, error) { + return _Contract.Contract.MaxAttestationsCount(&_Contract.CallOpts, dataMarket, batchId) +} + +// MaxAttestationsCount is a free data retrieval call binding the contract method 0x3230df83. +// +// Solidity: function maxAttestationsCount(address dataMarket, uint256 batchId) view returns(uint256) +func (_Contract *ContractCallerSession) MaxAttestationsCount(dataMarket common.Address, batchId *big.Int) (*big.Int, error) { + return _Contract.Contract.MaxAttestationsCount(&_Contract.CallOpts, dataMarket, batchId) +} + +// MaxSnapshotsCid is a free data retrieval call binding the contract method 0x7e9ce892. +// +// Solidity: function maxSnapshotsCid(address dataMarket, string projectId, uint256 epochId) view returns(string) +func (_Contract *ContractCaller) MaxSnapshotsCid(opts *bind.CallOpts, dataMarket common.Address, projectId string, epochId *big.Int) (string, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "maxSnapshotsCid", dataMarket, projectId, epochId) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// MaxSnapshotsCid is a free data retrieval call binding the contract method 0x7e9ce892. +// +// Solidity: function maxSnapshotsCid(address dataMarket, string projectId, uint256 epochId) view returns(string) +func (_Contract *ContractSession) MaxSnapshotsCid(dataMarket common.Address, projectId string, epochId *big.Int) (string, error) { + return _Contract.Contract.MaxSnapshotsCid(&_Contract.CallOpts, dataMarket, projectId, epochId) +} + +// MaxSnapshotsCid is a free data retrieval call binding the contract method 0x7e9ce892. +// +// Solidity: function maxSnapshotsCid(address dataMarket, string projectId, uint256 epochId) view returns(string) +func (_Contract *ContractCallerSession) MaxSnapshotsCid(dataMarket common.Address, projectId string, epochId *big.Int) (string, error) { + return _Contract.Contract.MaxSnapshotsCid(&_Contract.CallOpts, dataMarket, projectId, epochId) +} + +// MinAttestationsForConsensus is a free data retrieval call binding the contract method 0xb3d95efa. +// +// Solidity: function minAttestationsForConsensus(address dataMarket) view returns(uint256) +func (_Contract *ContractCaller) MinAttestationsForConsensus(opts *bind.CallOpts, dataMarket common.Address) (*big.Int, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "minAttestationsForConsensus", dataMarket) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// MinAttestationsForConsensus is a free data retrieval call binding the contract method 0xb3d95efa. +// +// Solidity: function minAttestationsForConsensus(address dataMarket) view returns(uint256) +func (_Contract *ContractSession) MinAttestationsForConsensus(dataMarket common.Address) (*big.Int, error) { + return _Contract.Contract.MinAttestationsForConsensus(&_Contract.CallOpts, dataMarket) +} + +// MinAttestationsForConsensus is a free data retrieval call binding the contract method 0xb3d95efa. +// +// Solidity: function minAttestationsForConsensus(address dataMarket) view returns(uint256) +func (_Contract *ContractCallerSession) MinAttestationsForConsensus(dataMarket common.Address) (*big.Int, error) { + return _Contract.Contract.MinAttestationsForConsensus(&_Contract.CallOpts, dataMarket) +} + +// MinSubmissionsForConsensus is a free data retrieval call binding the contract method 0x0984dbd2. +// +// Solidity: function minSubmissionsForConsensus(address dataMarket) view returns(uint256) +func (_Contract *ContractCaller) MinSubmissionsForConsensus(opts *bind.CallOpts, dataMarket common.Address) (*big.Int, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "minSubmissionsForConsensus", dataMarket) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// MinSubmissionsForConsensus is a free data retrieval call binding the contract method 0x0984dbd2. +// +// Solidity: function minSubmissionsForConsensus(address dataMarket) view returns(uint256) +func (_Contract *ContractSession) MinSubmissionsForConsensus(dataMarket common.Address) (*big.Int, error) { + return _Contract.Contract.MinSubmissionsForConsensus(&_Contract.CallOpts, dataMarket) +} + +// MinSubmissionsForConsensus is a free data retrieval call binding the contract method 0x0984dbd2. +// +// Solidity: function minSubmissionsForConsensus(address dataMarket) view returns(uint256) +func (_Contract *ContractCallerSession) MinSubmissionsForConsensus(dataMarket common.Address) (*big.Int, error) { + return _Contract.Contract.MinSubmissionsForConsensus(&_Contract.CallOpts, dataMarket) +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_Contract *ContractCaller) Owner(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Contract.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 (_Contract *ContractSession) Owner() (common.Address, error) { + return _Contract.Contract.Owner(&_Contract.CallOpts) +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_Contract *ContractCallerSession) Owner() (common.Address, error) { + return _Contract.Contract.Owner(&_Contract.CallOpts) +} + +// ProjectFirstEpochId is a free data retrieval call binding the contract method 0x4242614c. +// +// Solidity: function projectFirstEpochId(address dataMarket, string projectId) view returns(uint256) +func (_Contract *ContractCaller) ProjectFirstEpochId(opts *bind.CallOpts, dataMarket common.Address, projectId string) (*big.Int, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "projectFirstEpochId", dataMarket, projectId) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// ProjectFirstEpochId is a free data retrieval call binding the contract method 0x4242614c. +// +// Solidity: function projectFirstEpochId(address dataMarket, string projectId) view returns(uint256) +func (_Contract *ContractSession) ProjectFirstEpochId(dataMarket common.Address, projectId string) (*big.Int, error) { + return _Contract.Contract.ProjectFirstEpochId(&_Contract.CallOpts, dataMarket, projectId) +} + +// ProjectFirstEpochId is a free data retrieval call binding the contract method 0x4242614c. +// +// Solidity: function projectFirstEpochId(address dataMarket, string projectId) view returns(uint256) +func (_Contract *ContractCallerSession) ProjectFirstEpochId(dataMarket common.Address, projectId string) (*big.Int, error) { + return _Contract.Contract.ProjectFirstEpochId(&_Contract.CallOpts, dataMarket, projectId) +} + +// ProxiableUUID is a free data retrieval call binding the contract method 0x52d1902d. +// +// Solidity: function proxiableUUID() view returns(bytes32) +func (_Contract *ContractCaller) ProxiableUUID(opts *bind.CallOpts) ([32]byte, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "proxiableUUID") + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// ProxiableUUID is a free data retrieval call binding the contract method 0x52d1902d. +// +// Solidity: function proxiableUUID() view returns(bytes32) +func (_Contract *ContractSession) ProxiableUUID() ([32]byte, error) { + return _Contract.Contract.ProxiableUUID(&_Contract.CallOpts) +} + +// ProxiableUUID is a free data retrieval call binding the contract method 0x52d1902d. +// +// Solidity: function proxiableUUID() view returns(bytes32) +func (_Contract *ContractCallerSession) ProxiableUUID() ([32]byte, error) { + return _Contract.Contract.ProxiableUUID(&_Contract.CallOpts) +} + +// RewardBasePoints is a free data retrieval call binding the contract method 0x7f59285a. +// +// Solidity: function rewardBasePoints(address dataMarket) view returns(uint256) +func (_Contract *ContractCaller) RewardBasePoints(opts *bind.CallOpts, dataMarket common.Address) (*big.Int, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "rewardBasePoints", dataMarket) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// RewardBasePoints is a free data retrieval call binding the contract method 0x7f59285a. +// +// Solidity: function rewardBasePoints(address dataMarket) view returns(uint256) +func (_Contract *ContractSession) RewardBasePoints(dataMarket common.Address) (*big.Int, error) { + return _Contract.Contract.RewardBasePoints(&_Contract.CallOpts, dataMarket) +} + +// RewardBasePoints is a free data retrieval call binding the contract method 0x7f59285a. +// +// Solidity: function rewardBasePoints(address dataMarket) view returns(uint256) +func (_Contract *ContractCallerSession) RewardBasePoints(dataMarket common.Address) (*big.Int, error) { + return _Contract.Contract.RewardBasePoints(&_Contract.CallOpts, dataMarket) +} + +// RewardsEnabled is a free data retrieval call binding the contract method 0x83450d26. +// +// Solidity: function rewardsEnabled(address dataMarket) view returns(bool) +func (_Contract *ContractCaller) RewardsEnabled(opts *bind.CallOpts, dataMarket common.Address) (bool, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "rewardsEnabled", dataMarket) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// RewardsEnabled is a free data retrieval call binding the contract method 0x83450d26. +// +// Solidity: function rewardsEnabled(address dataMarket) view returns(bool) +func (_Contract *ContractSession) RewardsEnabled(dataMarket common.Address) (bool, error) { + return _Contract.Contract.RewardsEnabled(&_Contract.CallOpts, dataMarket) +} + +// RewardsEnabled is a free data retrieval call binding the contract method 0x83450d26. +// +// Solidity: function rewardsEnabled(address dataMarket) view returns(bool) +func (_Contract *ContractCallerSession) RewardsEnabled(dataMarket common.Address) (bool, error) { + return _Contract.Contract.RewardsEnabled(&_Contract.CallOpts, dataMarket) +} + +// SlotCounter is a free data retrieval call binding the contract method 0xe59a4105. +// +// Solidity: function slotCounter() view returns(uint256) +func (_Contract *ContractCaller) SlotCounter(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "slotCounter") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// SlotCounter is a free data retrieval call binding the contract method 0xe59a4105. +// +// Solidity: function slotCounter() view returns(uint256) +func (_Contract *ContractSession) SlotCounter() (*big.Int, error) { + return _Contract.Contract.SlotCounter(&_Contract.CallOpts) +} + +// SlotCounter is a free data retrieval call binding the contract method 0xe59a4105. +// +// Solidity: function slotCounter() view returns(uint256) +func (_Contract *ContractCallerSession) SlotCounter() (*big.Int, error) { + return _Contract.Contract.SlotCounter(&_Contract.CallOpts) +} + +// SlotRewardPoints is a free data retrieval call binding the contract method 0x9a2458a6. +// +// Solidity: function slotRewardPoints(address dataMarket, uint256 slotId) view returns(uint256) +func (_Contract *ContractCaller) SlotRewardPoints(opts *bind.CallOpts, dataMarket common.Address, slotId *big.Int) (*big.Int, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "slotRewardPoints", dataMarket, slotId) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// SlotRewardPoints is a free data retrieval call binding the contract method 0x9a2458a6. +// +// Solidity: function slotRewardPoints(address dataMarket, uint256 slotId) view returns(uint256) +func (_Contract *ContractSession) SlotRewardPoints(dataMarket common.Address, slotId *big.Int) (*big.Int, error) { + return _Contract.Contract.SlotRewardPoints(&_Contract.CallOpts, dataMarket, slotId) +} + +// SlotRewardPoints is a free data retrieval call binding the contract method 0x9a2458a6. +// +// Solidity: function slotRewardPoints(address dataMarket, uint256 slotId) view returns(uint256) +func (_Contract *ContractCallerSession) SlotRewardPoints(dataMarket common.Address, slotId *big.Int) (*big.Int, error) { + return _Contract.Contract.SlotRewardPoints(&_Contract.CallOpts, dataMarket, slotId) +} + +// SlotRewards is a free data retrieval call binding the contract method 0x53e28269. +// +// Solidity: function slotRewards(uint256 ) view returns(uint256) +func (_Contract *ContractCaller) SlotRewards(opts *bind.CallOpts, arg0 *big.Int) (*big.Int, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "slotRewards", arg0) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// SlotRewards is a free data retrieval call binding the contract method 0x53e28269. +// +// Solidity: function slotRewards(uint256 ) view returns(uint256) +func (_Contract *ContractSession) SlotRewards(arg0 *big.Int) (*big.Int, error) { + return _Contract.Contract.SlotRewards(&_Contract.CallOpts, arg0) +} + +// SlotRewards is a free data retrieval call binding the contract method 0x53e28269. +// +// Solidity: function slotRewards(uint256 ) view returns(uint256) +func (_Contract *ContractCallerSession) SlotRewards(arg0 *big.Int) (*big.Int, error) { + return _Contract.Contract.SlotRewards(&_Contract.CallOpts, arg0) +} + +// SlotSnapshotterMapping is a free data retrieval call binding the contract method 0x948a463e. +// +// Solidity: function slotSnapshotterMapping(uint256 slotId) view returns(address) +func (_Contract *ContractCaller) SlotSnapshotterMapping(opts *bind.CallOpts, slotId *big.Int) (common.Address, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "slotSnapshotterMapping", slotId) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// SlotSnapshotterMapping is a free data retrieval call binding the contract method 0x948a463e. +// +// Solidity: function slotSnapshotterMapping(uint256 slotId) view returns(address) +func (_Contract *ContractSession) SlotSnapshotterMapping(slotId *big.Int) (common.Address, error) { + return _Contract.Contract.SlotSnapshotterMapping(&_Contract.CallOpts, slotId) +} + +// SlotSnapshotterMapping is a free data retrieval call binding the contract method 0x948a463e. +// +// Solidity: function slotSnapshotterMapping(uint256 slotId) view returns(address) +func (_Contract *ContractCallerSession) SlotSnapshotterMapping(slotId *big.Int) (common.Address, error) { + return _Contract.Contract.SlotSnapshotterMapping(&_Contract.CallOpts, slotId) +} + +// SlotSubmissionCount is a free data retrieval call binding the contract method 0x7f9ee950. +// +// Solidity: function slotSubmissionCount(address dataMarket, uint256 slotId, uint256 dayId) view returns(uint256) +func (_Contract *ContractCaller) SlotSubmissionCount(opts *bind.CallOpts, dataMarket common.Address, slotId *big.Int, dayId *big.Int) (*big.Int, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "slotSubmissionCount", dataMarket, slotId, dayId) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// SlotSubmissionCount is a free data retrieval call binding the contract method 0x7f9ee950. +// +// Solidity: function slotSubmissionCount(address dataMarket, uint256 slotId, uint256 dayId) view returns(uint256) +func (_Contract *ContractSession) SlotSubmissionCount(dataMarket common.Address, slotId *big.Int, dayId *big.Int) (*big.Int, error) { + return _Contract.Contract.SlotSubmissionCount(&_Contract.CallOpts, dataMarket, slotId, dayId) +} + +// SlotSubmissionCount is a free data retrieval call binding the contract method 0x7f9ee950. +// +// Solidity: function slotSubmissionCount(address dataMarket, uint256 slotId, uint256 dayId) view returns(uint256) +func (_Contract *ContractCallerSession) SlotSubmissionCount(dataMarket common.Address, slotId *big.Int, dayId *big.Int) (*big.Int, error) { + return _Contract.Contract.SlotSubmissionCount(&_Contract.CallOpts, dataMarket, slotId, dayId) +} + +// SnapshotStatus is a free data retrieval call binding the contract method 0x1f588588. +// +// Solidity: function snapshotStatus(address dataMarket, string projectId, uint256 epochId) view returns(uint8 status, string snapshotCid, uint256 timestamp) +func (_Contract *ContractCaller) SnapshotStatus(opts *bind.CallOpts, dataMarket common.Address, projectId string, epochId *big.Int) (struct { + Status uint8 + SnapshotCid string + Timestamp *big.Int +}, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "snapshotStatus", dataMarket, projectId, epochId) + + outstruct := new(struct { + Status uint8 + SnapshotCid string + Timestamp *big.Int + }) + if err != nil { + return *outstruct, err + } + + outstruct.Status = *abi.ConvertType(out[0], new(uint8)).(*uint8) + outstruct.SnapshotCid = *abi.ConvertType(out[1], new(string)).(*string) + outstruct.Timestamp = *abi.ConvertType(out[2], new(*big.Int)).(**big.Int) + + return *outstruct, err + +} + +// SnapshotStatus is a free data retrieval call binding the contract method 0x1f588588. +// +// Solidity: function snapshotStatus(address dataMarket, string projectId, uint256 epochId) view returns(uint8 status, string snapshotCid, uint256 timestamp) +func (_Contract *ContractSession) SnapshotStatus(dataMarket common.Address, projectId string, epochId *big.Int) (struct { + Status uint8 + SnapshotCid string + Timestamp *big.Int +}, error) { + return _Contract.Contract.SnapshotStatus(&_Contract.CallOpts, dataMarket, projectId, epochId) +} + +// SnapshotStatus is a free data retrieval call binding the contract method 0x1f588588. +// +// Solidity: function snapshotStatus(address dataMarket, string projectId, uint256 epochId) view returns(uint8 status, string snapshotCid, uint256 timestamp) +func (_Contract *ContractCallerSession) SnapshotStatus(dataMarket common.Address, projectId string, epochId *big.Int) (struct { + Status uint8 + SnapshotCid string + Timestamp *big.Int +}, error) { + return _Contract.Contract.SnapshotStatus(&_Contract.CallOpts, dataMarket, projectId, epochId) +} + +// SnapshotSubmissionWindow is a free data retrieval call binding the contract method 0xf3354db0. +// +// Solidity: function snapshotSubmissionWindow(address dataMarket) view returns(uint256) +func (_Contract *ContractCaller) SnapshotSubmissionWindow(opts *bind.CallOpts, dataMarket common.Address) (*big.Int, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "snapshotSubmissionWindow", dataMarket) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// SnapshotSubmissionWindow is a free data retrieval call binding the contract method 0xf3354db0. +// +// Solidity: function snapshotSubmissionWindow(address dataMarket) view returns(uint256) +func (_Contract *ContractSession) SnapshotSubmissionWindow(dataMarket common.Address) (*big.Int, error) { + return _Contract.Contract.SnapshotSubmissionWindow(&_Contract.CallOpts, dataMarket) +} + +// SnapshotSubmissionWindow is a free data retrieval call binding the contract method 0xf3354db0. +// +// Solidity: function snapshotSubmissionWindow(address dataMarket) view returns(uint256) +func (_Contract *ContractCallerSession) SnapshotSubmissionWindow(dataMarket common.Address) (*big.Int, error) { + return _Contract.Contract.SnapshotSubmissionWindow(&_Contract.CallOpts, dataMarket) +} + +// SnapshotterState is a free data retrieval call binding the contract method 0x342050cc. +// +// Solidity: function snapshotterState() view returns(address) +func (_Contract *ContractCaller) SnapshotterState(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Contract.contract.Call(opts, &out, "snapshotterState") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// SnapshotterState is a free data retrieval call binding the contract method 0x342050cc. +// +// Solidity: function snapshotterState() view returns(address) +func (_Contract *ContractSession) SnapshotterState() (common.Address, error) { + return _Contract.Contract.SnapshotterState(&_Contract.CallOpts) +} + +// SnapshotterState is a free data retrieval call binding the contract method 0x342050cc. +// +// Solidity: function snapshotterState() view returns(address) +func (_Contract *ContractCallerSession) SnapshotterState() (common.Address, error) { + return _Contract.Contract.SnapshotterState(&_Contract.CallOpts) +} + +// AssignSnapshotterToSlots is a paid mutator transaction binding the contract method 0xe2cb8d99. +// +// Solidity: function assignSnapshotterToSlots(uint256[] _slotIds, address[] _snapshotterAddresses) returns() +func (_Contract *ContractTransactor) AssignSnapshotterToSlots(opts *bind.TransactOpts, _slotIds []*big.Int, _snapshotterAddresses []common.Address) (*types.Transaction, error) { + return _Contract.contract.Transact(opts, "assignSnapshotterToSlots", _slotIds, _snapshotterAddresses) +} + +// AssignSnapshotterToSlots is a paid mutator transaction binding the contract method 0xe2cb8d99. +// +// Solidity: function assignSnapshotterToSlots(uint256[] _slotIds, address[] _snapshotterAddresses) returns() +func (_Contract *ContractSession) AssignSnapshotterToSlots(_slotIds []*big.Int, _snapshotterAddresses []common.Address) (*types.Transaction, error) { + return _Contract.Contract.AssignSnapshotterToSlots(&_Contract.TransactOpts, _slotIds, _snapshotterAddresses) +} + +// AssignSnapshotterToSlots is a paid mutator transaction binding the contract method 0xe2cb8d99. +// +// Solidity: function assignSnapshotterToSlots(uint256[] _slotIds, address[] _snapshotterAddresses) returns() +func (_Contract *ContractTransactorSession) AssignSnapshotterToSlots(_slotIds []*big.Int, _snapshotterAddresses []common.Address) (*types.Transaction, error) { + return _Contract.Contract.AssignSnapshotterToSlots(&_Contract.TransactOpts, _slotIds, _snapshotterAddresses) +} + +// CreateDataMarket is a paid mutator transaction binding the contract method 0x1dbc586b. +// +// Solidity: function createDataMarket(address ownerAddress, uint8 epochSize, uint256 sourceChainId, uint256 sourceChainBlockTime, bool useBlockNumberAsEpochId) returns(address) +func (_Contract *ContractTransactor) CreateDataMarket(opts *bind.TransactOpts, ownerAddress common.Address, epochSize uint8, sourceChainId *big.Int, sourceChainBlockTime *big.Int, useBlockNumberAsEpochId bool) (*types.Transaction, error) { + return _Contract.contract.Transact(opts, "createDataMarket", ownerAddress, epochSize, sourceChainId, sourceChainBlockTime, useBlockNumberAsEpochId) +} + +// CreateDataMarket is a paid mutator transaction binding the contract method 0x1dbc586b. +// +// Solidity: function createDataMarket(address ownerAddress, uint8 epochSize, uint256 sourceChainId, uint256 sourceChainBlockTime, bool useBlockNumberAsEpochId) returns(address) +func (_Contract *ContractSession) CreateDataMarket(ownerAddress common.Address, epochSize uint8, sourceChainId *big.Int, sourceChainBlockTime *big.Int, useBlockNumberAsEpochId bool) (*types.Transaction, error) { + return _Contract.Contract.CreateDataMarket(&_Contract.TransactOpts, ownerAddress, epochSize, sourceChainId, sourceChainBlockTime, useBlockNumberAsEpochId) +} + +// CreateDataMarket is a paid mutator transaction binding the contract method 0x1dbc586b. +// +// Solidity: function createDataMarket(address ownerAddress, uint8 epochSize, uint256 sourceChainId, uint256 sourceChainBlockTime, bool useBlockNumberAsEpochId) returns(address) +func (_Contract *ContractTransactorSession) CreateDataMarket(ownerAddress common.Address, epochSize uint8, sourceChainId *big.Int, sourceChainBlockTime *big.Int, useBlockNumberAsEpochId bool) (*types.Transaction, error) { + return _Contract.Contract.CreateDataMarket(&_Contract.TransactOpts, ownerAddress, epochSize, sourceChainId, sourceChainBlockTime, useBlockNumberAsEpochId) +} + +// EndBatchSubmissions is a paid mutator transaction binding the contract method 0x6ee55d73. +// +// Solidity: function endBatchSubmissions(address dataMarket, uint256 epochId) returns() +func (_Contract *ContractTransactor) EndBatchSubmissions(opts *bind.TransactOpts, dataMarket common.Address, epochId *big.Int) (*types.Transaction, error) { + return _Contract.contract.Transact(opts, "endBatchSubmissions", dataMarket, epochId) +} + +// EndBatchSubmissions is a paid mutator transaction binding the contract method 0x6ee55d73. +// +// Solidity: function endBatchSubmissions(address dataMarket, uint256 epochId) returns() +func (_Contract *ContractSession) EndBatchSubmissions(dataMarket common.Address, epochId *big.Int) (*types.Transaction, error) { + return _Contract.Contract.EndBatchSubmissions(&_Contract.TransactOpts, dataMarket, epochId) +} + +// EndBatchSubmissions is a paid mutator transaction binding the contract method 0x6ee55d73. +// +// Solidity: function endBatchSubmissions(address dataMarket, uint256 epochId) returns() +func (_Contract *ContractTransactorSession) EndBatchSubmissions(dataMarket common.Address, epochId *big.Int) (*types.Transaction, error) { + return _Contract.Contract.EndBatchSubmissions(&_Contract.TransactOpts, dataMarket, epochId) +} + +// ForceCompleteConsensusAttestations is a paid mutator transaction binding the contract method 0x05237c1b. +// +// Solidity: function forceCompleteConsensusAttestations(address dataMarket, uint256 batchId, uint256 epochId) returns() +func (_Contract *ContractTransactor) ForceCompleteConsensusAttestations(opts *bind.TransactOpts, dataMarket common.Address, batchId *big.Int, epochId *big.Int) (*types.Transaction, error) { + return _Contract.contract.Transact(opts, "forceCompleteConsensusAttestations", dataMarket, batchId, epochId) +} + +// ForceCompleteConsensusAttestations is a paid mutator transaction binding the contract method 0x05237c1b. +// +// Solidity: function forceCompleteConsensusAttestations(address dataMarket, uint256 batchId, uint256 epochId) returns() +func (_Contract *ContractSession) ForceCompleteConsensusAttestations(dataMarket common.Address, batchId *big.Int, epochId *big.Int) (*types.Transaction, error) { + return _Contract.Contract.ForceCompleteConsensusAttestations(&_Contract.TransactOpts, dataMarket, batchId, epochId) +} + +// ForceCompleteConsensusAttestations is a paid mutator transaction binding the contract method 0x05237c1b. +// +// Solidity: function forceCompleteConsensusAttestations(address dataMarket, uint256 batchId, uint256 epochId) returns() +func (_Contract *ContractTransactorSession) ForceCompleteConsensusAttestations(dataMarket common.Address, batchId *big.Int, epochId *big.Int) (*types.Transaction, error) { + return _Contract.Contract.ForceCompleteConsensusAttestations(&_Contract.TransactOpts, dataMarket, batchId, epochId) +} + +// ForceSkipEpoch is a paid mutator transaction binding the contract method 0x27856ff3. +// +// Solidity: function forceSkipEpoch(address dataMarket, uint256 begin, uint256 end) returns() +func (_Contract *ContractTransactor) ForceSkipEpoch(opts *bind.TransactOpts, dataMarket common.Address, begin *big.Int, end *big.Int) (*types.Transaction, error) { + return _Contract.contract.Transact(opts, "forceSkipEpoch", dataMarket, begin, end) +} + +// ForceSkipEpoch is a paid mutator transaction binding the contract method 0x27856ff3. +// +// Solidity: function forceSkipEpoch(address dataMarket, uint256 begin, uint256 end) returns() +func (_Contract *ContractSession) ForceSkipEpoch(dataMarket common.Address, begin *big.Int, end *big.Int) (*types.Transaction, error) { + return _Contract.Contract.ForceSkipEpoch(&_Contract.TransactOpts, dataMarket, begin, end) +} + +// ForceSkipEpoch is a paid mutator transaction binding the contract method 0x27856ff3. +// +// Solidity: function forceSkipEpoch(address dataMarket, uint256 begin, uint256 end) returns() +func (_Contract *ContractTransactorSession) ForceSkipEpoch(dataMarket common.Address, begin *big.Int, end *big.Int) (*types.Transaction, error) { + return _Contract.Contract.ForceSkipEpoch(&_Contract.TransactOpts, dataMarket, begin, end) +} + +// Initialize is a paid mutator transaction binding the contract method 0xc4d66de8. +// +// Solidity: function initialize(address initialOwner) returns() +func (_Contract *ContractTransactor) Initialize(opts *bind.TransactOpts, initialOwner common.Address) (*types.Transaction, error) { + return _Contract.contract.Transact(opts, "initialize", initialOwner) +} + +// Initialize is a paid mutator transaction binding the contract method 0xc4d66de8. +// +// Solidity: function initialize(address initialOwner) returns() +func (_Contract *ContractSession) Initialize(initialOwner common.Address) (*types.Transaction, error) { + return _Contract.Contract.Initialize(&_Contract.TransactOpts, initialOwner) +} + +// Initialize is a paid mutator transaction binding the contract method 0xc4d66de8. +// +// Solidity: function initialize(address initialOwner) returns() +func (_Contract *ContractTransactorSession) Initialize(initialOwner common.Address) (*types.Transaction, error) { + return _Contract.Contract.Initialize(&_Contract.TransactOpts, initialOwner) +} + +// LoadCurrentDay is a paid mutator transaction binding the contract method 0x59c60b30. +// +// Solidity: function loadCurrentDay(address dataMarket, uint256 _dayCounter) returns() +func (_Contract *ContractTransactor) LoadCurrentDay(opts *bind.TransactOpts, dataMarket common.Address, _dayCounter *big.Int) (*types.Transaction, error) { + return _Contract.contract.Transact(opts, "loadCurrentDay", dataMarket, _dayCounter) +} + +// LoadCurrentDay is a paid mutator transaction binding the contract method 0x59c60b30. +// +// Solidity: function loadCurrentDay(address dataMarket, uint256 _dayCounter) returns() +func (_Contract *ContractSession) LoadCurrentDay(dataMarket common.Address, _dayCounter *big.Int) (*types.Transaction, error) { + return _Contract.Contract.LoadCurrentDay(&_Contract.TransactOpts, dataMarket, _dayCounter) +} + +// LoadCurrentDay is a paid mutator transaction binding the contract method 0x59c60b30. +// +// Solidity: function loadCurrentDay(address dataMarket, uint256 _dayCounter) returns() +func (_Contract *ContractTransactorSession) LoadCurrentDay(dataMarket common.Address, _dayCounter *big.Int) (*types.Transaction, error) { + return _Contract.Contract.LoadCurrentDay(&_Contract.TransactOpts, dataMarket, _dayCounter) +} + +// LoadSlotSubmissions is a paid mutator transaction binding the contract method 0xa1ac8af0. +// +// Solidity: function loadSlotSubmissions(address dataMarket, uint256 slotId, uint256 dayId, uint256 snapshotCount) returns() +func (_Contract *ContractTransactor) LoadSlotSubmissions(opts *bind.TransactOpts, dataMarket common.Address, slotId *big.Int, dayId *big.Int, snapshotCount *big.Int) (*types.Transaction, error) { + return _Contract.contract.Transact(opts, "loadSlotSubmissions", dataMarket, slotId, dayId, snapshotCount) +} + +// LoadSlotSubmissions is a paid mutator transaction binding the contract method 0xa1ac8af0. +// +// Solidity: function loadSlotSubmissions(address dataMarket, uint256 slotId, uint256 dayId, uint256 snapshotCount) returns() +func (_Contract *ContractSession) LoadSlotSubmissions(dataMarket common.Address, slotId *big.Int, dayId *big.Int, snapshotCount *big.Int) (*types.Transaction, error) { + return _Contract.Contract.LoadSlotSubmissions(&_Contract.TransactOpts, dataMarket, slotId, dayId, snapshotCount) +} + +// LoadSlotSubmissions is a paid mutator transaction binding the contract method 0xa1ac8af0. +// +// Solidity: function loadSlotSubmissions(address dataMarket, uint256 slotId, uint256 dayId, uint256 snapshotCount) returns() +func (_Contract *ContractTransactorSession) LoadSlotSubmissions(dataMarket common.Address, slotId *big.Int, dayId *big.Int, snapshotCount *big.Int) (*types.Transaction, error) { + return _Contract.Contract.LoadSlotSubmissions(&_Contract.TransactOpts, dataMarket, slotId, dayId, snapshotCount) +} + +// ReleaseEpoch is a paid mutator transaction binding the contract method 0x09517cb6. +// +// Solidity: function releaseEpoch(address dataMarket, uint256 begin, uint256 end) returns() +func (_Contract *ContractTransactor) ReleaseEpoch(opts *bind.TransactOpts, dataMarket common.Address, begin *big.Int, end *big.Int) (*types.Transaction, error) { + return _Contract.contract.Transact(opts, "releaseEpoch", dataMarket, begin, end) +} + +// ReleaseEpoch is a paid mutator transaction binding the contract method 0x09517cb6. +// +// Solidity: function releaseEpoch(address dataMarket, uint256 begin, uint256 end) returns() +func (_Contract *ContractSession) ReleaseEpoch(dataMarket common.Address, begin *big.Int, end *big.Int) (*types.Transaction, error) { + return _Contract.Contract.ReleaseEpoch(&_Contract.TransactOpts, dataMarket, begin, end) +} + +// ReleaseEpoch is a paid mutator transaction binding the contract method 0x09517cb6. +// +// Solidity: function releaseEpoch(address dataMarket, uint256 begin, uint256 end) returns() +func (_Contract *ContractTransactorSession) ReleaseEpoch(dataMarket common.Address, begin *big.Int, end *big.Int) (*types.Transaction, error) { + return _Contract.Contract.ReleaseEpoch(&_Contract.TransactOpts, dataMarket, begin, end) +} + +// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. +// +// Solidity: function renounceOwnership() returns() +func (_Contract *ContractTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Contract.contract.Transact(opts, "renounceOwnership") +} + +// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. +// +// Solidity: function renounceOwnership() returns() +func (_Contract *ContractSession) RenounceOwnership() (*types.Transaction, error) { + return _Contract.Contract.RenounceOwnership(&_Contract.TransactOpts) +} + +// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. +// +// Solidity: function renounceOwnership() returns() +func (_Contract *ContractTransactorSession) RenounceOwnership() (*types.Transaction, error) { + return _Contract.Contract.RenounceOwnership(&_Contract.TransactOpts) +} + +// SetSequencerId is a paid mutator transaction binding the contract method 0x79d01175. +// +// Solidity: function setSequencerId(address dataMarket, string _sequencerId) returns() +func (_Contract *ContractTransactor) SetSequencerId(opts *bind.TransactOpts, dataMarket common.Address, _sequencerId string) (*types.Transaction, error) { + return _Contract.contract.Transact(opts, "setSequencerId", dataMarket, _sequencerId) +} + +// SetSequencerId is a paid mutator transaction binding the contract method 0x79d01175. +// +// Solidity: function setSequencerId(address dataMarket, string _sequencerId) returns() +func (_Contract *ContractSession) SetSequencerId(dataMarket common.Address, _sequencerId string) (*types.Transaction, error) { + return _Contract.Contract.SetSequencerId(&_Contract.TransactOpts, dataMarket, _sequencerId) +} + +// SetSequencerId is a paid mutator transaction binding the contract method 0x79d01175. +// +// Solidity: function setSequencerId(address dataMarket, string _sequencerId) returns() +func (_Contract *ContractTransactorSession) SetSequencerId(dataMarket common.Address, _sequencerId string) (*types.Transaction, error) { + return _Contract.Contract.SetSequencerId(&_Contract.TransactOpts, dataMarket, _sequencerId) +} + +// SubmitBatchAttestation is a paid mutator transaction binding the contract method 0x31632255. +// +// Solidity: function submitBatchAttestation(address dataMarket, uint256 batchId, uint256 epochId, bytes32 finalizedCidsRootHash) returns() +func (_Contract *ContractTransactor) SubmitBatchAttestation(opts *bind.TransactOpts, dataMarket common.Address, batchId *big.Int, epochId *big.Int, finalizedCidsRootHash [32]byte) (*types.Transaction, error) { + return _Contract.contract.Transact(opts, "submitBatchAttestation", dataMarket, batchId, epochId, finalizedCidsRootHash) +} + +// SubmitBatchAttestation is a paid mutator transaction binding the contract method 0x31632255. +// +// Solidity: function submitBatchAttestation(address dataMarket, uint256 batchId, uint256 epochId, bytes32 finalizedCidsRootHash) returns() +func (_Contract *ContractSession) SubmitBatchAttestation(dataMarket common.Address, batchId *big.Int, epochId *big.Int, finalizedCidsRootHash [32]byte) (*types.Transaction, error) { + return _Contract.Contract.SubmitBatchAttestation(&_Contract.TransactOpts, dataMarket, batchId, epochId, finalizedCidsRootHash) +} + +// SubmitBatchAttestation is a paid mutator transaction binding the contract method 0x31632255. +// +// Solidity: function submitBatchAttestation(address dataMarket, uint256 batchId, uint256 epochId, bytes32 finalizedCidsRootHash) returns() +func (_Contract *ContractTransactorSession) SubmitBatchAttestation(dataMarket common.Address, batchId *big.Int, epochId *big.Int, finalizedCidsRootHash [32]byte) (*types.Transaction, error) { + return _Contract.Contract.SubmitBatchAttestation(&_Contract.TransactOpts, dataMarket, batchId, epochId, finalizedCidsRootHash) +} + +// SubmitSnapshot is a paid mutator transaction binding the contract method 0x5678a9d5. +// +// Solidity: function submitSnapshot(address dataMarket, uint256 slotId, string snapshotCid, uint256 epochId, string projectId, (uint256,uint256,string,uint256,string) request, bytes signature) returns() +func (_Contract *ContractTransactor) SubmitSnapshot(opts *bind.TransactOpts, dataMarket common.Address, slotId *big.Int, snapshotCid string, epochId *big.Int, projectId string, request PowerloomDataMarketRequest, signature []byte) (*types.Transaction, error) { + return _Contract.contract.Transact(opts, "submitSnapshot", dataMarket, slotId, snapshotCid, epochId, projectId, request, signature) +} + +// SubmitSnapshot is a paid mutator transaction binding the contract method 0x5678a9d5. +// +// Solidity: function submitSnapshot(address dataMarket, uint256 slotId, string snapshotCid, uint256 epochId, string projectId, (uint256,uint256,string,uint256,string) request, bytes signature) returns() +func (_Contract *ContractSession) SubmitSnapshot(dataMarket common.Address, slotId *big.Int, snapshotCid string, epochId *big.Int, projectId string, request PowerloomDataMarketRequest, signature []byte) (*types.Transaction, error) { + return _Contract.Contract.SubmitSnapshot(&_Contract.TransactOpts, dataMarket, slotId, snapshotCid, epochId, projectId, request, signature) +} + +// SubmitSnapshot is a paid mutator transaction binding the contract method 0x5678a9d5. +// +// Solidity: function submitSnapshot(address dataMarket, uint256 slotId, string snapshotCid, uint256 epochId, string projectId, (uint256,uint256,string,uint256,string) request, bytes signature) returns() +func (_Contract *ContractTransactorSession) SubmitSnapshot(dataMarket common.Address, slotId *big.Int, snapshotCid string, epochId *big.Int, projectId string, request PowerloomDataMarketRequest, signature []byte) (*types.Transaction, error) { + return _Contract.Contract.SubmitSnapshot(&_Contract.TransactOpts, dataMarket, slotId, snapshotCid, epochId, projectId, request, signature) +} + +// SubmitSubmissionBatch is a paid mutator transaction binding the contract method 0xc19e74d9. +// +// Solidity: function submitSubmissionBatch(address dataMarket, string batchCid, uint256 batchId, uint256 epochId, string[] projectIds, string[] snapshotCids, bytes32 finalizedCidsRootHash) returns() +func (_Contract *ContractTransactor) SubmitSubmissionBatch(opts *bind.TransactOpts, dataMarket common.Address, batchCid string, batchId *big.Int, epochId *big.Int, projectIds []string, snapshotCids []string, finalizedCidsRootHash [32]byte) (*types.Transaction, error) { + return _Contract.contract.Transact(opts, "submitSubmissionBatch", dataMarket, batchCid, batchId, epochId, projectIds, snapshotCids, finalizedCidsRootHash) +} + +// SubmitSubmissionBatch is a paid mutator transaction binding the contract method 0xc19e74d9. +// +// Solidity: function submitSubmissionBatch(address dataMarket, string batchCid, uint256 batchId, uint256 epochId, string[] projectIds, string[] snapshotCids, bytes32 finalizedCidsRootHash) returns() +func (_Contract *ContractSession) SubmitSubmissionBatch(dataMarket common.Address, batchCid string, batchId *big.Int, epochId *big.Int, projectIds []string, snapshotCids []string, finalizedCidsRootHash [32]byte) (*types.Transaction, error) { + return _Contract.Contract.SubmitSubmissionBatch(&_Contract.TransactOpts, dataMarket, batchCid, batchId, epochId, projectIds, snapshotCids, finalizedCidsRootHash) +} + +// SubmitSubmissionBatch is a paid mutator transaction binding the contract method 0xc19e74d9. +// +// Solidity: function submitSubmissionBatch(address dataMarket, string batchCid, uint256 batchId, uint256 epochId, string[] projectIds, string[] snapshotCids, bytes32 finalizedCidsRootHash) returns() +func (_Contract *ContractTransactorSession) SubmitSubmissionBatch(dataMarket common.Address, batchCid string, batchId *big.Int, epochId *big.Int, projectIds []string, snapshotCids []string, finalizedCidsRootHash [32]byte) (*types.Transaction, error) { + return _Contract.Contract.SubmitSubmissionBatch(&_Contract.TransactOpts, dataMarket, batchCid, batchId, epochId, projectIds, snapshotCids, finalizedCidsRootHash) +} + +// ToggleDataMarket is a paid mutator transaction binding the contract method 0xb34aebca. +// +// Solidity: function toggleDataMarket(address dataMarketAddress, bool enabled) returns() +func (_Contract *ContractTransactor) ToggleDataMarket(opts *bind.TransactOpts, dataMarketAddress common.Address, enabled bool) (*types.Transaction, error) { + return _Contract.contract.Transact(opts, "toggleDataMarket", dataMarketAddress, enabled) +} + +// ToggleDataMarket is a paid mutator transaction binding the contract method 0xb34aebca. +// +// Solidity: function toggleDataMarket(address dataMarketAddress, bool enabled) returns() +func (_Contract *ContractSession) ToggleDataMarket(dataMarketAddress common.Address, enabled bool) (*types.Transaction, error) { + return _Contract.Contract.ToggleDataMarket(&_Contract.TransactOpts, dataMarketAddress, enabled) +} + +// ToggleDataMarket is a paid mutator transaction binding the contract method 0xb34aebca. +// +// Solidity: function toggleDataMarket(address dataMarketAddress, bool enabled) returns() +func (_Contract *ContractTransactorSession) ToggleDataMarket(dataMarketAddress common.Address, enabled bool) (*types.Transaction, error) { + return _Contract.Contract.ToggleDataMarket(&_Contract.TransactOpts, dataMarketAddress, enabled) +} + +// ToggleFallback is a paid mutator transaction binding the contract method 0x32f6f519. +// +// Solidity: function toggleFallback(address dataMarket) returns() +func (_Contract *ContractTransactor) ToggleFallback(opts *bind.TransactOpts, dataMarket common.Address) (*types.Transaction, error) { + return _Contract.contract.Transact(opts, "toggleFallback", dataMarket) +} + +// ToggleFallback is a paid mutator transaction binding the contract method 0x32f6f519. +// +// Solidity: function toggleFallback(address dataMarket) returns() +func (_Contract *ContractSession) ToggleFallback(dataMarket common.Address) (*types.Transaction, error) { + return _Contract.Contract.ToggleFallback(&_Contract.TransactOpts, dataMarket) +} + +// ToggleFallback is a paid mutator transaction binding the contract method 0x32f6f519. +// +// Solidity: function toggleFallback(address dataMarket) returns() +func (_Contract *ContractTransactorSession) ToggleFallback(dataMarket common.Address) (*types.Transaction, error) { + return _Contract.Contract.ToggleFallback(&_Contract.TransactOpts, dataMarket) +} + +// ToggleRewards is a paid mutator transaction binding the contract method 0x71746644. +// +// Solidity: function toggleRewards(address dataMarket) returns() +func (_Contract *ContractTransactor) ToggleRewards(opts *bind.TransactOpts, dataMarket common.Address) (*types.Transaction, error) { + return _Contract.contract.Transact(opts, "toggleRewards", dataMarket) +} + +// ToggleRewards is a paid mutator transaction binding the contract method 0x71746644. +// +// Solidity: function toggleRewards(address dataMarket) returns() +func (_Contract *ContractSession) ToggleRewards(dataMarket common.Address) (*types.Transaction, error) { + return _Contract.Contract.ToggleRewards(&_Contract.TransactOpts, dataMarket) +} + +// ToggleRewards is a paid mutator transaction binding the contract method 0x71746644. +// +// Solidity: function toggleRewards(address dataMarket) returns() +func (_Contract *ContractTransactorSession) ToggleRewards(dataMarket common.Address) (*types.Transaction, error) { + return _Contract.Contract.ToggleRewards(&_Contract.TransactOpts, dataMarket) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_Contract *ContractTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { + return _Contract.contract.Transact(opts, "transferOwnership", newOwner) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_Contract *ContractSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _Contract.Contract.TransferOwnership(&_Contract.TransactOpts, newOwner) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_Contract *ContractTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _Contract.Contract.TransferOwnership(&_Contract.TransactOpts, newOwner) +} + +// UpdateAddresses is a paid mutator transaction binding the contract method 0x8d3bcb5a. +// +// Solidity: function updateAddresses(address dataMarket, uint8 role, address[] _addresses, bool[] _status) returns() +func (_Contract *ContractTransactor) UpdateAddresses(opts *bind.TransactOpts, dataMarket common.Address, role uint8, _addresses []common.Address, _status []bool) (*types.Transaction, error) { + return _Contract.contract.Transact(opts, "updateAddresses", dataMarket, role, _addresses, _status) +} + +// UpdateAddresses is a paid mutator transaction binding the contract method 0x8d3bcb5a. +// +// Solidity: function updateAddresses(address dataMarket, uint8 role, address[] _addresses, bool[] _status) returns() +func (_Contract *ContractSession) UpdateAddresses(dataMarket common.Address, role uint8, _addresses []common.Address, _status []bool) (*types.Transaction, error) { + return _Contract.Contract.UpdateAddresses(&_Contract.TransactOpts, dataMarket, role, _addresses, _status) +} + +// UpdateAddresses is a paid mutator transaction binding the contract method 0x8d3bcb5a. +// +// Solidity: function updateAddresses(address dataMarket, uint8 role, address[] _addresses, bool[] _status) returns() +func (_Contract *ContractTransactorSession) UpdateAddresses(dataMarket common.Address, role uint8, _addresses []common.Address, _status []bool) (*types.Transaction, error) { + return _Contract.Contract.UpdateAddresses(&_Contract.TransactOpts, dataMarket, role, _addresses, _status) +} + +// UpdateAllowedProjectType is a paid mutator transaction binding the contract method 0xb1a3f28d. +// +// Solidity: function updateAllowedProjectType(address dataMarket, string _projectType, bool _status) returns() +func (_Contract *ContractTransactor) UpdateAllowedProjectType(opts *bind.TransactOpts, dataMarket common.Address, _projectType string, _status bool) (*types.Transaction, error) { + return _Contract.contract.Transact(opts, "updateAllowedProjectType", dataMarket, _projectType, _status) +} + +// UpdateAllowedProjectType is a paid mutator transaction binding the contract method 0xb1a3f28d. +// +// Solidity: function updateAllowedProjectType(address dataMarket, string _projectType, bool _status) returns() +func (_Contract *ContractSession) UpdateAllowedProjectType(dataMarket common.Address, _projectType string, _status bool) (*types.Transaction, error) { + return _Contract.Contract.UpdateAllowedProjectType(&_Contract.TransactOpts, dataMarket, _projectType, _status) +} + +// UpdateAllowedProjectType is a paid mutator transaction binding the contract method 0xb1a3f28d. +// +// Solidity: function updateAllowedProjectType(address dataMarket, string _projectType, bool _status) returns() +func (_Contract *ContractTransactorSession) UpdateAllowedProjectType(dataMarket common.Address, _projectType string, _status bool) (*types.Transaction, error) { + return _Contract.Contract.UpdateAllowedProjectType(&_Contract.TransactOpts, dataMarket, _projectType, _status) +} + +// UpdateAttestationSubmissionWindow is a paid mutator transaction binding the contract method 0x89afe86a. +// +// Solidity: function updateAttestationSubmissionWindow(address dataMarket, uint256 newattestationSubmissionWindow) returns() +func (_Contract *ContractTransactor) UpdateAttestationSubmissionWindow(opts *bind.TransactOpts, dataMarket common.Address, newattestationSubmissionWindow *big.Int) (*types.Transaction, error) { + return _Contract.contract.Transact(opts, "updateAttestationSubmissionWindow", dataMarket, newattestationSubmissionWindow) +} + +// UpdateAttestationSubmissionWindow is a paid mutator transaction binding the contract method 0x89afe86a. +// +// Solidity: function updateAttestationSubmissionWindow(address dataMarket, uint256 newattestationSubmissionWindow) returns() +func (_Contract *ContractSession) UpdateAttestationSubmissionWindow(dataMarket common.Address, newattestationSubmissionWindow *big.Int) (*types.Transaction, error) { + return _Contract.Contract.UpdateAttestationSubmissionWindow(&_Contract.TransactOpts, dataMarket, newattestationSubmissionWindow) +} + +// UpdateAttestationSubmissionWindow is a paid mutator transaction binding the contract method 0x89afe86a. +// +// Solidity: function updateAttestationSubmissionWindow(address dataMarket, uint256 newattestationSubmissionWindow) returns() +func (_Contract *ContractTransactorSession) UpdateAttestationSubmissionWindow(dataMarket common.Address, newattestationSubmissionWindow *big.Int) (*types.Transaction, error) { + return _Contract.Contract.UpdateAttestationSubmissionWindow(&_Contract.TransactOpts, dataMarket, newattestationSubmissionWindow) +} + +// UpdateBatchSubmissionWindow is a paid mutator transaction binding the contract method 0xd72e07fd. +// +// Solidity: function updateBatchSubmissionWindow(address dataMarket, uint256 newbatchSubmissionWindow) returns() +func (_Contract *ContractTransactor) UpdateBatchSubmissionWindow(opts *bind.TransactOpts, dataMarket common.Address, newbatchSubmissionWindow *big.Int) (*types.Transaction, error) { + return _Contract.contract.Transact(opts, "updateBatchSubmissionWindow", dataMarket, newbatchSubmissionWindow) +} + +// UpdateBatchSubmissionWindow is a paid mutator transaction binding the contract method 0xd72e07fd. +// +// Solidity: function updateBatchSubmissionWindow(address dataMarket, uint256 newbatchSubmissionWindow) returns() +func (_Contract *ContractSession) UpdateBatchSubmissionWindow(dataMarket common.Address, newbatchSubmissionWindow *big.Int) (*types.Transaction, error) { + return _Contract.Contract.UpdateBatchSubmissionWindow(&_Contract.TransactOpts, dataMarket, newbatchSubmissionWindow) +} + +// UpdateBatchSubmissionWindow is a paid mutator transaction binding the contract method 0xd72e07fd. +// +// Solidity: function updateBatchSubmissionWindow(address dataMarket, uint256 newbatchSubmissionWindow) returns() +func (_Contract *ContractTransactorSession) UpdateBatchSubmissionWindow(dataMarket common.Address, newbatchSubmissionWindow *big.Int) (*types.Transaction, error) { + return _Contract.Contract.UpdateBatchSubmissionWindow(&_Contract.TransactOpts, dataMarket, newbatchSubmissionWindow) +} + +// UpdateDailySnapshotQuota is a paid mutator transaction binding the contract method 0xeb4c8b89. +// +// Solidity: function updateDailySnapshotQuota(address dataMarket, uint256 dailySnapshotQuota) returns() +func (_Contract *ContractTransactor) UpdateDailySnapshotQuota(opts *bind.TransactOpts, dataMarket common.Address, dailySnapshotQuota *big.Int) (*types.Transaction, error) { + return _Contract.contract.Transact(opts, "updateDailySnapshotQuota", dataMarket, dailySnapshotQuota) +} + +// UpdateDailySnapshotQuota is a paid mutator transaction binding the contract method 0xeb4c8b89. +// +// Solidity: function updateDailySnapshotQuota(address dataMarket, uint256 dailySnapshotQuota) returns() +func (_Contract *ContractSession) UpdateDailySnapshotQuota(dataMarket common.Address, dailySnapshotQuota *big.Int) (*types.Transaction, error) { + return _Contract.Contract.UpdateDailySnapshotQuota(&_Contract.TransactOpts, dataMarket, dailySnapshotQuota) +} + +// UpdateDailySnapshotQuota is a paid mutator transaction binding the contract method 0xeb4c8b89. +// +// Solidity: function updateDailySnapshotQuota(address dataMarket, uint256 dailySnapshotQuota) returns() +func (_Contract *ContractTransactorSession) UpdateDailySnapshotQuota(dataMarket common.Address, dailySnapshotQuota *big.Int) (*types.Transaction, error) { + return _Contract.Contract.UpdateDailySnapshotQuota(&_Contract.TransactOpts, dataMarket, dailySnapshotQuota) +} + +// UpdateDataMarketFactory is a paid mutator transaction binding the contract method 0xb48753eb. +// +// Solidity: function updateDataMarketFactory(address _address) returns() +func (_Contract *ContractTransactor) UpdateDataMarketFactory(opts *bind.TransactOpts, _address common.Address) (*types.Transaction, error) { + return _Contract.contract.Transact(opts, "updateDataMarketFactory", _address) +} + +// UpdateDataMarketFactory is a paid mutator transaction binding the contract method 0xb48753eb. +// +// Solidity: function updateDataMarketFactory(address _address) returns() +func (_Contract *ContractSession) UpdateDataMarketFactory(_address common.Address) (*types.Transaction, error) { + return _Contract.Contract.UpdateDataMarketFactory(&_Contract.TransactOpts, _address) +} + +// UpdateDataMarketFactory is a paid mutator transaction binding the contract method 0xb48753eb. +// +// Solidity: function updateDataMarketFactory(address _address) returns() +func (_Contract *ContractTransactorSession) UpdateDataMarketFactory(_address common.Address) (*types.Transaction, error) { + return _Contract.Contract.UpdateDataMarketFactory(&_Contract.TransactOpts, _address) +} + +// UpdateEpochManager is a paid mutator transaction binding the contract method 0x6e81f234. +// +// Solidity: function updateEpochManager(address dataMarket, address _address) returns() +func (_Contract *ContractTransactor) UpdateEpochManager(opts *bind.TransactOpts, dataMarket common.Address, _address common.Address) (*types.Transaction, error) { + return _Contract.contract.Transact(opts, "updateEpochManager", dataMarket, _address) +} + +// UpdateEpochManager is a paid mutator transaction binding the contract method 0x6e81f234. +// +// Solidity: function updateEpochManager(address dataMarket, address _address) returns() +func (_Contract *ContractSession) UpdateEpochManager(dataMarket common.Address, _address common.Address) (*types.Transaction, error) { + return _Contract.Contract.UpdateEpochManager(&_Contract.TransactOpts, dataMarket, _address) +} + +// UpdateEpochManager is a paid mutator transaction binding the contract method 0x6e81f234. +// +// Solidity: function updateEpochManager(address dataMarket, address _address) returns() +func (_Contract *ContractTransactorSession) UpdateEpochManager(dataMarket common.Address, _address common.Address) (*types.Transaction, error) { + return _Contract.Contract.UpdateEpochManager(&_Contract.TransactOpts, dataMarket, _address) +} + +// UpdateFallbackNodes is a paid mutator transaction binding the contract method 0x50304b62. +// +// Solidity: function updateFallbackNodes(address dataMarket, address[] _fallbackNodes, bool[] _status) returns() +func (_Contract *ContractTransactor) UpdateFallbackNodes(opts *bind.TransactOpts, dataMarket common.Address, _fallbackNodes []common.Address, _status []bool) (*types.Transaction, error) { + return _Contract.contract.Transact(opts, "updateFallbackNodes", dataMarket, _fallbackNodes, _status) +} + +// UpdateFallbackNodes is a paid mutator transaction binding the contract method 0x50304b62. +// +// Solidity: function updateFallbackNodes(address dataMarket, address[] _fallbackNodes, bool[] _status) returns() +func (_Contract *ContractSession) UpdateFallbackNodes(dataMarket common.Address, _fallbackNodes []common.Address, _status []bool) (*types.Transaction, error) { + return _Contract.Contract.UpdateFallbackNodes(&_Contract.TransactOpts, dataMarket, _fallbackNodes, _status) +} + +// UpdateFallbackNodes is a paid mutator transaction binding the contract method 0x50304b62. +// +// Solidity: function updateFallbackNodes(address dataMarket, address[] _fallbackNodes, bool[] _status) returns() +func (_Contract *ContractTransactorSession) UpdateFallbackNodes(dataMarket common.Address, _fallbackNodes []common.Address, _status []bool) (*types.Transaction, error) { + return _Contract.Contract.UpdateFallbackNodes(&_Contract.TransactOpts, dataMarket, _fallbackNodes, _status) +} + +// UpdateMinAttestationsForConsensus is a paid mutator transaction binding the contract method 0xe4578d51. +// +// Solidity: function updateMinAttestationsForConsensus(address dataMarket, uint256 _minAttestationsForConsensus) returns() +func (_Contract *ContractTransactor) UpdateMinAttestationsForConsensus(opts *bind.TransactOpts, dataMarket common.Address, _minAttestationsForConsensus *big.Int) (*types.Transaction, error) { + return _Contract.contract.Transact(opts, "updateMinAttestationsForConsensus", dataMarket, _minAttestationsForConsensus) +} + +// UpdateMinAttestationsForConsensus is a paid mutator transaction binding the contract method 0xe4578d51. +// +// Solidity: function updateMinAttestationsForConsensus(address dataMarket, uint256 _minAttestationsForConsensus) returns() +func (_Contract *ContractSession) UpdateMinAttestationsForConsensus(dataMarket common.Address, _minAttestationsForConsensus *big.Int) (*types.Transaction, error) { + return _Contract.Contract.UpdateMinAttestationsForConsensus(&_Contract.TransactOpts, dataMarket, _minAttestationsForConsensus) +} + +// UpdateMinAttestationsForConsensus is a paid mutator transaction binding the contract method 0xe4578d51. +// +// Solidity: function updateMinAttestationsForConsensus(address dataMarket, uint256 _minAttestationsForConsensus) returns() +func (_Contract *ContractTransactorSession) UpdateMinAttestationsForConsensus(dataMarket common.Address, _minAttestationsForConsensus *big.Int) (*types.Transaction, error) { + return _Contract.Contract.UpdateMinAttestationsForConsensus(&_Contract.TransactOpts, dataMarket, _minAttestationsForConsensus) +} + +// UpdateMinSnapshottersForConsensus is a paid mutator transaction binding the contract method 0x3cb782cd. +// +// Solidity: function updateMinSnapshottersForConsensus(address dataMarket, uint256 _minSubmissionsForConsensus) returns() +func (_Contract *ContractTransactor) UpdateMinSnapshottersForConsensus(opts *bind.TransactOpts, dataMarket common.Address, _minSubmissionsForConsensus *big.Int) (*types.Transaction, error) { + return _Contract.contract.Transact(opts, "updateMinSnapshottersForConsensus", dataMarket, _minSubmissionsForConsensus) +} + +// UpdateMinSnapshottersForConsensus is a paid mutator transaction binding the contract method 0x3cb782cd. +// +// Solidity: function updateMinSnapshottersForConsensus(address dataMarket, uint256 _minSubmissionsForConsensus) returns() +func (_Contract *ContractSession) UpdateMinSnapshottersForConsensus(dataMarket common.Address, _minSubmissionsForConsensus *big.Int) (*types.Transaction, error) { + return _Contract.Contract.UpdateMinSnapshottersForConsensus(&_Contract.TransactOpts, dataMarket, _minSubmissionsForConsensus) +} + +// UpdateMinSnapshottersForConsensus is a paid mutator transaction binding the contract method 0x3cb782cd. +// +// Solidity: function updateMinSnapshottersForConsensus(address dataMarket, uint256 _minSubmissionsForConsensus) returns() +func (_Contract *ContractTransactorSession) UpdateMinSnapshottersForConsensus(dataMarket common.Address, _minSubmissionsForConsensus *big.Int) (*types.Transaction, error) { + return _Contract.Contract.UpdateMinSnapshottersForConsensus(&_Contract.TransactOpts, dataMarket, _minSubmissionsForConsensus) +} + +// UpdateProjects is a paid mutator transaction binding the contract method 0x0589852d. +// +// Solidity: function updateProjects(address dataMarket, string[] _projects, bool[] _status) returns() +func (_Contract *ContractTransactor) UpdateProjects(opts *bind.TransactOpts, dataMarket common.Address, _projects []string, _status []bool) (*types.Transaction, error) { + return _Contract.contract.Transact(opts, "updateProjects", dataMarket, _projects, _status) +} + +// UpdateProjects is a paid mutator transaction binding the contract method 0x0589852d. +// +// Solidity: function updateProjects(address dataMarket, string[] _projects, bool[] _status) returns() +func (_Contract *ContractSession) UpdateProjects(dataMarket common.Address, _projects []string, _status []bool) (*types.Transaction, error) { + return _Contract.Contract.UpdateProjects(&_Contract.TransactOpts, dataMarket, _projects, _status) +} + +// UpdateProjects is a paid mutator transaction binding the contract method 0x0589852d. +// +// Solidity: function updateProjects(address dataMarket, string[] _projects, bool[] _status) returns() +func (_Contract *ContractTransactorSession) UpdateProjects(dataMarket common.Address, _projects []string, _status []bool) (*types.Transaction, error) { + return _Contract.Contract.UpdateProjects(&_Contract.TransactOpts, dataMarket, _projects, _status) +} + +// UpdateRewardBasePoints is a paid mutator transaction binding the contract method 0x7195df15. +// +// Solidity: function updateRewardBasePoints(address dataMarket, uint256 newRewardBasePoints) returns() +func (_Contract *ContractTransactor) UpdateRewardBasePoints(opts *bind.TransactOpts, dataMarket common.Address, newRewardBasePoints *big.Int) (*types.Transaction, error) { + return _Contract.contract.Transact(opts, "updateRewardBasePoints", dataMarket, newRewardBasePoints) +} + +// UpdateRewardBasePoints is a paid mutator transaction binding the contract method 0x7195df15. +// +// Solidity: function updateRewardBasePoints(address dataMarket, uint256 newRewardBasePoints) returns() +func (_Contract *ContractSession) UpdateRewardBasePoints(dataMarket common.Address, newRewardBasePoints *big.Int) (*types.Transaction, error) { + return _Contract.Contract.UpdateRewardBasePoints(&_Contract.TransactOpts, dataMarket, newRewardBasePoints) +} + +// UpdateRewardBasePoints is a paid mutator transaction binding the contract method 0x7195df15. +// +// Solidity: function updateRewardBasePoints(address dataMarket, uint256 newRewardBasePoints) returns() +func (_Contract *ContractTransactorSession) UpdateRewardBasePoints(dataMarket common.Address, newRewardBasePoints *big.Int) (*types.Transaction, error) { + return _Contract.Contract.UpdateRewardBasePoints(&_Contract.TransactOpts, dataMarket, newRewardBasePoints) +} + +// UpdateRewards is a paid mutator transaction binding the contract method 0x7d2bd53d. +// +// Solidity: function updateRewards(address dataMarket, uint256[] slotIds, uint256[] submissionsList, uint256 day) returns() +func (_Contract *ContractTransactor) UpdateRewards(opts *bind.TransactOpts, dataMarket common.Address, slotIds []*big.Int, submissionsList []*big.Int, day *big.Int) (*types.Transaction, error) { + return _Contract.contract.Transact(opts, "updateRewards", dataMarket, slotIds, submissionsList, day) +} + +// UpdateRewards is a paid mutator transaction binding the contract method 0x7d2bd53d. +// +// Solidity: function updateRewards(address dataMarket, uint256[] slotIds, uint256[] submissionsList, uint256 day) returns() +func (_Contract *ContractSession) UpdateRewards(dataMarket common.Address, slotIds []*big.Int, submissionsList []*big.Int, day *big.Int) (*types.Transaction, error) { + return _Contract.Contract.UpdateRewards(&_Contract.TransactOpts, dataMarket, slotIds, submissionsList, day) +} + +// UpdateRewards is a paid mutator transaction binding the contract method 0x7d2bd53d. +// +// Solidity: function updateRewards(address dataMarket, uint256[] slotIds, uint256[] submissionsList, uint256 day) returns() +func (_Contract *ContractTransactorSession) UpdateRewards(dataMarket common.Address, slotIds []*big.Int, submissionsList []*big.Int, day *big.Int) (*types.Transaction, error) { + return _Contract.Contract.UpdateRewards(&_Contract.TransactOpts, dataMarket, slotIds, submissionsList, day) +} + +// UpdateSnapshotSubmissionWindow is a paid mutator transaction binding the contract method 0xa02c3e9b. +// +// Solidity: function updateSnapshotSubmissionWindow(address dataMarket, uint256 newsnapshotSubmissionWindow) returns() +func (_Contract *ContractTransactor) UpdateSnapshotSubmissionWindow(opts *bind.TransactOpts, dataMarket common.Address, newsnapshotSubmissionWindow *big.Int) (*types.Transaction, error) { + return _Contract.contract.Transact(opts, "updateSnapshotSubmissionWindow", dataMarket, newsnapshotSubmissionWindow) +} + +// UpdateSnapshotSubmissionWindow is a paid mutator transaction binding the contract method 0xa02c3e9b. +// +// Solidity: function updateSnapshotSubmissionWindow(address dataMarket, uint256 newsnapshotSubmissionWindow) returns() +func (_Contract *ContractSession) UpdateSnapshotSubmissionWindow(dataMarket common.Address, newsnapshotSubmissionWindow *big.Int) (*types.Transaction, error) { + return _Contract.Contract.UpdateSnapshotSubmissionWindow(&_Contract.TransactOpts, dataMarket, newsnapshotSubmissionWindow) +} + +// UpdateSnapshotSubmissionWindow is a paid mutator transaction binding the contract method 0xa02c3e9b. +// +// Solidity: function updateSnapshotSubmissionWindow(address dataMarket, uint256 newsnapshotSubmissionWindow) returns() +func (_Contract *ContractTransactorSession) UpdateSnapshotSubmissionWindow(dataMarket common.Address, newsnapshotSubmissionWindow *big.Int) (*types.Transaction, error) { + return _Contract.Contract.UpdateSnapshotSubmissionWindow(&_Contract.TransactOpts, dataMarket, newsnapshotSubmissionWindow) +} + +// UpdateSnapshotterState is a paid mutator transaction binding the contract method 0xc9742dc1. +// +// Solidity: function updateSnapshotterState(address _address) returns() +func (_Contract *ContractTransactor) UpdateSnapshotterState(opts *bind.TransactOpts, _address common.Address) (*types.Transaction, error) { + return _Contract.contract.Transact(opts, "updateSnapshotterState", _address) +} + +// UpdateSnapshotterState is a paid mutator transaction binding the contract method 0xc9742dc1. +// +// Solidity: function updateSnapshotterState(address _address) returns() +func (_Contract *ContractSession) UpdateSnapshotterState(_address common.Address) (*types.Transaction, error) { + return _Contract.Contract.UpdateSnapshotterState(&_Contract.TransactOpts, _address) +} + +// UpdateSnapshotterState is a paid mutator transaction binding the contract method 0xc9742dc1. +// +// Solidity: function updateSnapshotterState(address _address) returns() +func (_Contract *ContractTransactorSession) UpdateSnapshotterState(_address common.Address) (*types.Transaction, error) { + return _Contract.Contract.UpdateSnapshotterState(&_Contract.TransactOpts, _address) +} + +// UpgradeToAndCall is a paid mutator transaction binding the contract method 0x4f1ef286. +// +// Solidity: function upgradeToAndCall(address newImplementation, bytes data) payable returns() +func (_Contract *ContractTransactor) UpgradeToAndCall(opts *bind.TransactOpts, newImplementation common.Address, data []byte) (*types.Transaction, error) { + return _Contract.contract.Transact(opts, "upgradeToAndCall", newImplementation, data) +} + +// UpgradeToAndCall is a paid mutator transaction binding the contract method 0x4f1ef286. +// +// Solidity: function upgradeToAndCall(address newImplementation, bytes data) payable returns() +func (_Contract *ContractSession) UpgradeToAndCall(newImplementation common.Address, data []byte) (*types.Transaction, error) { + return _Contract.Contract.UpgradeToAndCall(&_Contract.TransactOpts, newImplementation, data) +} + +// UpgradeToAndCall is a paid mutator transaction binding the contract method 0x4f1ef286. +// +// Solidity: function upgradeToAndCall(address newImplementation, bytes data) payable returns() +func (_Contract *ContractTransactorSession) UpgradeToAndCall(newImplementation common.Address, data []byte) (*types.Transaction, error) { + return _Contract.Contract.UpgradeToAndCall(&_Contract.TransactOpts, newImplementation, data) +} + +// ContractAdminsUpdatedIterator is returned from FilterAdminsUpdated and is used to iterate over the raw logs and unpacked data for AdminsUpdated events raised by the Contract contract. +type ContractAdminsUpdatedIterator struct { + Event *ContractAdminsUpdated // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ContractAdminsUpdatedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ContractAdminsUpdated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ContractAdminsUpdated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ContractAdminsUpdatedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ContractAdminsUpdatedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ContractAdminsUpdated represents a AdminsUpdated event raised by the Contract contract. +type ContractAdminsUpdated struct { + DataMarketAddress common.Address + AdminAddress common.Address + Allowed bool + Raw types.Log // Blockchain specific contextual infos +} + +// FilterAdminsUpdated is a free log retrieval operation binding the contract event 0xcde1efc8de533d8d3476a1e5f7423ea506a579776fc27e7d5f963f6c6018ca39. +// +// Solidity: event AdminsUpdated(address indexed dataMarketAddress, address adminAddress, bool allowed) +func (_Contract *ContractFilterer) FilterAdminsUpdated(opts *bind.FilterOpts, dataMarketAddress []common.Address) (*ContractAdminsUpdatedIterator, error) { + + var dataMarketAddressRule []interface{} + for _, dataMarketAddressItem := range dataMarketAddress { + dataMarketAddressRule = append(dataMarketAddressRule, dataMarketAddressItem) + } + + logs, sub, err := _Contract.contract.FilterLogs(opts, "AdminsUpdated", dataMarketAddressRule) + if err != nil { + return nil, err + } + return &ContractAdminsUpdatedIterator{contract: _Contract.contract, event: "AdminsUpdated", logs: logs, sub: sub}, nil +} + +// WatchAdminsUpdated is a free log subscription operation binding the contract event 0xcde1efc8de533d8d3476a1e5f7423ea506a579776fc27e7d5f963f6c6018ca39. +// +// Solidity: event AdminsUpdated(address indexed dataMarketAddress, address adminAddress, bool allowed) +func (_Contract *ContractFilterer) WatchAdminsUpdated(opts *bind.WatchOpts, sink chan<- *ContractAdminsUpdated, dataMarketAddress []common.Address) (event.Subscription, error) { + + var dataMarketAddressRule []interface{} + for _, dataMarketAddressItem := range dataMarketAddress { + dataMarketAddressRule = append(dataMarketAddressRule, dataMarketAddressItem) + } + + logs, sub, err := _Contract.contract.WatchLogs(opts, "AdminsUpdated", dataMarketAddressRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ContractAdminsUpdated) + if err := _Contract.contract.UnpackLog(event, "AdminsUpdated", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseAdminsUpdated is a log parse operation binding the contract event 0xcde1efc8de533d8d3476a1e5f7423ea506a579776fc27e7d5f963f6c6018ca39. +// +// Solidity: event AdminsUpdated(address indexed dataMarketAddress, address adminAddress, bool allowed) +func (_Contract *ContractFilterer) ParseAdminsUpdated(log types.Log) (*ContractAdminsUpdated, error) { + event := new(ContractAdminsUpdated) + if err := _Contract.contract.UnpackLog(event, "AdminsUpdated", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ContractBatchSubmissionsCompletedIterator is returned from FilterBatchSubmissionsCompleted and is used to iterate over the raw logs and unpacked data for BatchSubmissionsCompleted events raised by the Contract contract. +type ContractBatchSubmissionsCompletedIterator struct { + Event *ContractBatchSubmissionsCompleted // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ContractBatchSubmissionsCompletedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ContractBatchSubmissionsCompleted) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ContractBatchSubmissionsCompleted) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ContractBatchSubmissionsCompletedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ContractBatchSubmissionsCompletedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ContractBatchSubmissionsCompleted represents a BatchSubmissionsCompleted event raised by the Contract contract. +type ContractBatchSubmissionsCompleted struct { + DataMarketAddress common.Address + EpochId *big.Int + Timestamp *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterBatchSubmissionsCompleted is a free log retrieval operation binding the contract event 0x5ed90e6a0e12831302fecf13a2cc6f7e9439fed821340d0bddc4ae305dbf9c30. +// +// Solidity: event BatchSubmissionsCompleted(address indexed dataMarketAddress, uint256 indexed epochId, uint256 timestamp) +func (_Contract *ContractFilterer) FilterBatchSubmissionsCompleted(opts *bind.FilterOpts, dataMarketAddress []common.Address, epochId []*big.Int) (*ContractBatchSubmissionsCompletedIterator, error) { + + var dataMarketAddressRule []interface{} + for _, dataMarketAddressItem := range dataMarketAddress { + dataMarketAddressRule = append(dataMarketAddressRule, dataMarketAddressItem) + } + var epochIdRule []interface{} + for _, epochIdItem := range epochId { + epochIdRule = append(epochIdRule, epochIdItem) + } + + logs, sub, err := _Contract.contract.FilterLogs(opts, "BatchSubmissionsCompleted", dataMarketAddressRule, epochIdRule) + if err != nil { + return nil, err + } + return &ContractBatchSubmissionsCompletedIterator{contract: _Contract.contract, event: "BatchSubmissionsCompleted", logs: logs, sub: sub}, nil +} + +// WatchBatchSubmissionsCompleted is a free log subscription operation binding the contract event 0x5ed90e6a0e12831302fecf13a2cc6f7e9439fed821340d0bddc4ae305dbf9c30. +// +// Solidity: event BatchSubmissionsCompleted(address indexed dataMarketAddress, uint256 indexed epochId, uint256 timestamp) +func (_Contract *ContractFilterer) WatchBatchSubmissionsCompleted(opts *bind.WatchOpts, sink chan<- *ContractBatchSubmissionsCompleted, dataMarketAddress []common.Address, epochId []*big.Int) (event.Subscription, error) { + + var dataMarketAddressRule []interface{} + for _, dataMarketAddressItem := range dataMarketAddress { + dataMarketAddressRule = append(dataMarketAddressRule, dataMarketAddressItem) + } + var epochIdRule []interface{} + for _, epochIdItem := range epochId { + epochIdRule = append(epochIdRule, epochIdItem) + } + + logs, sub, err := _Contract.contract.WatchLogs(opts, "BatchSubmissionsCompleted", dataMarketAddressRule, epochIdRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ContractBatchSubmissionsCompleted) + if err := _Contract.contract.UnpackLog(event, "BatchSubmissionsCompleted", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseBatchSubmissionsCompleted is a log parse operation binding the contract event 0x5ed90e6a0e12831302fecf13a2cc6f7e9439fed821340d0bddc4ae305dbf9c30. +// +// Solidity: event BatchSubmissionsCompleted(address indexed dataMarketAddress, uint256 indexed epochId, uint256 timestamp) +func (_Contract *ContractFilterer) ParseBatchSubmissionsCompleted(log types.Log) (*ContractBatchSubmissionsCompleted, error) { + event := new(ContractBatchSubmissionsCompleted) + if err := _Contract.contract.UnpackLog(event, "BatchSubmissionsCompleted", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ContractDailyTaskCompletedEventIterator is returned from FilterDailyTaskCompletedEvent and is used to iterate over the raw logs and unpacked data for DailyTaskCompletedEvent events raised by the Contract contract. +type ContractDailyTaskCompletedEventIterator struct { + Event *ContractDailyTaskCompletedEvent // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ContractDailyTaskCompletedEventIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ContractDailyTaskCompletedEvent) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ContractDailyTaskCompletedEvent) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ContractDailyTaskCompletedEventIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ContractDailyTaskCompletedEventIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ContractDailyTaskCompletedEvent represents a DailyTaskCompletedEvent event raised by the Contract contract. +type ContractDailyTaskCompletedEvent struct { + DataMarketAddress common.Address + SnapshotterAddress common.Address + SlotId *big.Int + DayId *big.Int + Timestamp *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterDailyTaskCompletedEvent is a free log retrieval operation binding the contract event 0x7da483c8dd175f1c370a23b17545e19c0584cf3960d991202e216e6cf95b7a3d. +// +// Solidity: event DailyTaskCompletedEvent(address indexed dataMarketAddress, address snapshotterAddress, uint256 slotId, uint256 dayId, uint256 timestamp) +func (_Contract *ContractFilterer) FilterDailyTaskCompletedEvent(opts *bind.FilterOpts, dataMarketAddress []common.Address) (*ContractDailyTaskCompletedEventIterator, error) { + + var dataMarketAddressRule []interface{} + for _, dataMarketAddressItem := range dataMarketAddress { + dataMarketAddressRule = append(dataMarketAddressRule, dataMarketAddressItem) + } + + logs, sub, err := _Contract.contract.FilterLogs(opts, "DailyTaskCompletedEvent", dataMarketAddressRule) + if err != nil { + return nil, err + } + return &ContractDailyTaskCompletedEventIterator{contract: _Contract.contract, event: "DailyTaskCompletedEvent", logs: logs, sub: sub}, nil +} + +// WatchDailyTaskCompletedEvent is a free log subscription operation binding the contract event 0x7da483c8dd175f1c370a23b17545e19c0584cf3960d991202e216e6cf95b7a3d. +// +// Solidity: event DailyTaskCompletedEvent(address indexed dataMarketAddress, address snapshotterAddress, uint256 slotId, uint256 dayId, uint256 timestamp) +func (_Contract *ContractFilterer) WatchDailyTaskCompletedEvent(opts *bind.WatchOpts, sink chan<- *ContractDailyTaskCompletedEvent, dataMarketAddress []common.Address) (event.Subscription, error) { + + var dataMarketAddressRule []interface{} + for _, dataMarketAddressItem := range dataMarketAddress { + dataMarketAddressRule = append(dataMarketAddressRule, dataMarketAddressItem) + } + + logs, sub, err := _Contract.contract.WatchLogs(opts, "DailyTaskCompletedEvent", dataMarketAddressRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ContractDailyTaskCompletedEvent) + if err := _Contract.contract.UnpackLog(event, "DailyTaskCompletedEvent", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseDailyTaskCompletedEvent is a log parse operation binding the contract event 0x7da483c8dd175f1c370a23b17545e19c0584cf3960d991202e216e6cf95b7a3d. +// +// Solidity: event DailyTaskCompletedEvent(address indexed dataMarketAddress, address snapshotterAddress, uint256 slotId, uint256 dayId, uint256 timestamp) +func (_Contract *ContractFilterer) ParseDailyTaskCompletedEvent(log types.Log) (*ContractDailyTaskCompletedEvent, error) { + event := new(ContractDailyTaskCompletedEvent) + if err := _Contract.contract.UnpackLog(event, "DailyTaskCompletedEvent", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ContractDataMarketCreatedIterator is returned from FilterDataMarketCreated and is used to iterate over the raw logs and unpacked data for DataMarketCreated events raised by the Contract contract. +type ContractDataMarketCreatedIterator struct { + Event *ContractDataMarketCreated // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ContractDataMarketCreatedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ContractDataMarketCreated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ContractDataMarketCreated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ContractDataMarketCreatedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ContractDataMarketCreatedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ContractDataMarketCreated represents a DataMarketCreated event raised by the Contract contract. +type ContractDataMarketCreated struct { + OwnerAddress common.Address + EpochSize uint8 + SourceChainId *big.Int + SourceChainBlockTime *big.Int + UseBlockNumberAsEpochId bool + ProtocolState common.Address + DataMarketAddress common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterDataMarketCreated is a free log retrieval operation binding the contract event 0x4ac24bfdd2a01328b05db8f3587611f1d37fd01718e1edaa23a75ec91d71f517. +// +// Solidity: event DataMarketCreated(address indexed ownerAddress, uint8 epochSize, uint256 sourceChainId, uint256 sourceChainBlockTime, bool useBlockNumberAsEpochId, address protocolState, address dataMarketAddress) +func (_Contract *ContractFilterer) FilterDataMarketCreated(opts *bind.FilterOpts, ownerAddress []common.Address) (*ContractDataMarketCreatedIterator, error) { + + var ownerAddressRule []interface{} + for _, ownerAddressItem := range ownerAddress { + ownerAddressRule = append(ownerAddressRule, ownerAddressItem) + } + + logs, sub, err := _Contract.contract.FilterLogs(opts, "DataMarketCreated", ownerAddressRule) + if err != nil { + return nil, err + } + return &ContractDataMarketCreatedIterator{contract: _Contract.contract, event: "DataMarketCreated", logs: logs, sub: sub}, nil +} + +// WatchDataMarketCreated is a free log subscription operation binding the contract event 0x4ac24bfdd2a01328b05db8f3587611f1d37fd01718e1edaa23a75ec91d71f517. +// +// Solidity: event DataMarketCreated(address indexed ownerAddress, uint8 epochSize, uint256 sourceChainId, uint256 sourceChainBlockTime, bool useBlockNumberAsEpochId, address protocolState, address dataMarketAddress) +func (_Contract *ContractFilterer) WatchDataMarketCreated(opts *bind.WatchOpts, sink chan<- *ContractDataMarketCreated, ownerAddress []common.Address) (event.Subscription, error) { + + var ownerAddressRule []interface{} + for _, ownerAddressItem := range ownerAddress { + ownerAddressRule = append(ownerAddressRule, ownerAddressItem) + } + + logs, sub, err := _Contract.contract.WatchLogs(opts, "DataMarketCreated", ownerAddressRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ContractDataMarketCreated) + if err := _Contract.contract.UnpackLog(event, "DataMarketCreated", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseDataMarketCreated is a log parse operation binding the contract event 0x4ac24bfdd2a01328b05db8f3587611f1d37fd01718e1edaa23a75ec91d71f517. +// +// Solidity: event DataMarketCreated(address indexed ownerAddress, uint8 epochSize, uint256 sourceChainId, uint256 sourceChainBlockTime, bool useBlockNumberAsEpochId, address protocolState, address dataMarketAddress) +func (_Contract *ContractFilterer) ParseDataMarketCreated(log types.Log) (*ContractDataMarketCreated, error) { + event := new(ContractDataMarketCreated) + if err := _Contract.contract.UnpackLog(event, "DataMarketCreated", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ContractDayStartedEventIterator is returned from FilterDayStartedEvent and is used to iterate over the raw logs and unpacked data for DayStartedEvent events raised by the Contract contract. +type ContractDayStartedEventIterator struct { + Event *ContractDayStartedEvent // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ContractDayStartedEventIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ContractDayStartedEvent) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ContractDayStartedEvent) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ContractDayStartedEventIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ContractDayStartedEventIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ContractDayStartedEvent represents a DayStartedEvent event raised by the Contract contract. +type ContractDayStartedEvent struct { + DataMarketAddress common.Address + DayId *big.Int + Timestamp *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterDayStartedEvent is a free log retrieval operation binding the contract event 0x9bf380fe36617cd5d995968abb4ae6d3657a763c126535d590b4503ff2542426. +// +// Solidity: event DayStartedEvent(address indexed dataMarketAddress, uint256 dayId, uint256 timestamp) +func (_Contract *ContractFilterer) FilterDayStartedEvent(opts *bind.FilterOpts, dataMarketAddress []common.Address) (*ContractDayStartedEventIterator, error) { + + var dataMarketAddressRule []interface{} + for _, dataMarketAddressItem := range dataMarketAddress { + dataMarketAddressRule = append(dataMarketAddressRule, dataMarketAddressItem) + } + + logs, sub, err := _Contract.contract.FilterLogs(opts, "DayStartedEvent", dataMarketAddressRule) + if err != nil { + return nil, err + } + return &ContractDayStartedEventIterator{contract: _Contract.contract, event: "DayStartedEvent", logs: logs, sub: sub}, nil +} + +// WatchDayStartedEvent is a free log subscription operation binding the contract event 0x9bf380fe36617cd5d995968abb4ae6d3657a763c126535d590b4503ff2542426. +// +// Solidity: event DayStartedEvent(address indexed dataMarketAddress, uint256 dayId, uint256 timestamp) +func (_Contract *ContractFilterer) WatchDayStartedEvent(opts *bind.WatchOpts, sink chan<- *ContractDayStartedEvent, dataMarketAddress []common.Address) (event.Subscription, error) { + + var dataMarketAddressRule []interface{} + for _, dataMarketAddressItem := range dataMarketAddress { + dataMarketAddressRule = append(dataMarketAddressRule, dataMarketAddressItem) + } + + logs, sub, err := _Contract.contract.WatchLogs(opts, "DayStartedEvent", dataMarketAddressRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ContractDayStartedEvent) + if err := _Contract.contract.UnpackLog(event, "DayStartedEvent", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseDayStartedEvent is a log parse operation binding the contract event 0x9bf380fe36617cd5d995968abb4ae6d3657a763c126535d590b4503ff2542426. +// +// Solidity: event DayStartedEvent(address indexed dataMarketAddress, uint256 dayId, uint256 timestamp) +func (_Contract *ContractFilterer) ParseDayStartedEvent(log types.Log) (*ContractDayStartedEvent, error) { + event := new(ContractDayStartedEvent) + if err := _Contract.contract.UnpackLog(event, "DayStartedEvent", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ContractDelayedAttestationSubmittedIterator is returned from FilterDelayedAttestationSubmitted and is used to iterate over the raw logs and unpacked data for DelayedAttestationSubmitted events raised by the Contract contract. +type ContractDelayedAttestationSubmittedIterator struct { + Event *ContractDelayedAttestationSubmitted // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ContractDelayedAttestationSubmittedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ContractDelayedAttestationSubmitted) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ContractDelayedAttestationSubmitted) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ContractDelayedAttestationSubmittedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ContractDelayedAttestationSubmittedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ContractDelayedAttestationSubmitted represents a DelayedAttestationSubmitted event raised by the Contract contract. +type ContractDelayedAttestationSubmitted struct { + DataMarketAddress common.Address + BatchId *big.Int + EpochId *big.Int + Timestamp *big.Int + ValidatorAddr common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterDelayedAttestationSubmitted is a free log retrieval operation binding the contract event 0x4fd04f28641379ddef7bacd546c5e698814831a1c0772236c460aa42b029aa31. +// +// Solidity: event DelayedAttestationSubmitted(address indexed dataMarketAddress, uint256 batchId, uint256 indexed epochId, uint256 timestamp, address indexed validatorAddr) +func (_Contract *ContractFilterer) FilterDelayedAttestationSubmitted(opts *bind.FilterOpts, dataMarketAddress []common.Address, epochId []*big.Int, validatorAddr []common.Address) (*ContractDelayedAttestationSubmittedIterator, error) { + + var dataMarketAddressRule []interface{} + for _, dataMarketAddressItem := range dataMarketAddress { + dataMarketAddressRule = append(dataMarketAddressRule, dataMarketAddressItem) + } + + var epochIdRule []interface{} + for _, epochIdItem := range epochId { + epochIdRule = append(epochIdRule, epochIdItem) + } + + var validatorAddrRule []interface{} + for _, validatorAddrItem := range validatorAddr { + validatorAddrRule = append(validatorAddrRule, validatorAddrItem) + } + + logs, sub, err := _Contract.contract.FilterLogs(opts, "DelayedAttestationSubmitted", dataMarketAddressRule, epochIdRule, validatorAddrRule) + if err != nil { + return nil, err + } + return &ContractDelayedAttestationSubmittedIterator{contract: _Contract.contract, event: "DelayedAttestationSubmitted", logs: logs, sub: sub}, nil +} + +// WatchDelayedAttestationSubmitted is a free log subscription operation binding the contract event 0x4fd04f28641379ddef7bacd546c5e698814831a1c0772236c460aa42b029aa31. +// +// Solidity: event DelayedAttestationSubmitted(address indexed dataMarketAddress, uint256 batchId, uint256 indexed epochId, uint256 timestamp, address indexed validatorAddr) +func (_Contract *ContractFilterer) WatchDelayedAttestationSubmitted(opts *bind.WatchOpts, sink chan<- *ContractDelayedAttestationSubmitted, dataMarketAddress []common.Address, epochId []*big.Int, validatorAddr []common.Address) (event.Subscription, error) { + + var dataMarketAddressRule []interface{} + for _, dataMarketAddressItem := range dataMarketAddress { + dataMarketAddressRule = append(dataMarketAddressRule, dataMarketAddressItem) + } + + var epochIdRule []interface{} + for _, epochIdItem := range epochId { + epochIdRule = append(epochIdRule, epochIdItem) + } + + var validatorAddrRule []interface{} + for _, validatorAddrItem := range validatorAddr { + validatorAddrRule = append(validatorAddrRule, validatorAddrItem) + } + + logs, sub, err := _Contract.contract.WatchLogs(opts, "DelayedAttestationSubmitted", dataMarketAddressRule, epochIdRule, validatorAddrRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ContractDelayedAttestationSubmitted) + if err := _Contract.contract.UnpackLog(event, "DelayedAttestationSubmitted", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseDelayedAttestationSubmitted is a log parse operation binding the contract event 0x4fd04f28641379ddef7bacd546c5e698814831a1c0772236c460aa42b029aa31. +// +// Solidity: event DelayedAttestationSubmitted(address indexed dataMarketAddress, uint256 batchId, uint256 indexed epochId, uint256 timestamp, address indexed validatorAddr) +func (_Contract *ContractFilterer) ParseDelayedAttestationSubmitted(log types.Log) (*ContractDelayedAttestationSubmitted, error) { + event := new(ContractDelayedAttestationSubmitted) + if err := _Contract.contract.UnpackLog(event, "DelayedAttestationSubmitted", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ContractDelayedBatchSubmittedIterator is returned from FilterDelayedBatchSubmitted and is used to iterate over the raw logs and unpacked data for DelayedBatchSubmitted events raised by the Contract contract. +type ContractDelayedBatchSubmittedIterator struct { + Event *ContractDelayedBatchSubmitted // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ContractDelayedBatchSubmittedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ContractDelayedBatchSubmitted) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ContractDelayedBatchSubmitted) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ContractDelayedBatchSubmittedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ContractDelayedBatchSubmittedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ContractDelayedBatchSubmitted represents a DelayedBatchSubmitted event raised by the Contract contract. +type ContractDelayedBatchSubmitted struct { + DataMarketAddress common.Address + BatchId *big.Int + BatchCid string + EpochId *big.Int + Timestamp *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterDelayedBatchSubmitted is a free log retrieval operation binding the contract event 0xf2de85dca20817401360fd386051732f208a7508ed4ffa7c15686979da276ec6. +// +// Solidity: event DelayedBatchSubmitted(address indexed dataMarketAddress, uint256 batchId, string batchCid, uint256 indexed epochId, uint256 timestamp) +func (_Contract *ContractFilterer) FilterDelayedBatchSubmitted(opts *bind.FilterOpts, dataMarketAddress []common.Address, epochId []*big.Int) (*ContractDelayedBatchSubmittedIterator, error) { + + var dataMarketAddressRule []interface{} + for _, dataMarketAddressItem := range dataMarketAddress { + dataMarketAddressRule = append(dataMarketAddressRule, dataMarketAddressItem) + } + + var epochIdRule []interface{} + for _, epochIdItem := range epochId { + epochIdRule = append(epochIdRule, epochIdItem) + } + + logs, sub, err := _Contract.contract.FilterLogs(opts, "DelayedBatchSubmitted", dataMarketAddressRule, epochIdRule) + if err != nil { + return nil, err + } + return &ContractDelayedBatchSubmittedIterator{contract: _Contract.contract, event: "DelayedBatchSubmitted", logs: logs, sub: sub}, nil +} + +// WatchDelayedBatchSubmitted is a free log subscription operation binding the contract event 0xf2de85dca20817401360fd386051732f208a7508ed4ffa7c15686979da276ec6. +// +// Solidity: event DelayedBatchSubmitted(address indexed dataMarketAddress, uint256 batchId, string batchCid, uint256 indexed epochId, uint256 timestamp) +func (_Contract *ContractFilterer) WatchDelayedBatchSubmitted(opts *bind.WatchOpts, sink chan<- *ContractDelayedBatchSubmitted, dataMarketAddress []common.Address, epochId []*big.Int) (event.Subscription, error) { + + var dataMarketAddressRule []interface{} + for _, dataMarketAddressItem := range dataMarketAddress { + dataMarketAddressRule = append(dataMarketAddressRule, dataMarketAddressItem) + } + + var epochIdRule []interface{} + for _, epochIdItem := range epochId { + epochIdRule = append(epochIdRule, epochIdItem) + } + + logs, sub, err := _Contract.contract.WatchLogs(opts, "DelayedBatchSubmitted", dataMarketAddressRule, epochIdRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ContractDelayedBatchSubmitted) + if err := _Contract.contract.UnpackLog(event, "DelayedBatchSubmitted", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseDelayedBatchSubmitted is a log parse operation binding the contract event 0xf2de85dca20817401360fd386051732f208a7508ed4ffa7c15686979da276ec6. +// +// Solidity: event DelayedBatchSubmitted(address indexed dataMarketAddress, uint256 batchId, string batchCid, uint256 indexed epochId, uint256 timestamp) +func (_Contract *ContractFilterer) ParseDelayedBatchSubmitted(log types.Log) (*ContractDelayedBatchSubmitted, error) { + event := new(ContractDelayedBatchSubmitted) + if err := _Contract.contract.UnpackLog(event, "DelayedBatchSubmitted", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ContractDelayedSnapshotSubmittedIterator is returned from FilterDelayedSnapshotSubmitted and is used to iterate over the raw logs and unpacked data for DelayedSnapshotSubmitted events raised by the Contract contract. +type ContractDelayedSnapshotSubmittedIterator struct { + Event *ContractDelayedSnapshotSubmitted // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ContractDelayedSnapshotSubmittedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ContractDelayedSnapshotSubmitted) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ContractDelayedSnapshotSubmitted) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ContractDelayedSnapshotSubmittedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ContractDelayedSnapshotSubmittedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ContractDelayedSnapshotSubmitted represents a DelayedSnapshotSubmitted event raised by the Contract contract. +type ContractDelayedSnapshotSubmitted struct { + DataMarketAddress common.Address + SnapshotterAddr common.Address + SlotId *big.Int + SnapshotCid string + EpochId *big.Int + ProjectId string + Timestamp *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterDelayedSnapshotSubmitted is a free log retrieval operation binding the contract event 0x3857c02d90218ce4e6decef6b24babba8e0d8331c159392de06c1ce2c7a2d3be. +// +// Solidity: event DelayedSnapshotSubmitted(address indexed dataMarketAddress, address indexed snapshotterAddr, uint256 slotId, string snapshotCid, uint256 indexed epochId, string projectId, uint256 timestamp) +func (_Contract *ContractFilterer) FilterDelayedSnapshotSubmitted(opts *bind.FilterOpts, dataMarketAddress []common.Address, snapshotterAddr []common.Address, epochId []*big.Int) (*ContractDelayedSnapshotSubmittedIterator, error) { + + var dataMarketAddressRule []interface{} + for _, dataMarketAddressItem := range dataMarketAddress { + dataMarketAddressRule = append(dataMarketAddressRule, dataMarketAddressItem) + } + var snapshotterAddrRule []interface{} + for _, snapshotterAddrItem := range snapshotterAddr { + snapshotterAddrRule = append(snapshotterAddrRule, snapshotterAddrItem) + } + + var epochIdRule []interface{} + for _, epochIdItem := range epochId { + epochIdRule = append(epochIdRule, epochIdItem) + } + + logs, sub, err := _Contract.contract.FilterLogs(opts, "DelayedSnapshotSubmitted", dataMarketAddressRule, snapshotterAddrRule, epochIdRule) + if err != nil { + return nil, err + } + return &ContractDelayedSnapshotSubmittedIterator{contract: _Contract.contract, event: "DelayedSnapshotSubmitted", logs: logs, sub: sub}, nil +} + +// WatchDelayedSnapshotSubmitted is a free log subscription operation binding the contract event 0x3857c02d90218ce4e6decef6b24babba8e0d8331c159392de06c1ce2c7a2d3be. +// +// Solidity: event DelayedSnapshotSubmitted(address indexed dataMarketAddress, address indexed snapshotterAddr, uint256 slotId, string snapshotCid, uint256 indexed epochId, string projectId, uint256 timestamp) +func (_Contract *ContractFilterer) WatchDelayedSnapshotSubmitted(opts *bind.WatchOpts, sink chan<- *ContractDelayedSnapshotSubmitted, dataMarketAddress []common.Address, snapshotterAddr []common.Address, epochId []*big.Int) (event.Subscription, error) { + + var dataMarketAddressRule []interface{} + for _, dataMarketAddressItem := range dataMarketAddress { + dataMarketAddressRule = append(dataMarketAddressRule, dataMarketAddressItem) + } + var snapshotterAddrRule []interface{} + for _, snapshotterAddrItem := range snapshotterAddr { + snapshotterAddrRule = append(snapshotterAddrRule, snapshotterAddrItem) + } + + var epochIdRule []interface{} + for _, epochIdItem := range epochId { + epochIdRule = append(epochIdRule, epochIdItem) + } + + logs, sub, err := _Contract.contract.WatchLogs(opts, "DelayedSnapshotSubmitted", dataMarketAddressRule, snapshotterAddrRule, epochIdRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ContractDelayedSnapshotSubmitted) + if err := _Contract.contract.UnpackLog(event, "DelayedSnapshotSubmitted", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseDelayedSnapshotSubmitted is a log parse operation binding the contract event 0x3857c02d90218ce4e6decef6b24babba8e0d8331c159392de06c1ce2c7a2d3be. +// +// Solidity: event DelayedSnapshotSubmitted(address indexed dataMarketAddress, address indexed snapshotterAddr, uint256 slotId, string snapshotCid, uint256 indexed epochId, string projectId, uint256 timestamp) +func (_Contract *ContractFilterer) ParseDelayedSnapshotSubmitted(log types.Log) (*ContractDelayedSnapshotSubmitted, error) { + event := new(ContractDelayedSnapshotSubmitted) + if err := _Contract.contract.UnpackLog(event, "DelayedSnapshotSubmitted", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ContractEpochReleasedIterator is returned from FilterEpochReleased and is used to iterate over the raw logs and unpacked data for EpochReleased events raised by the Contract contract. +type ContractEpochReleasedIterator struct { + Event *ContractEpochReleased // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ContractEpochReleasedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ContractEpochReleased) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ContractEpochReleased) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ContractEpochReleasedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ContractEpochReleasedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ContractEpochReleased represents a EpochReleased event raised by the Contract contract. +type ContractEpochReleased struct { + DataMarketAddress common.Address + EpochId *big.Int + Begin *big.Int + End *big.Int + Timestamp *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterEpochReleased is a free log retrieval operation binding the contract event 0xf7d2257d4a1c445138ab52bd3c22425bfed29da81d0173961c697dc14fcba60c. +// +// Solidity: event EpochReleased(address indexed dataMarketAddress, uint256 indexed epochId, uint256 begin, uint256 end, uint256 timestamp) +func (_Contract *ContractFilterer) FilterEpochReleased(opts *bind.FilterOpts, dataMarketAddress []common.Address, epochId []*big.Int) (*ContractEpochReleasedIterator, error) { + + var dataMarketAddressRule []interface{} + for _, dataMarketAddressItem := range dataMarketAddress { + dataMarketAddressRule = append(dataMarketAddressRule, dataMarketAddressItem) + } + var epochIdRule []interface{} + for _, epochIdItem := range epochId { + epochIdRule = append(epochIdRule, epochIdItem) + } + + logs, sub, err := _Contract.contract.FilterLogs(opts, "EpochReleased", dataMarketAddressRule, epochIdRule) + if err != nil { + return nil, err + } + return &ContractEpochReleasedIterator{contract: _Contract.contract, event: "EpochReleased", logs: logs, sub: sub}, nil +} + +// WatchEpochReleased is a free log subscription operation binding the contract event 0xf7d2257d4a1c445138ab52bd3c22425bfed29da81d0173961c697dc14fcba60c. +// +// Solidity: event EpochReleased(address indexed dataMarketAddress, uint256 indexed epochId, uint256 begin, uint256 end, uint256 timestamp) +func (_Contract *ContractFilterer) WatchEpochReleased(opts *bind.WatchOpts, sink chan<- *ContractEpochReleased, dataMarketAddress []common.Address, epochId []*big.Int) (event.Subscription, error) { + + var dataMarketAddressRule []interface{} + for _, dataMarketAddressItem := range dataMarketAddress { + dataMarketAddressRule = append(dataMarketAddressRule, dataMarketAddressItem) + } + var epochIdRule []interface{} + for _, epochIdItem := range epochId { + epochIdRule = append(epochIdRule, epochIdItem) + } + + logs, sub, err := _Contract.contract.WatchLogs(opts, "EpochReleased", dataMarketAddressRule, epochIdRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ContractEpochReleased) + if err := _Contract.contract.UnpackLog(event, "EpochReleased", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseEpochReleased is a log parse operation binding the contract event 0xf7d2257d4a1c445138ab52bd3c22425bfed29da81d0173961c697dc14fcba60c. +// +// Solidity: event EpochReleased(address indexed dataMarketAddress, uint256 indexed epochId, uint256 begin, uint256 end, uint256 timestamp) +func (_Contract *ContractFilterer) ParseEpochReleased(log types.Log) (*ContractEpochReleased, error) { + event := new(ContractEpochReleased) + if err := _Contract.contract.UnpackLog(event, "EpochReleased", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ContractInitializedIterator is returned from FilterInitialized and is used to iterate over the raw logs and unpacked data for Initialized events raised by the Contract contract. +type ContractInitializedIterator struct { + Event *ContractInitialized // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ContractInitializedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ContractInitialized) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ContractInitialized) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ContractInitializedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ContractInitializedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ContractInitialized represents a Initialized event raised by the Contract contract. +type ContractInitialized struct { + Version uint64 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterInitialized is a free log retrieval operation binding the contract event 0xc7f505b2f371ae2175ee4913f4499e1f2633a7b5936321eed1cdaeb6115181d2. +// +// Solidity: event Initialized(uint64 version) +func (_Contract *ContractFilterer) FilterInitialized(opts *bind.FilterOpts) (*ContractInitializedIterator, error) { + + logs, sub, err := _Contract.contract.FilterLogs(opts, "Initialized") + if err != nil { + return nil, err + } + return &ContractInitializedIterator{contract: _Contract.contract, event: "Initialized", logs: logs, sub: sub}, nil +} + +// WatchInitialized is a free log subscription operation binding the contract event 0xc7f505b2f371ae2175ee4913f4499e1f2633a7b5936321eed1cdaeb6115181d2. +// +// Solidity: event Initialized(uint64 version) +func (_Contract *ContractFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *ContractInitialized) (event.Subscription, error) { + + logs, sub, err := _Contract.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(ContractInitialized) + if err := _Contract.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 0xc7f505b2f371ae2175ee4913f4499e1f2633a7b5936321eed1cdaeb6115181d2. +// +// Solidity: event Initialized(uint64 version) +func (_Contract *ContractFilterer) ParseInitialized(log types.Log) (*ContractInitialized, error) { + event := new(ContractInitialized) + if err := _Contract.contract.UnpackLog(event, "Initialized", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ContractOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the Contract contract. +type ContractOwnershipTransferredIterator struct { + Event *ContractOwnershipTransferred // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ContractOwnershipTransferredIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ContractOwnershipTransferred) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ContractOwnershipTransferred) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ContractOwnershipTransferredIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ContractOwnershipTransferredIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ContractOwnershipTransferred represents a OwnershipTransferred event raised by the Contract contract. +type ContractOwnershipTransferred 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 (_Contract *ContractFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*ContractOwnershipTransferredIterator, 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 := _Contract.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) + if err != nil { + return nil, err + } + return &ContractOwnershipTransferredIterator{contract: _Contract.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 (_Contract *ContractFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *ContractOwnershipTransferred, 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 := _Contract.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(ContractOwnershipTransferred) + if err := _Contract.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 (_Contract *ContractFilterer) ParseOwnershipTransferred(log types.Log) (*ContractOwnershipTransferred, error) { + event := new(ContractOwnershipTransferred) + if err := _Contract.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ContractProjectTypeUpdatedIterator is returned from FilterProjectTypeUpdated and is used to iterate over the raw logs and unpacked data for ProjectTypeUpdated events raised by the Contract contract. +type ContractProjectTypeUpdatedIterator struct { + Event *ContractProjectTypeUpdated // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ContractProjectTypeUpdatedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ContractProjectTypeUpdated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ContractProjectTypeUpdated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ContractProjectTypeUpdatedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ContractProjectTypeUpdatedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ContractProjectTypeUpdated represents a ProjectTypeUpdated event raised by the Contract contract. +type ContractProjectTypeUpdated struct { + DataMarketAddress common.Address + ProjectType string + Allowed bool + EnableEpochId *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterProjectTypeUpdated is a free log retrieval operation binding the contract event 0x3c6dc99dfc227a11ad701f84af7d44db829ba6c5e71c85f0ba80da02a2c20b42. +// +// Solidity: event ProjectTypeUpdated(address indexed dataMarketAddress, string projectType, bool allowed, uint256 enableEpochId) +func (_Contract *ContractFilterer) FilterProjectTypeUpdated(opts *bind.FilterOpts, dataMarketAddress []common.Address) (*ContractProjectTypeUpdatedIterator, error) { + + var dataMarketAddressRule []interface{} + for _, dataMarketAddressItem := range dataMarketAddress { + dataMarketAddressRule = append(dataMarketAddressRule, dataMarketAddressItem) + } + + logs, sub, err := _Contract.contract.FilterLogs(opts, "ProjectTypeUpdated", dataMarketAddressRule) + if err != nil { + return nil, err + } + return &ContractProjectTypeUpdatedIterator{contract: _Contract.contract, event: "ProjectTypeUpdated", logs: logs, sub: sub}, nil +} + +// WatchProjectTypeUpdated is a free log subscription operation binding the contract event 0x3c6dc99dfc227a11ad701f84af7d44db829ba6c5e71c85f0ba80da02a2c20b42. +// +// Solidity: event ProjectTypeUpdated(address indexed dataMarketAddress, string projectType, bool allowed, uint256 enableEpochId) +func (_Contract *ContractFilterer) WatchProjectTypeUpdated(opts *bind.WatchOpts, sink chan<- *ContractProjectTypeUpdated, dataMarketAddress []common.Address) (event.Subscription, error) { + + var dataMarketAddressRule []interface{} + for _, dataMarketAddressItem := range dataMarketAddress { + dataMarketAddressRule = append(dataMarketAddressRule, dataMarketAddressItem) + } + + logs, sub, err := _Contract.contract.WatchLogs(opts, "ProjectTypeUpdated", dataMarketAddressRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ContractProjectTypeUpdated) + if err := _Contract.contract.UnpackLog(event, "ProjectTypeUpdated", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseProjectTypeUpdated is a log parse operation binding the contract event 0x3c6dc99dfc227a11ad701f84af7d44db829ba6c5e71c85f0ba80da02a2c20b42. +// +// Solidity: event ProjectTypeUpdated(address indexed dataMarketAddress, string projectType, bool allowed, uint256 enableEpochId) +func (_Contract *ContractFilterer) ParseProjectTypeUpdated(log types.Log) (*ContractProjectTypeUpdated, error) { + event := new(ContractProjectTypeUpdated) + if err := _Contract.contract.UnpackLog(event, "ProjectTypeUpdated", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ContractProjectsUpdatedIterator is returned from FilterProjectsUpdated and is used to iterate over the raw logs and unpacked data for ProjectsUpdated events raised by the Contract contract. +type ContractProjectsUpdatedIterator struct { + Event *ContractProjectsUpdated // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ContractProjectsUpdatedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ContractProjectsUpdated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ContractProjectsUpdated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ContractProjectsUpdatedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ContractProjectsUpdatedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ContractProjectsUpdated represents a ProjectsUpdated event raised by the Contract contract. +type ContractProjectsUpdated struct { + DataMarketAddress common.Address + Projects []string + Status []bool + EnableEpochId *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterProjectsUpdated is a free log retrieval operation binding the contract event 0xcbf1b93d76451f05244e2f6139bf7266a14bac5182e5ed8981ab0ce36479efbf. +// +// Solidity: event ProjectsUpdated(address indexed dataMarketAddress, string[] projects, bool[] status, uint256 enableEpochId) +func (_Contract *ContractFilterer) FilterProjectsUpdated(opts *bind.FilterOpts, dataMarketAddress []common.Address) (*ContractProjectsUpdatedIterator, error) { + + var dataMarketAddressRule []interface{} + for _, dataMarketAddressItem := range dataMarketAddress { + dataMarketAddressRule = append(dataMarketAddressRule, dataMarketAddressItem) + } + + logs, sub, err := _Contract.contract.FilterLogs(opts, "ProjectsUpdated", dataMarketAddressRule) + if err != nil { + return nil, err + } + return &ContractProjectsUpdatedIterator{contract: _Contract.contract, event: "ProjectsUpdated", logs: logs, sub: sub}, nil +} + +// WatchProjectsUpdated is a free log subscription operation binding the contract event 0xcbf1b93d76451f05244e2f6139bf7266a14bac5182e5ed8981ab0ce36479efbf. +// +// Solidity: event ProjectsUpdated(address indexed dataMarketAddress, string[] projects, bool[] status, uint256 enableEpochId) +func (_Contract *ContractFilterer) WatchProjectsUpdated(opts *bind.WatchOpts, sink chan<- *ContractProjectsUpdated, dataMarketAddress []common.Address) (event.Subscription, error) { + + var dataMarketAddressRule []interface{} + for _, dataMarketAddressItem := range dataMarketAddress { + dataMarketAddressRule = append(dataMarketAddressRule, dataMarketAddressItem) + } + + logs, sub, err := _Contract.contract.WatchLogs(opts, "ProjectsUpdated", dataMarketAddressRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ContractProjectsUpdated) + if err := _Contract.contract.UnpackLog(event, "ProjectsUpdated", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseProjectsUpdated is a log parse operation binding the contract event 0xcbf1b93d76451f05244e2f6139bf7266a14bac5182e5ed8981ab0ce36479efbf. +// +// Solidity: event ProjectsUpdated(address indexed dataMarketAddress, string[] projects, bool[] status, uint256 enableEpochId) +func (_Contract *ContractFilterer) ParseProjectsUpdated(log types.Log) (*ContractProjectsUpdated, error) { + event := new(ContractProjectsUpdated) + if err := _Contract.contract.UnpackLog(event, "ProjectsUpdated", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ContractSequencersUpdatedIterator is returned from FilterSequencersUpdated and is used to iterate over the raw logs and unpacked data for SequencersUpdated events raised by the Contract contract. +type ContractSequencersUpdatedIterator struct { + Event *ContractSequencersUpdated // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ContractSequencersUpdatedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ContractSequencersUpdated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ContractSequencersUpdated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ContractSequencersUpdatedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ContractSequencersUpdatedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ContractSequencersUpdated represents a SequencersUpdated event raised by the Contract contract. +type ContractSequencersUpdated struct { + DataMarketAddress common.Address + SequencerAddress common.Address + Allowed bool + Raw types.Log // Blockchain specific contextual infos +} + +// FilterSequencersUpdated is a free log retrieval operation binding the contract event 0xad12010237fe83915c67abe51836e693a16f8a2592b9a4e959374ab33ae7a697. +// +// Solidity: event SequencersUpdated(address indexed dataMarketAddress, address sequencerAddress, bool allowed) +func (_Contract *ContractFilterer) FilterSequencersUpdated(opts *bind.FilterOpts, dataMarketAddress []common.Address) (*ContractSequencersUpdatedIterator, error) { + + var dataMarketAddressRule []interface{} + for _, dataMarketAddressItem := range dataMarketAddress { + dataMarketAddressRule = append(dataMarketAddressRule, dataMarketAddressItem) + } + + logs, sub, err := _Contract.contract.FilterLogs(opts, "SequencersUpdated", dataMarketAddressRule) + if err != nil { + return nil, err + } + return &ContractSequencersUpdatedIterator{contract: _Contract.contract, event: "SequencersUpdated", logs: logs, sub: sub}, nil +} + +// WatchSequencersUpdated is a free log subscription operation binding the contract event 0xad12010237fe83915c67abe51836e693a16f8a2592b9a4e959374ab33ae7a697. +// +// Solidity: event SequencersUpdated(address indexed dataMarketAddress, address sequencerAddress, bool allowed) +func (_Contract *ContractFilterer) WatchSequencersUpdated(opts *bind.WatchOpts, sink chan<- *ContractSequencersUpdated, dataMarketAddress []common.Address) (event.Subscription, error) { + + var dataMarketAddressRule []interface{} + for _, dataMarketAddressItem := range dataMarketAddress { + dataMarketAddressRule = append(dataMarketAddressRule, dataMarketAddressItem) + } + + logs, sub, err := _Contract.contract.WatchLogs(opts, "SequencersUpdated", dataMarketAddressRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ContractSequencersUpdated) + if err := _Contract.contract.UnpackLog(event, "SequencersUpdated", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseSequencersUpdated is a log parse operation binding the contract event 0xad12010237fe83915c67abe51836e693a16f8a2592b9a4e959374ab33ae7a697. +// +// Solidity: event SequencersUpdated(address indexed dataMarketAddress, address sequencerAddress, bool allowed) +func (_Contract *ContractFilterer) ParseSequencersUpdated(log types.Log) (*ContractSequencersUpdated, error) { + event := new(ContractSequencersUpdated) + if err := _Contract.contract.UnpackLog(event, "SequencersUpdated", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ContractSnapshotBatchAttestationSubmittedIterator is returned from FilterSnapshotBatchAttestationSubmitted and is used to iterate over the raw logs and unpacked data for SnapshotBatchAttestationSubmitted events raised by the Contract contract. +type ContractSnapshotBatchAttestationSubmittedIterator struct { + Event *ContractSnapshotBatchAttestationSubmitted // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ContractSnapshotBatchAttestationSubmittedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ContractSnapshotBatchAttestationSubmitted) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ContractSnapshotBatchAttestationSubmitted) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ContractSnapshotBatchAttestationSubmittedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ContractSnapshotBatchAttestationSubmittedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ContractSnapshotBatchAttestationSubmitted represents a SnapshotBatchAttestationSubmitted event raised by the Contract contract. +type ContractSnapshotBatchAttestationSubmitted struct { + DataMarketAddress common.Address + BatchId *big.Int + EpochId *big.Int + Timestamp *big.Int + ValidatorAddr common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterSnapshotBatchAttestationSubmitted is a free log retrieval operation binding the contract event 0xf4b2e45e85a2dfbff1f3d17d57722c58599f10a2a3b9764b6106e7ca0c21d22f. +// +// Solidity: event SnapshotBatchAttestationSubmitted(address indexed dataMarketAddress, uint256 batchId, uint256 indexed epochId, uint256 timestamp, address indexed validatorAddr) +func (_Contract *ContractFilterer) FilterSnapshotBatchAttestationSubmitted(opts *bind.FilterOpts, dataMarketAddress []common.Address, epochId []*big.Int, validatorAddr []common.Address) (*ContractSnapshotBatchAttestationSubmittedIterator, error) { + + var dataMarketAddressRule []interface{} + for _, dataMarketAddressItem := range dataMarketAddress { + dataMarketAddressRule = append(dataMarketAddressRule, dataMarketAddressItem) + } + + var epochIdRule []interface{} + for _, epochIdItem := range epochId { + epochIdRule = append(epochIdRule, epochIdItem) + } + + var validatorAddrRule []interface{} + for _, validatorAddrItem := range validatorAddr { + validatorAddrRule = append(validatorAddrRule, validatorAddrItem) + } + + logs, sub, err := _Contract.contract.FilterLogs(opts, "SnapshotBatchAttestationSubmitted", dataMarketAddressRule, epochIdRule, validatorAddrRule) + if err != nil { + return nil, err + } + return &ContractSnapshotBatchAttestationSubmittedIterator{contract: _Contract.contract, event: "SnapshotBatchAttestationSubmitted", logs: logs, sub: sub}, nil +} + +// WatchSnapshotBatchAttestationSubmitted is a free log subscription operation binding the contract event 0xf4b2e45e85a2dfbff1f3d17d57722c58599f10a2a3b9764b6106e7ca0c21d22f. +// +// Solidity: event SnapshotBatchAttestationSubmitted(address indexed dataMarketAddress, uint256 batchId, uint256 indexed epochId, uint256 timestamp, address indexed validatorAddr) +func (_Contract *ContractFilterer) WatchSnapshotBatchAttestationSubmitted(opts *bind.WatchOpts, sink chan<- *ContractSnapshotBatchAttestationSubmitted, dataMarketAddress []common.Address, epochId []*big.Int, validatorAddr []common.Address) (event.Subscription, error) { + + var dataMarketAddressRule []interface{} + for _, dataMarketAddressItem := range dataMarketAddress { + dataMarketAddressRule = append(dataMarketAddressRule, dataMarketAddressItem) + } + + var epochIdRule []interface{} + for _, epochIdItem := range epochId { + epochIdRule = append(epochIdRule, epochIdItem) + } + + var validatorAddrRule []interface{} + for _, validatorAddrItem := range validatorAddr { + validatorAddrRule = append(validatorAddrRule, validatorAddrItem) + } + + logs, sub, err := _Contract.contract.WatchLogs(opts, "SnapshotBatchAttestationSubmitted", dataMarketAddressRule, epochIdRule, validatorAddrRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ContractSnapshotBatchAttestationSubmitted) + if err := _Contract.contract.UnpackLog(event, "SnapshotBatchAttestationSubmitted", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseSnapshotBatchAttestationSubmitted is a log parse operation binding the contract event 0xf4b2e45e85a2dfbff1f3d17d57722c58599f10a2a3b9764b6106e7ca0c21d22f. +// +// Solidity: event SnapshotBatchAttestationSubmitted(address indexed dataMarketAddress, uint256 batchId, uint256 indexed epochId, uint256 timestamp, address indexed validatorAddr) +func (_Contract *ContractFilterer) ParseSnapshotBatchAttestationSubmitted(log types.Log) (*ContractSnapshotBatchAttestationSubmitted, error) { + event := new(ContractSnapshotBatchAttestationSubmitted) + if err := _Contract.contract.UnpackLog(event, "SnapshotBatchAttestationSubmitted", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ContractSnapshotBatchFinalizedIterator is returned from FilterSnapshotBatchFinalized and is used to iterate over the raw logs and unpacked data for SnapshotBatchFinalized events raised by the Contract contract. +type ContractSnapshotBatchFinalizedIterator struct { + Event *ContractSnapshotBatchFinalized // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ContractSnapshotBatchFinalizedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ContractSnapshotBatchFinalized) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ContractSnapshotBatchFinalized) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ContractSnapshotBatchFinalizedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ContractSnapshotBatchFinalizedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ContractSnapshotBatchFinalized represents a SnapshotBatchFinalized event raised by the Contract contract. +type ContractSnapshotBatchFinalized struct { + DataMarketAddress common.Address + EpochId *big.Int + BatchId *big.Int + Timestamp *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterSnapshotBatchFinalized is a free log retrieval operation binding the contract event 0x9737b8e7fb3913ba98706f4b1758ac14f5cf26afbb2457117aa3360b9cc85de1. +// +// Solidity: event SnapshotBatchFinalized(address indexed dataMarketAddress, uint256 indexed epochId, uint256 indexed batchId, uint256 timestamp) +func (_Contract *ContractFilterer) FilterSnapshotBatchFinalized(opts *bind.FilterOpts, dataMarketAddress []common.Address, epochId []*big.Int, batchId []*big.Int) (*ContractSnapshotBatchFinalizedIterator, error) { + + var dataMarketAddressRule []interface{} + for _, dataMarketAddressItem := range dataMarketAddress { + dataMarketAddressRule = append(dataMarketAddressRule, dataMarketAddressItem) + } + var epochIdRule []interface{} + for _, epochIdItem := range epochId { + epochIdRule = append(epochIdRule, epochIdItem) + } + var batchIdRule []interface{} + for _, batchIdItem := range batchId { + batchIdRule = append(batchIdRule, batchIdItem) + } + + logs, sub, err := _Contract.contract.FilterLogs(opts, "SnapshotBatchFinalized", dataMarketAddressRule, epochIdRule, batchIdRule) + if err != nil { + return nil, err + } + return &ContractSnapshotBatchFinalizedIterator{contract: _Contract.contract, event: "SnapshotBatchFinalized", logs: logs, sub: sub}, nil +} + +// WatchSnapshotBatchFinalized is a free log subscription operation binding the contract event 0x9737b8e7fb3913ba98706f4b1758ac14f5cf26afbb2457117aa3360b9cc85de1. +// +// Solidity: event SnapshotBatchFinalized(address indexed dataMarketAddress, uint256 indexed epochId, uint256 indexed batchId, uint256 timestamp) +func (_Contract *ContractFilterer) WatchSnapshotBatchFinalized(opts *bind.WatchOpts, sink chan<- *ContractSnapshotBatchFinalized, dataMarketAddress []common.Address, epochId []*big.Int, batchId []*big.Int) (event.Subscription, error) { + + var dataMarketAddressRule []interface{} + for _, dataMarketAddressItem := range dataMarketAddress { + dataMarketAddressRule = append(dataMarketAddressRule, dataMarketAddressItem) + } + var epochIdRule []interface{} + for _, epochIdItem := range epochId { + epochIdRule = append(epochIdRule, epochIdItem) + } + var batchIdRule []interface{} + for _, batchIdItem := range batchId { + batchIdRule = append(batchIdRule, batchIdItem) + } + + logs, sub, err := _Contract.contract.WatchLogs(opts, "SnapshotBatchFinalized", dataMarketAddressRule, epochIdRule, batchIdRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ContractSnapshotBatchFinalized) + if err := _Contract.contract.UnpackLog(event, "SnapshotBatchFinalized", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseSnapshotBatchFinalized is a log parse operation binding the contract event 0x9737b8e7fb3913ba98706f4b1758ac14f5cf26afbb2457117aa3360b9cc85de1. +// +// Solidity: event SnapshotBatchFinalized(address indexed dataMarketAddress, uint256 indexed epochId, uint256 indexed batchId, uint256 timestamp) +func (_Contract *ContractFilterer) ParseSnapshotBatchFinalized(log types.Log) (*ContractSnapshotBatchFinalized, error) { + event := new(ContractSnapshotBatchFinalized) + if err := _Contract.contract.UnpackLog(event, "SnapshotBatchFinalized", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ContractSnapshotBatchSubmittedIterator is returned from FilterSnapshotBatchSubmitted and is used to iterate over the raw logs and unpacked data for SnapshotBatchSubmitted events raised by the Contract contract. +type ContractSnapshotBatchSubmittedIterator struct { + Event *ContractSnapshotBatchSubmitted // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ContractSnapshotBatchSubmittedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ContractSnapshotBatchSubmitted) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ContractSnapshotBatchSubmitted) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ContractSnapshotBatchSubmittedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ContractSnapshotBatchSubmittedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ContractSnapshotBatchSubmitted represents a SnapshotBatchSubmitted event raised by the Contract contract. +type ContractSnapshotBatchSubmitted struct { + DataMarketAddress common.Address + BatchId *big.Int + BatchCid string + EpochId *big.Int + Timestamp *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterSnapshotBatchSubmitted is a free log retrieval operation binding the contract event 0x0b4031b6dda76fc423ccf9fba3aa5b0936474be3c9b7080c165c0744a002fe75. +// +// Solidity: event SnapshotBatchSubmitted(address indexed dataMarketAddress, uint256 batchId, string batchCid, uint256 indexed epochId, uint256 timestamp) +func (_Contract *ContractFilterer) FilterSnapshotBatchSubmitted(opts *bind.FilterOpts, dataMarketAddress []common.Address, epochId []*big.Int) (*ContractSnapshotBatchSubmittedIterator, error) { + + var dataMarketAddressRule []interface{} + for _, dataMarketAddressItem := range dataMarketAddress { + dataMarketAddressRule = append(dataMarketAddressRule, dataMarketAddressItem) + } + + var epochIdRule []interface{} + for _, epochIdItem := range epochId { + epochIdRule = append(epochIdRule, epochIdItem) + } + + logs, sub, err := _Contract.contract.FilterLogs(opts, "SnapshotBatchSubmitted", dataMarketAddressRule, epochIdRule) + if err != nil { + return nil, err + } + return &ContractSnapshotBatchSubmittedIterator{contract: _Contract.contract, event: "SnapshotBatchSubmitted", logs: logs, sub: sub}, nil +} + +// WatchSnapshotBatchSubmitted is a free log subscription operation binding the contract event 0x0b4031b6dda76fc423ccf9fba3aa5b0936474be3c9b7080c165c0744a002fe75. +// +// Solidity: event SnapshotBatchSubmitted(address indexed dataMarketAddress, uint256 batchId, string batchCid, uint256 indexed epochId, uint256 timestamp) +func (_Contract *ContractFilterer) WatchSnapshotBatchSubmitted(opts *bind.WatchOpts, sink chan<- *ContractSnapshotBatchSubmitted, dataMarketAddress []common.Address, epochId []*big.Int) (event.Subscription, error) { + + var dataMarketAddressRule []interface{} + for _, dataMarketAddressItem := range dataMarketAddress { + dataMarketAddressRule = append(dataMarketAddressRule, dataMarketAddressItem) + } + + var epochIdRule []interface{} + for _, epochIdItem := range epochId { + epochIdRule = append(epochIdRule, epochIdItem) + } + + logs, sub, err := _Contract.contract.WatchLogs(opts, "SnapshotBatchSubmitted", dataMarketAddressRule, epochIdRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ContractSnapshotBatchSubmitted) + if err := _Contract.contract.UnpackLog(event, "SnapshotBatchSubmitted", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseSnapshotBatchSubmitted is a log parse operation binding the contract event 0x0b4031b6dda76fc423ccf9fba3aa5b0936474be3c9b7080c165c0744a002fe75. +// +// Solidity: event SnapshotBatchSubmitted(address indexed dataMarketAddress, uint256 batchId, string batchCid, uint256 indexed epochId, uint256 timestamp) +func (_Contract *ContractFilterer) ParseSnapshotBatchSubmitted(log types.Log) (*ContractSnapshotBatchSubmitted, error) { + event := new(ContractSnapshotBatchSubmitted) + if err := _Contract.contract.UnpackLog(event, "SnapshotBatchSubmitted", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ContractSnapshotFinalizedIterator is returned from FilterSnapshotFinalized and is used to iterate over the raw logs and unpacked data for SnapshotFinalized events raised by the Contract contract. +type ContractSnapshotFinalizedIterator struct { + Event *ContractSnapshotFinalized // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ContractSnapshotFinalizedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ContractSnapshotFinalized) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ContractSnapshotFinalized) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ContractSnapshotFinalizedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ContractSnapshotFinalizedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ContractSnapshotFinalized represents a SnapshotFinalized event raised by the Contract contract. +type ContractSnapshotFinalized struct { + DataMarketAddress common.Address + EpochId *big.Int + EpochEnd *big.Int + ProjectId string + SnapshotCid string + Timestamp *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterSnapshotFinalized is a free log retrieval operation binding the contract event 0x1746fd35c2b9c905f8e7ef34232f796acb536f2fd87f01d201f57fb338eab9a6. +// +// Solidity: event SnapshotFinalized(address indexed dataMarketAddress, uint256 indexed epochId, uint256 epochEnd, string projectId, string snapshotCid, uint256 timestamp) +func (_Contract *ContractFilterer) FilterSnapshotFinalized(opts *bind.FilterOpts, dataMarketAddress []common.Address, epochId []*big.Int) (*ContractSnapshotFinalizedIterator, error) { + + var dataMarketAddressRule []interface{} + for _, dataMarketAddressItem := range dataMarketAddress { + dataMarketAddressRule = append(dataMarketAddressRule, dataMarketAddressItem) + } + var epochIdRule []interface{} + for _, epochIdItem := range epochId { + epochIdRule = append(epochIdRule, epochIdItem) + } + + logs, sub, err := _Contract.contract.FilterLogs(opts, "SnapshotFinalized", dataMarketAddressRule, epochIdRule) + if err != nil { + return nil, err + } + return &ContractSnapshotFinalizedIterator{contract: _Contract.contract, event: "SnapshotFinalized", logs: logs, sub: sub}, nil +} + +// WatchSnapshotFinalized is a free log subscription operation binding the contract event 0x1746fd35c2b9c905f8e7ef34232f796acb536f2fd87f01d201f57fb338eab9a6. +// +// Solidity: event SnapshotFinalized(address indexed dataMarketAddress, uint256 indexed epochId, uint256 epochEnd, string projectId, string snapshotCid, uint256 timestamp) +func (_Contract *ContractFilterer) WatchSnapshotFinalized(opts *bind.WatchOpts, sink chan<- *ContractSnapshotFinalized, dataMarketAddress []common.Address, epochId []*big.Int) (event.Subscription, error) { + + var dataMarketAddressRule []interface{} + for _, dataMarketAddressItem := range dataMarketAddress { + dataMarketAddressRule = append(dataMarketAddressRule, dataMarketAddressItem) + } + var epochIdRule []interface{} + for _, epochIdItem := range epochId { + epochIdRule = append(epochIdRule, epochIdItem) + } + + logs, sub, err := _Contract.contract.WatchLogs(opts, "SnapshotFinalized", dataMarketAddressRule, epochIdRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ContractSnapshotFinalized) + if err := _Contract.contract.UnpackLog(event, "SnapshotFinalized", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseSnapshotFinalized is a log parse operation binding the contract event 0x1746fd35c2b9c905f8e7ef34232f796acb536f2fd87f01d201f57fb338eab9a6. +// +// Solidity: event SnapshotFinalized(address indexed dataMarketAddress, uint256 indexed epochId, uint256 epochEnd, string projectId, string snapshotCid, uint256 timestamp) +func (_Contract *ContractFilterer) ParseSnapshotFinalized(log types.Log) (*ContractSnapshotFinalized, error) { + event := new(ContractSnapshotFinalized) + if err := _Contract.contract.UnpackLog(event, "SnapshotFinalized", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ContractTriggerBatchResubmissionIterator is returned from FilterTriggerBatchResubmission and is used to iterate over the raw logs and unpacked data for TriggerBatchResubmission events raised by the Contract contract. +type ContractTriggerBatchResubmissionIterator struct { + Event *ContractTriggerBatchResubmission // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ContractTriggerBatchResubmissionIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ContractTriggerBatchResubmission) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ContractTriggerBatchResubmission) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ContractTriggerBatchResubmissionIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ContractTriggerBatchResubmissionIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ContractTriggerBatchResubmission represents a TriggerBatchResubmission event raised by the Contract contract. +type ContractTriggerBatchResubmission struct { + DataMarketAddress common.Address + EpochId *big.Int + BatchId *big.Int + Timestamp *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterTriggerBatchResubmission is a free log retrieval operation binding the contract event 0x4a87247b65ffdb6c5ebb776b6e70fc9bddc3402b413d82060701fd9c30a3ff07. +// +// Solidity: event TriggerBatchResubmission(address indexed dataMarketAddress, uint256 indexed epochId, uint256 indexed batchId, uint256 timestamp) +func (_Contract *ContractFilterer) FilterTriggerBatchResubmission(opts *bind.FilterOpts, dataMarketAddress []common.Address, epochId []*big.Int, batchId []*big.Int) (*ContractTriggerBatchResubmissionIterator, error) { + + var dataMarketAddressRule []interface{} + for _, dataMarketAddressItem := range dataMarketAddress { + dataMarketAddressRule = append(dataMarketAddressRule, dataMarketAddressItem) + } + var epochIdRule []interface{} + for _, epochIdItem := range epochId { + epochIdRule = append(epochIdRule, epochIdItem) + } + var batchIdRule []interface{} + for _, batchIdItem := range batchId { + batchIdRule = append(batchIdRule, batchIdItem) + } + + logs, sub, err := _Contract.contract.FilterLogs(opts, "TriggerBatchResubmission", dataMarketAddressRule, epochIdRule, batchIdRule) + if err != nil { + return nil, err + } + return &ContractTriggerBatchResubmissionIterator{contract: _Contract.contract, event: "TriggerBatchResubmission", logs: logs, sub: sub}, nil +} + +// WatchTriggerBatchResubmission is a free log subscription operation binding the contract event 0x4a87247b65ffdb6c5ebb776b6e70fc9bddc3402b413d82060701fd9c30a3ff07. +// +// Solidity: event TriggerBatchResubmission(address indexed dataMarketAddress, uint256 indexed epochId, uint256 indexed batchId, uint256 timestamp) +func (_Contract *ContractFilterer) WatchTriggerBatchResubmission(opts *bind.WatchOpts, sink chan<- *ContractTriggerBatchResubmission, dataMarketAddress []common.Address, epochId []*big.Int, batchId []*big.Int) (event.Subscription, error) { + + var dataMarketAddressRule []interface{} + for _, dataMarketAddressItem := range dataMarketAddress { + dataMarketAddressRule = append(dataMarketAddressRule, dataMarketAddressItem) + } + var epochIdRule []interface{} + for _, epochIdItem := range epochId { + epochIdRule = append(epochIdRule, epochIdItem) + } + var batchIdRule []interface{} + for _, batchIdItem := range batchId { + batchIdRule = append(batchIdRule, batchIdItem) + } + + logs, sub, err := _Contract.contract.WatchLogs(opts, "TriggerBatchResubmission", dataMarketAddressRule, epochIdRule, batchIdRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ContractTriggerBatchResubmission) + if err := _Contract.contract.UnpackLog(event, "TriggerBatchResubmission", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseTriggerBatchResubmission is a log parse operation binding the contract event 0x4a87247b65ffdb6c5ebb776b6e70fc9bddc3402b413d82060701fd9c30a3ff07. +// +// Solidity: event TriggerBatchResubmission(address indexed dataMarketAddress, uint256 indexed epochId, uint256 indexed batchId, uint256 timestamp) +func (_Contract *ContractFilterer) ParseTriggerBatchResubmission(log types.Log) (*ContractTriggerBatchResubmission, error) { + event := new(ContractTriggerBatchResubmission) + if err := _Contract.contract.UnpackLog(event, "TriggerBatchResubmission", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ContractUpgradedIterator is returned from FilterUpgraded and is used to iterate over the raw logs and unpacked data for Upgraded events raised by the Contract contract. +type ContractUpgradedIterator struct { + Event *ContractUpgraded // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ContractUpgradedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ContractUpgraded) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ContractUpgraded) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ContractUpgradedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ContractUpgradedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ContractUpgraded represents a Upgraded event raised by the Contract contract. +type ContractUpgraded struct { + Implementation common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterUpgraded is a free log retrieval operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. +// +// Solidity: event Upgraded(address indexed implementation) +func (_Contract *ContractFilterer) FilterUpgraded(opts *bind.FilterOpts, implementation []common.Address) (*ContractUpgradedIterator, error) { + + var implementationRule []interface{} + for _, implementationItem := range implementation { + implementationRule = append(implementationRule, implementationItem) + } + + logs, sub, err := _Contract.contract.FilterLogs(opts, "Upgraded", implementationRule) + if err != nil { + return nil, err + } + return &ContractUpgradedIterator{contract: _Contract.contract, event: "Upgraded", logs: logs, sub: sub}, nil +} + +// WatchUpgraded is a free log subscription operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. +// +// Solidity: event Upgraded(address indexed implementation) +func (_Contract *ContractFilterer) WatchUpgraded(opts *bind.WatchOpts, sink chan<- *ContractUpgraded, implementation []common.Address) (event.Subscription, error) { + + var implementationRule []interface{} + for _, implementationItem := range implementation { + implementationRule = append(implementationRule, implementationItem) + } + + logs, sub, err := _Contract.contract.WatchLogs(opts, "Upgraded", implementationRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ContractUpgraded) + if err := _Contract.contract.UnpackLog(event, "Upgraded", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseUpgraded is a log parse operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. +// +// Solidity: event Upgraded(address indexed implementation) +func (_Contract *ContractFilterer) ParseUpgraded(log types.Log) (*ContractUpgraded, error) { + event := new(ContractUpgraded) + if err := _Contract.contract.UnpackLog(event, "Upgraded", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ContractValidatorAttestationsInvalidatedIterator is returned from FilterValidatorAttestationsInvalidated and is used to iterate over the raw logs and unpacked data for ValidatorAttestationsInvalidated events raised by the Contract contract. +type ContractValidatorAttestationsInvalidatedIterator struct { + Event *ContractValidatorAttestationsInvalidated // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ContractValidatorAttestationsInvalidatedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ContractValidatorAttestationsInvalidated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ContractValidatorAttestationsInvalidated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ContractValidatorAttestationsInvalidatedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ContractValidatorAttestationsInvalidatedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ContractValidatorAttestationsInvalidated represents a ValidatorAttestationsInvalidated event raised by the Contract contract. +type ContractValidatorAttestationsInvalidated struct { + DataMarketAddress common.Address + EpochId *big.Int + BatchId *big.Int + Validator common.Address + Timestamp *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterValidatorAttestationsInvalidated is a free log retrieval operation binding the contract event 0x714caf86f735bcfc9ca5f4e56456c4c16a6630870eaee41fa5748b2502a1317a. +// +// Solidity: event ValidatorAttestationsInvalidated(address indexed dataMarketAddress, uint256 indexed epochId, uint256 indexed batchId, address validator, uint256 timestamp) +func (_Contract *ContractFilterer) FilterValidatorAttestationsInvalidated(opts *bind.FilterOpts, dataMarketAddress []common.Address, epochId []*big.Int, batchId []*big.Int) (*ContractValidatorAttestationsInvalidatedIterator, error) { + + var dataMarketAddressRule []interface{} + for _, dataMarketAddressItem := range dataMarketAddress { + dataMarketAddressRule = append(dataMarketAddressRule, dataMarketAddressItem) + } + var epochIdRule []interface{} + for _, epochIdItem := range epochId { + epochIdRule = append(epochIdRule, epochIdItem) + } + var batchIdRule []interface{} + for _, batchIdItem := range batchId { + batchIdRule = append(batchIdRule, batchIdItem) + } + + logs, sub, err := _Contract.contract.FilterLogs(opts, "ValidatorAttestationsInvalidated", dataMarketAddressRule, epochIdRule, batchIdRule) + if err != nil { + return nil, err + } + return &ContractValidatorAttestationsInvalidatedIterator{contract: _Contract.contract, event: "ValidatorAttestationsInvalidated", logs: logs, sub: sub}, nil +} + +// WatchValidatorAttestationsInvalidated is a free log subscription operation binding the contract event 0x714caf86f735bcfc9ca5f4e56456c4c16a6630870eaee41fa5748b2502a1317a. +// +// Solidity: event ValidatorAttestationsInvalidated(address indexed dataMarketAddress, uint256 indexed epochId, uint256 indexed batchId, address validator, uint256 timestamp) +func (_Contract *ContractFilterer) WatchValidatorAttestationsInvalidated(opts *bind.WatchOpts, sink chan<- *ContractValidatorAttestationsInvalidated, dataMarketAddress []common.Address, epochId []*big.Int, batchId []*big.Int) (event.Subscription, error) { + + var dataMarketAddressRule []interface{} + for _, dataMarketAddressItem := range dataMarketAddress { + dataMarketAddressRule = append(dataMarketAddressRule, dataMarketAddressItem) + } + var epochIdRule []interface{} + for _, epochIdItem := range epochId { + epochIdRule = append(epochIdRule, epochIdItem) + } + var batchIdRule []interface{} + for _, batchIdItem := range batchId { + batchIdRule = append(batchIdRule, batchIdItem) + } + + logs, sub, err := _Contract.contract.WatchLogs(opts, "ValidatorAttestationsInvalidated", dataMarketAddressRule, epochIdRule, batchIdRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ContractValidatorAttestationsInvalidated) + if err := _Contract.contract.UnpackLog(event, "ValidatorAttestationsInvalidated", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseValidatorAttestationsInvalidated is a log parse operation binding the contract event 0x714caf86f735bcfc9ca5f4e56456c4c16a6630870eaee41fa5748b2502a1317a. +// +// Solidity: event ValidatorAttestationsInvalidated(address indexed dataMarketAddress, uint256 indexed epochId, uint256 indexed batchId, address validator, uint256 timestamp) +func (_Contract *ContractFilterer) ParseValidatorAttestationsInvalidated(log types.Log) (*ContractValidatorAttestationsInvalidated, error) { + event := new(ContractValidatorAttestationsInvalidated) + if err := _Contract.contract.UnpackLog(event, "ValidatorAttestationsInvalidated", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ContractValidatorsUpdatedIterator is returned from FilterValidatorsUpdated and is used to iterate over the raw logs and unpacked data for ValidatorsUpdated events raised by the Contract contract. +type ContractValidatorsUpdatedIterator struct { + Event *ContractValidatorsUpdated // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ContractValidatorsUpdatedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ContractValidatorsUpdated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ContractValidatorsUpdated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ContractValidatorsUpdatedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ContractValidatorsUpdatedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ContractValidatorsUpdated represents a ValidatorsUpdated event raised by the Contract contract. +type ContractValidatorsUpdated struct { + DataMarketAddress common.Address + ValidatorAddress common.Address + Allowed bool + Raw types.Log // Blockchain specific contextual infos +} + +// FilterValidatorsUpdated is a free log retrieval operation binding the contract event 0x2a93c48a2a98c035cd37b0e8a3e25c15ce5dd0caa1fb0553603c249c37db24b8. +// +// Solidity: event ValidatorsUpdated(address indexed dataMarketAddress, address validatorAddress, bool allowed) +func (_Contract *ContractFilterer) FilterValidatorsUpdated(opts *bind.FilterOpts, dataMarketAddress []common.Address) (*ContractValidatorsUpdatedIterator, error) { + + var dataMarketAddressRule []interface{} + for _, dataMarketAddressItem := range dataMarketAddress { + dataMarketAddressRule = append(dataMarketAddressRule, dataMarketAddressItem) + } + + logs, sub, err := _Contract.contract.FilterLogs(opts, "ValidatorsUpdated", dataMarketAddressRule) + if err != nil { + return nil, err + } + return &ContractValidatorsUpdatedIterator{contract: _Contract.contract, event: "ValidatorsUpdated", logs: logs, sub: sub}, nil +} + +// WatchValidatorsUpdated is a free log subscription operation binding the contract event 0x2a93c48a2a98c035cd37b0e8a3e25c15ce5dd0caa1fb0553603c249c37db24b8. +// +// Solidity: event ValidatorsUpdated(address indexed dataMarketAddress, address validatorAddress, bool allowed) +func (_Contract *ContractFilterer) WatchValidatorsUpdated(opts *bind.WatchOpts, sink chan<- *ContractValidatorsUpdated, dataMarketAddress []common.Address) (event.Subscription, error) { + + var dataMarketAddressRule []interface{} + for _, dataMarketAddressItem := range dataMarketAddress { + dataMarketAddressRule = append(dataMarketAddressRule, dataMarketAddressItem) + } + + logs, sub, err := _Contract.contract.WatchLogs(opts, "ValidatorsUpdated", dataMarketAddressRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ContractValidatorsUpdated) + if err := _Contract.contract.UnpackLog(event, "ValidatorsUpdated", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseValidatorsUpdated is a log parse operation binding the contract event 0x2a93c48a2a98c035cd37b0e8a3e25c15ce5dd0caa1fb0553603c249c37db24b8. +// +// Solidity: event ValidatorsUpdated(address indexed dataMarketAddress, address validatorAddress, bool allowed) +func (_Contract *ContractFilterer) ParseValidatorsUpdated(log types.Log) (*ContractValidatorsUpdated, error) { + event := new(ContractValidatorsUpdated) + if err := _Contract.contract.UnpackLog(event, "ValidatorsUpdated", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/pkgs/prost/contract.go b/pkgs/prost/contract.go new file mode 100644 index 0000000..2a66277 --- /dev/null +++ b/pkgs/prost/contract.go @@ -0,0 +1,152 @@ +package prost + +import ( + "context" + "encoding/json" + "github.com/cenkalti/backoff/v4" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/ethclient" + log "github.com/sirupsen/logrus" + "math/big" + "protocol-state-cacher/config" + "protocol-state-cacher/pkgs" + listenerCommon "protocol-state-cacher/pkgs/common" + "protocol-state-cacher/pkgs/contract" + "protocol-state-cacher/pkgs/redis" + "time" +) + +var Instance *contract.Contract + +var ( + Client *ethclient.Client + CurrentBlock *types.Block + DataMarket common.Address +) + +const BlockTime = 1 + +func ConfigureClient() { + var err error + Client, err = ethclient.Dial(config.SettingsObj.ClientUrl) + if err != nil { + log.Fatal(err) + } +} + +func ConfigureContractInstance() { + DataMarket = common.HexToAddress(config.SettingsObj.DataMarketAddress) + Instance, _ = contract.NewContract(common.HexToAddress(config.SettingsObj.ContractAddress), Client) +} + +func MustQuery[K any](ctx context.Context, call func(opts *bind.CallOpts) (val K, err error)) (K, error) { + expBackOff := backoff.NewExponentialBackOff() + expBackOff.MaxElapsedTime = 1 * time.Minute + var val K + operation := func() error { + var err error + val, err = call(&bind.CallOpts{}) + return err + } + // Use the retry package to execute the operation with backoff + err := backoff.Retry(operation, backoff.WithContext(expBackOff, ctx)) + if err != nil { + return *new(K), err + } + return val, err +} + +func ColdSync() { + for { + PopulateStateVars() + coldSyncAllSlots() + time.Sleep((time.Millisecond * 500) * BlockTime) + } +} + +func coldSyncAllSlots() { + var allSlots []string + + if slotCount, err := Instance.SlotCounter(&bind.CallOpts{}); slotCount != nil && err == nil { + PersistState(context.Background(), redis.ContractStateVariable(pkgs.SlotCounter), slotCount.String()) + + for i := int64(0); i <= slotCount.Int64(); i++ { + slot, err := Instance.GetSlotInfo(&bind.CallOpts{}, DataMarket, big.NewInt(i)) + + if slot == (contract.PowerloomDataMarketSlotInfo{}) || err != nil { + log.Debugln("Error getting slot info: ", i) + continue + } + + slotMarshalled, err := json.Marshal(slot) + + if err != nil { + log.Debugln("Error marshalling slot info: ", i) + continue + } + + PersistState( + context.Background(), + redis.SlotInfo(slot.SlotId.String()), + string(slotMarshalled), + ) + + allSlots = append( + allSlots, + redis.SlotInfo(slot.SlotId.String()), + ) + + log.Debugln("Slot info: ", i, string(slotMarshalled), slot.SlotId.String()) + } + + err := redis.AddToSet(context.Background(), "AllSlotsInfo", allSlots...) + if err != nil { + log.Errorln("Error adding slots to set: ", err) + listenerCommon.SendFailureNotification("ColdSync", err.Error(), time.Now().String(), "ERROR") + } + } else { + log.Errorln("Error getting slot counter: ", err) + listenerCommon.SendFailureNotification("ColdSync", err.Error(), time.Now().String(), "ERROR") + } +} + +func PopulateStateVars() { + for { + if block, err := Client.BlockByNumber(context.Background(), nil); err == nil { + CurrentBlock = block + break + } else { + log.Debugln("Encountered error while fetching current block: ", err.Error()) + } + } + + if output, err := Instance.CurrentEpoch(&bind.CallOpts{}, DataMarket); output.EpochId != nil && err == nil { + key := redis.ContractStateVariable(pkgs.CurrentEpoch) + PersistState(context.Background(), key, output.EpochId.String()) + } + + if output, err := Instance.CurrentBatchId(&bind.CallOpts{}, DataMarket); output != nil && err == nil { + key := redis.ContractStateVariable(pkgs.CurrentBatchId) + PersistState(context.Background(), key, output.String()) + } + + if output, err := Instance.EpochsInADay(&bind.CallOpts{}, DataMarket); output != nil && err == nil { + key := redis.ContractStateVariable(pkgs.EpochsInADay) + PersistState(context.Background(), key, output.String()) + } +} + +func PersistState(ctx context.Context, key string, val string) { + var err error + if err = redis.Set(ctx, key, val, 0); err != nil { + log.Errorln("Error setting state variable: ", key, val) + listenerCommon.SendFailureNotification("PersistState", err.Error(), time.Now().String(), "ERROR") + } + if err = redis.PersistKey(ctx, key); err != nil { + log.Errorln("Error persisting state variable: ", key) + listenerCommon.SendFailureNotification("PersistState", err.Error(), time.Now().String(), "ERROR") + return + } +} diff --git a/pkgs/redis/client.go b/pkgs/redis/client.go new file mode 100644 index 0000000..31bba69 --- /dev/null +++ b/pkgs/redis/client.go @@ -0,0 +1,98 @@ +package redis + +import ( + "context" + "encoding/json" + "errors" + "fmt" + "github.com/go-redis/redis/v8" + "protocol-state-cacher/config" + "protocol-state-cacher/pkgs/common" + "time" +) + +var RedisClient *redis.Client + +// TODO: Pool size failures to be checked +func NewRedisClient() *redis.Client { + return redis.NewClient(&redis.Options{ + Addr: fmt.Sprintf("%s:%s", config.SettingsObj.RedisHost, config.SettingsObj.RedisPort), // Redis server address + Password: "", // no password set + DB: 0, + PoolSize: 1000, + ReadTimeout: 200 * time.Millisecond, + WriteTimeout: 200 * time.Millisecond, + DialTimeout: 5 * time.Second, + IdleTimeout: 5 * time.Minute, + }) +} + +func AddToSet(ctx context.Context, set string, keys ...string) error { + if err := RedisClient.SAdd(ctx, set, keys).Err(); err != nil { + common.SendFailureNotification("Redis error", err.Error(), time.Now().String(), "High") + return err + } + return nil +} + +func GetSetKeys(ctx context.Context, set string) []string { + return RedisClient.SMembers(ctx, set).Val() +} + +func RemoveFromSet(ctx context.Context, set, key string) error { + return RedisClient.SRem(context.Background(), set, key).Err() +} + +func Delete(ctx context.Context, set string) error { + return RedisClient.Del(ctx, set).Err() +} + +func SetSubmission(ctx context.Context, key string, value string, set string, expiration time.Duration) error { + if err := RedisClient.SAdd(ctx, set, key).Err(); err != nil { + common.SendFailureNotification("Redis error", err.Error(), time.Now().String(), "High") + return err + } + if err := RedisClient.Set(ctx, key, value, expiration).Err(); err != nil { + common.SendFailureNotification("Redis error", err.Error(), time.Now().String(), "High") + return err + } + return nil +} + +func PersistKey(ctx context.Context, key string) error { + return RedisClient.Persist(ctx, key).Err() +} + +func Get(ctx context.Context, key string) (string, error) { + val, err := RedisClient.Get(ctx, key).Result() + if err != nil { + if errors.Is(err, redis.Nil) { + return "", nil + } else { + common.SendFailureNotification("Redis error", err.Error(), time.Now().String(), "High") + return "", err + } + } + return val, nil +} + +func Set(ctx context.Context, key, value string, expiration time.Duration) error { + return RedisClient.Set(ctx, key, value, expiration).Err() +} + +// Save log to Redis +func SetProcessLog(ctx context.Context, key string, logEntry map[string]interface{}, exp time.Duration) error { + data, err := json.Marshal(logEntry) + if err != nil { + common.SendFailureNotification("Redis SetProcessLog marshalling", err.Error(), time.Now().String(), "High") + return fmt.Errorf("failed to marshal log entry: %w", err) + } + + err = RedisClient.Set(ctx, key, data, exp).Err() + if err != nil { + common.SendFailureNotification("Redis error", err.Error(), time.Now().String(), "High") + return fmt.Errorf("failed to set log entry in Redis: %w", err) + } + + return nil +} diff --git a/pkgs/redis/keys.go b/pkgs/redis/keys.go new file mode 100644 index 0000000..8884a31 --- /dev/null +++ b/pkgs/redis/keys.go @@ -0,0 +1,13 @@ +package redis + +import ( + "fmt" +) + +func ContractStateVariable(varName string) string { + return fmt.Sprintf("ProtocolState.%s", varName) +} + +func SlotInfo(slotId string) string { + return fmt.Sprintf("%s.%s", ContractStateVariable("SlotInfo"), slotId) +} diff --git a/pkgs/utils/logger.go b/pkgs/utils/logger.go new file mode 100644 index 0000000..707186a --- /dev/null +++ b/pkgs/utils/logger.go @@ -0,0 +1,48 @@ +package utils + +import ( + "fmt" + log "github.com/sirupsen/logrus" + "github.com/sirupsen/logrus/hooks/writer" + "io" + "os" + "strconv" +) + +func InitLogger() { + log.SetOutput(io.Discard) // Send all logs to nowhere by default + + log.SetReportCaller(true) + + log.AddHook(&writer.Hook{ // Send logs with level higher than warning to stderr + Writer: os.Stderr, + LogLevels: []log.Level{ + log.PanicLevel, + log.FatalLevel, + log.ErrorLevel, + log.WarnLevel, + }, + }) + log.AddHook(&writer.Hook{ // Send info and debug logs to stdout + Writer: os.Stdout, + LogLevels: []log.Level{ + log.TraceLevel, + log.InfoLevel, + log.DebugLevel, + }, + }) + if len(os.Args) < 2 { + fmt.Println("Pass loglevel as an argument if you don't want default(INFO) to be set.") + fmt.Println("Values to be passed for logLevel: ERROR(2),INFO(4),DEBUG(5)") + log.SetLevel(log.DebugLevel) + } else { + logLevel, err := strconv.ParseUint(os.Args[1], 10, 32) + if err != nil || logLevel > 6 { + log.SetLevel(log.DebugLevel) //TODO: Change default level to error + } else { + //TODO: Need to come up with approach to dynamically update logLevel. + log.SetLevel(log.Level(logLevel)) + } + } + log.SetFormatter(&log.TextFormatter{FullTimestamp: true}) +} diff --git a/run-dev.sh b/run-dev.sh new file mode 100755 index 0000000..e616a52 --- /dev/null +++ b/run-dev.sh @@ -0,0 +1,17 @@ +#!/bin/bash + +env_vars="" + +env_file=".env" +if [ -f "$env_file" ]; then + echo "Reading $env_file" + while IFS= read -r line || [ -n "$line" ]; do + if [[ ! "$line" =~ ^# && -n "$line" ]]; then + env_vars+=" $line" + fi + done < "$env_file" +else + echo "File $env_file does not exist" +fi + +env $env_vars go run cmd/main.go diff --git a/run.sh b/run.sh new file mode 100644 index 0000000..10d2619 --- /dev/null +++ b/run.sh @@ -0,0 +1 @@ +docker run --env-file .env -p 9000:9000 proto-snapshot-listener \ No newline at end of file