diff --git a/.github/workflows/change-log-check.yml b/.github/workflows/change-log-check.yml index 1e5374179f..6fe9ac2a9f 100644 --- a/.github/workflows/change-log-check.yml +++ b/.github/workflows/change-log-check.yml @@ -17,7 +17,7 @@ jobs: if: ${{ !contains(github.event.pull_request.labels.*.name, 'no-changelog') }} run: | git fetch origin ${{ github.base_ref }} - CHANGELOG_DIFF=$(git diff origin/${{ github.base_ref }} origin/${{ github.head_ref }} -- changelog.md) + CHANGELOG_DIFF=$(git diff ${{ github.event.pull_request.base.sha }}..${{ github.event.pull_request.head.sha }} -- changelog.md) echo "${CHANGELOG_DIFF}" if [ -z "$CHANGELOG_DIFF" ]; then echo "ERROR: No changes detected in CHANGELOG.md. Please update the changelog." diff --git a/.github/workflows/labeler.yml b/.github/workflows/labeler.yml index 079b8dfa92..936823a405 100644 --- a/.github/workflows/labeler.yml +++ b/.github/workflows/labeler.yml @@ -1,6 +1,6 @@ name: "Pull Request Labeler" on: - pull_request: + pull_request_target: types: - opened - edited diff --git a/.github/workflows/publish-typescript.yaml b/.github/workflows/publish-typescript.yaml index a5906d5047..890f867d8b 100644 --- a/.github/workflows/publish-typescript.yaml +++ b/.github/workflows/publish-typescript.yaml @@ -16,16 +16,20 @@ jobs: node-version: '20.x' registry-url: 'https://registry.npmjs.org' + - name: Install buf + run: | + curl -sSL https://github.com/bufbuild/buf/releases/download/v1.28.1/buf-Linux-x86_64 -o /usr/local/bin/buf + chmod +x /usr/local/bin/buf + + - name: Generate + run: | + make typescript + - name: Set Version working-directory: typescript run: | - version=$(cat app/setup_handlers.go | grep "const releaseVersion" | cut -d ' ' -f4 | tr -d '"') + version=$(cat ../app/setup_handlers.go | grep "const releaseVersion" | cut -d ' ' -f4 | tr -d '"') npm version ${version} - sed -i 's/@zetachain\/blockchain-types/@zetachain\/node-types/' package.json - - - name: Install dependencies and build 🔧 - working-directory: typescript - run: npm ci && npm run build - name: Publish package on NPM 📦 run: npm publish diff --git a/.gitignore b/.gitignore index d53a2695bd..6a53c9be7b 100644 --- a/.gitignore +++ b/.gitignore @@ -46,3 +46,11 @@ localnet/ganache/storage localnet/zetachain-monorepo /standalone-network/authz/tx.json /zetanode.log + +# Blockscout Files +contrib/localnet/blockscout/services/blockscout-db-data/* +contrib/localnet/blockscout/services/logs/* +contrib/localnet/blockscout/services/redis-data/* +contrib/localnet/blockscout/services/stats-db-data/* +contrib/localnet/grafana/addresses.txt +contrib/localnet/addresses.txt \ No newline at end of file diff --git a/Dockerfile-versioned b/Dockerfile-versioned index c948817829..96e8c0e88e 100644 --- a/Dockerfile-versioned +++ b/Dockerfile-versioned @@ -1,4 +1,4 @@ -FROM golang:1.19-alpine +FROM golang:1.20-alpine3.18 ENV GOPATH /go ENV GOOS=linux @@ -38,10 +38,7 @@ RUN cp $GOPATH/bin/smoketest $GOPATH/bin/old/ RUN git clone https://github.com/zeta-chain/cosmos-sdk.git RUN cd cosmos-sdk && git checkout zetavisor-v0.1.5 RUN cd cosmos-sdk/cosmovisor && make zetavisor -# -#FROM golang:1.19-alpine -#RUN apk --no-cache add openssh jq tmux vim curl bash RUN ssh-keygen -A WORKDIR /root diff --git a/Dockerfile-versioned-source b/Dockerfile-versioned-source index a0ee08a782..f6b90d5126 100644 --- a/Dockerfile-versioned-source +++ b/Dockerfile-versioned-source @@ -1,4 +1,4 @@ -FROM golang:1.19-alpine +FROM golang:1.20-alpine3.18 ENV GOPATH /go ENV GOOS=linux @@ -9,12 +9,15 @@ ARG old_version RUN apk --no-cache add git make build-base jq openssh libusb-dev linux-headers bash curl tmux RUN ssh-keygen -b 2048 -t rsa -f /root/.ssh/localtest.pem -q -N "" +# Build cosmovisor +RUN go install cosmossdk.io/tools/cosmovisor/cmd/cosmovisor@v1.5.0 + WORKDIR /go/delivery/zeta-node RUN mkdir -p $GOPATH/bin/old RUN mkdir -p $GOPATH/bin/new -ENV NEW_VERSION=v42.0.0 +ENV NEW_VERSION=v12.0.0 # Build new release from the current source COPY go.mod /go/delivery/zeta-node/ @@ -22,10 +25,9 @@ COPY go.sum /go/delivery/zeta-node/ RUN cd /go/delivery/zeta-node/ && go mod download COPY . /go/delivery/zeta-node/ RUN cd /go/delivery/zeta-node/ && make install -RUN cd /go/delivery/zeta-node/ && make install-smoketest +RUN cd /go/delivery/zeta-node/ && make install-zetae2e RUN cp $GOPATH/bin/zetacored $GOPATH/bin/new/ RUN cp $GOPATH/bin/zetaclientd $GOPATH/bin/new/ -RUN cp $GOPATH/bin/smoketest $GOPATH/bin/new/ # Checkout and build old binary RUN git clone https://github.com/zeta-chain/node.git @@ -33,18 +35,9 @@ RUN cd node && git fetch RUN cd node && git checkout ${old_version} RUN cd node && make install -RUN cd node && make install-smoketest RUN cp $GOPATH/bin/zetacored $GOPATH/bin/old/ RUN cp $GOPATH/bin/zetaclientd $GOPATH/bin/old/ -RUN cp $GOPATH/bin/smoketest $GOPATH/bin/old/ - -RUN git clone https://github.com/zeta-chain/cosmos-sdk.git -RUN cd cosmos-sdk && git checkout zetavisor-v0.1.5 -RUN cd cosmos-sdk/cosmovisor && make zetavisor -# -#FROM golang:1.19-alpine -#RUN apk --no-cache add openssh jq tmux vim curl bash RUN ssh-keygen -A WORKDIR /root @@ -52,8 +45,8 @@ RUN cp /root/.ssh/localtest.pem.pub /root/.ssh/authorized_keys RUN cp /go/bin/zetaclientd /usr/local/bin RUN cp /go/bin/zetacored /usr/local/bin -RUN cp /go/bin/smoketest /usr/local/bin -RUN cp /go/bin/zetavisor /usr/local/bin +RUN cp /go/bin/zetae2e /usr/local/bin +RUN cp /go/bin/cosmovisor /usr/local/bin COPY contrib/localnet/scripts /root COPY contrib/localnet/preparams /root/preparams diff --git a/Makefile b/Makefile index dd47b6a541..34862f40e3 100644 --- a/Makefile +++ b/Makefile @@ -240,13 +240,26 @@ stateful-upgrade: stateful-upgrade-source: @echo "--> Starting stateful smoketest" - $(DOCKER) build --build-arg old_version=v10.1.7 -t zetanode -f ./Dockerfile-versioned-source . + $(DOCKER) build --build-arg old_version=v11.0.0-patch-core-params -t zetanode -f ./Dockerfile-versioned-source . $(DOCKER) build -t orchestrator -f contrib/localnet/orchestrator/Dockerfile-upgrade.fastbuild . cd contrib/localnet/ && $(DOCKER) compose -f docker-compose-stateful.yml up -d stop-stateful-upgrade: cd contrib/localnet/ && $(DOCKER) compose -f docker-compose-stateful.yml down --remove-orphans +############################################################################### +### Monitoring ### +############################################################################### + +start-monitoring: + @echo "Starting monitoring services" + cd contrib/localnet/grafana/ && ./get-tss-address.sh + cd contrib/localnet/ && $(DOCKER) compose -f docker-compose-monitoring.yml up -d + +stop-monitoring: + @echo "Stopping monitoring services" + cd contrib/localnet/ && $(DOCKER) compose -f docker-compose-monitoring.yml down + ############################################################################### ### GoReleaser ### ############################################################################### diff --git a/app/setup_handlers.go b/app/setup_handlers.go index 8948c68527..533679f243 100644 --- a/app/setup_handlers.go +++ b/app/setup_handlers.go @@ -9,7 +9,7 @@ import ( observertypes "github.com/zeta-chain/zetacore/x/observer/types" ) -const releaseVersion = "v11.0.0" +const releaseVersion = "v12.0.0" func SetupHandlers(app *App) { app.UpgradeKeeper.SetUpgradeHandler(releaseVersion, func(ctx sdk.Context, plan types.Plan, vm module.VersionMap) (module.VersionMap, error) { diff --git a/changelog.md b/changelog.md index 1a15cfa3a4..0498a869e1 100644 --- a/changelog.md +++ b/changelog.md @@ -11,7 +11,7 @@ * ChainNoncesAll :Changed from `/zeta-chain/observer/chainNonces` to `/zeta-chain/observer/chainNonces` . It returns all the chain nonces for all chains. This returns the current nonce of the TSS address for all chains. ### Features - +* [1498](https://github.com/zeta-chain/node/pull/1498) - Add monitoring(grafana, prometheus, ethbalance) for localnet testing * [1395](https://github.com/zeta-chain/node/pull/1395) - Add state variable to track aborted zeta amount * [1410](https://github.com/zeta-chain/node/pull/1410) - `snapshots` commands * enable zetaclients to use dynamic gas price on zetachain - enables >0 min_gas_price in feemarket module @@ -59,6 +59,8 @@ ### Tests +* [1538](https://github.com/zeta-chain/node/pull/1538) - improve stateful e2e testing + ### CI * Removed private runners and unused GitHub Action diff --git a/cmd/zetaclientd/start_utils.go b/cmd/zetaclientd/start_utils.go index 1fcdc1945e..47ed135442 100644 --- a/cmd/zetaclientd/start_utils.go +++ b/cmd/zetaclientd/start_utils.go @@ -34,18 +34,18 @@ func validatePeer(seedPeer string) error { parsedPeer := strings.Split(seedPeer, "/") if len(parsedPeer) < 7 { - return errors.New("seed peer missing IP or ID") + return errors.New("seed peer missing IP or ID or both, seed: " + seedPeer) } seedIP := parsedPeer[2] seedID := parsedPeer[6] if net.ParseIP(seedIP) == nil { - return errors.New("invalid seed IP address") + return errors.New("invalid seed IP address format, seed: " + seedPeer) } if len(seedID) == 0 { - return errors.New("seed id is empty") + return errors.New("seed id is empty, seed: " + seedPeer) } return nil diff --git a/cmd/zetae2e/config/config.go b/cmd/zetae2e/config/config.go index f1635f768e..f307afa02e 100644 --- a/cmd/zetae2e/config/config.go +++ b/cmd/zetae2e/config/config.go @@ -74,3 +74,24 @@ func RunnerFromConfig( return sm, err } + +// ExportContractsFromRunner export contracts from the runner to config using a source config +func ExportContractsFromRunner(sm *runner.SmokeTestRunner, conf config.Config) config.Config { + // copy contracts from deployer runner + conf.Contracts.EVM.ZetaEthAddress = sm.ZetaEthAddr.Hex() + conf.Contracts.EVM.ConnectorEthAddr = sm.ConnectorEthAddr.Hex() + conf.Contracts.EVM.CustodyAddr = sm.ERC20CustodyAddr.Hex() + conf.Contracts.EVM.USDT = sm.USDTERC20Addr.Hex() + + conf.Contracts.ZEVM.SystemContractAddr = sm.SystemContractAddr.Hex() + conf.Contracts.ZEVM.ETHZRC20Addr = sm.ETHZRC20Addr.Hex() + conf.Contracts.ZEVM.USDTZRC20Addr = sm.USDTZRC20Addr.Hex() + conf.Contracts.ZEVM.BTCZRC20Addr = sm.BTCZRC20Addr.Hex() + conf.Contracts.ZEVM.UniswapFactoryAddr = sm.UniswapV2FactoryAddr.Hex() + conf.Contracts.ZEVM.UniswapRouterAddr = sm.UniswapV2RouterAddr.Hex() + conf.Contracts.ZEVM.ZEVMSwapAppAddr = sm.ZEVMSwapAppAddr.Hex() + conf.Contracts.ZEVM.ContextAppAddr = sm.ContextAppAddr.Hex() + conf.Contracts.ZEVM.TestDappAddr = sm.TestDAppAddr.Hex() + + return conf +} diff --git a/cmd/zetae2e/config/contracts.go b/cmd/zetae2e/config/contracts.go index 49ad44dc4c..c49ce98f8b 100644 --- a/cmd/zetae2e/config/contracts.go +++ b/cmd/zetae2e/config/contracts.go @@ -12,7 +12,9 @@ import ( "github.com/zeta-chain/protocol-contracts/pkg/uniswap/v2-core/contracts/uniswapv2factory.sol" uniswapv2router "github.com/zeta-chain/protocol-contracts/pkg/uniswap/v2-periphery/contracts/uniswapv2router02.sol" "github.com/zeta-chain/zetacore/contrib/localnet/orchestrator/smoketest/config" + "github.com/zeta-chain/zetacore/contrib/localnet/orchestrator/smoketest/contracts/contextapp" "github.com/zeta-chain/zetacore/contrib/localnet/orchestrator/smoketest/contracts/erc20" + "github.com/zeta-chain/zetacore/contrib/localnet/orchestrator/smoketest/contracts/zevmswap" "github.com/zeta-chain/zetacore/contrib/localnet/orchestrator/smoketest/runner" ) @@ -133,6 +135,32 @@ func setContractsFromConfig(r *runner.SmokeTestRunner, conf config.Config) error return err } } + if c := conf.Contracts.ZEVM.ZEVMSwapAppAddr; c != "" { + if !ethcommon.IsHexAddress(c) { + return fmt.Errorf("invalid ZEVMSwapAppAddr: %s", c) + } + r.ZEVMSwapAppAddr = ethcommon.HexToAddress(c) + r.ZEVMSwapApp, err = zevmswap.NewZEVMSwapApp(r.ZEVMSwapAppAddr, r.ZevmClient) + if err != nil { + return err + } + } + if c := conf.Contracts.ZEVM.ContextAppAddr; c != "" { + if !ethcommon.IsHexAddress(c) { + return fmt.Errorf("invalid ContextAppAddr: %s", c) + } + r.ContextAppAddr = ethcommon.HexToAddress(c) + r.ContextApp, err = contextapp.NewContextApp(r.ContextAppAddr, r.ZevmClient) + if err != nil { + return err + } + } + if c := conf.Contracts.ZEVM.TestDappAddr; c != "" { + if !ethcommon.IsHexAddress(c) { + return fmt.Errorf("invalid TestDappAddr: %s", c) + } + r.TestDAppAddr = ethcommon.HexToAddress(c) + } return nil } diff --git a/cmd/zetae2e/local/local.go b/cmd/zetae2e/local/local.go index 754f856aa6..72023b8e9b 100644 --- a/cmd/zetae2e/local/local.go +++ b/cmd/zetae2e/local/local.go @@ -3,11 +3,13 @@ package local import ( "context" "os" + "path/filepath" "time" "github.com/fatih/color" "github.com/spf13/cobra" zetae2econfig "github.com/zeta-chain/zetacore/cmd/zetae2e/config" + "github.com/zeta-chain/zetacore/contrib/localnet/orchestrator/smoketest/config" "github.com/zeta-chain/zetacore/contrib/localnet/orchestrator/smoketest/runner" "github.com/zeta-chain/zetacore/contrib/localnet/orchestrator/smoketest/utils" "golang.org/x/sync/errgroup" @@ -21,6 +23,9 @@ const ( flagTestAdmin = "test-admin" flagTestCustom = "test-custom" flagSkipRegular = "skip-regular" + flagSetupOnly = "setup-only" + flagConfigOut = "config-out" + flagSkipSetup = "skip-setup" ) var ( @@ -70,6 +75,21 @@ func NewLocalCmd() *cobra.Command { false, "set to true to skip regular tests", ) + cmd.Flags().Bool( + flagSetupOnly, + false, + "set to true to only setup the networks", + ) + cmd.Flags().String( + flagConfigOut, + "", + "config file to write the deployed contracts from the setup", + ) + cmd.Flags().Bool( + flagSkipSetup, + false, + "set to true to skip setup", + ) return cmd } @@ -101,6 +121,18 @@ func localE2ETest(cmd *cobra.Command, _ []string) { if err != nil { panic(err) } + setupOnly, err := cmd.Flags().GetBool(flagSetupOnly) + if err != nil { + panic(err) + } + configOut, err := cmd.Flags().GetString(flagConfigOut) + if err != nil { + panic(err) + } + skipSetup, err := cmd.Flags().GetBool(flagSkipSetup) + if err != nil { + panic(err) + } testStartTime := time.Now() logger.Print("starting tests") @@ -130,8 +162,11 @@ func localE2ETest(cmd *cobra.Command, _ []string) { setCosmosConfig() // wait for Genesis - logger.Print("⏳ wait 70s for genesis") - time.Sleep(70 * time.Second) + // if setup is skipp, we assume that the genesis is already created + if !skipSetup { + logger.Print("⏳ wait 70s for genesis") + time.Sleep(70 * time.Second) + } // initialize deployer runner with config deployerRunner, err := zetae2econfig.RunnerFromConfig( @@ -150,17 +185,45 @@ func localE2ETest(cmd *cobra.Command, _ []string) { } // wait for keygen to be completed - waitKeygenHeight(ctx, deployerRunner.CctxClient, logger) + // if setup is skipped, we assume that the keygen is already completed + if !skipSetup { + waitKeygenHeight(ctx, deployerRunner.CctxClient, logger) + } + + // query and set the TSS + deployerRunner.SetTSSAddresses() // setting up the networks - logger.Print("⚙️ setting up networks") - startTime := time.Now() + if !skipSetup { + logger.Print("⚙️ setting up networks") + startTime := time.Now() + deployerRunner.SetupEVM(contractsDeployed) + deployerRunner.SetZEVMContracts() + deployerRunner.MintUSDTOnEvm(10000) + logger.Print("✅ setup completed in %s", time.Since(startTime)) + deployerRunner.PrintContractAddresses() + } - deployerRunner.SetTSSAddresses() - deployerRunner.SetupEVM(contractsDeployed) - deployerRunner.SetZEVMContracts() - deployerRunner.MintUSDTOnEvm(10000) - logger.Print("✅ setup completed in %s", time.Since(startTime)) + // if a config output is specified, write the config + if configOut != "" { + newConfig := zetae2econfig.ExportContractsFromRunner(deployerRunner, conf) + configOut, err := filepath.Abs(configOut) + if err != nil { + panic(err) + } + + // write config into stdout + if err := config.WriteConfig(configOut, newConfig); err != nil { + panic(err) + } + + logger.Print("✅ config file written in %s", configOut) + } + + // if setup only, quit + if setupOnly { + os.Exit(0) + } // run tests var eg errgroup.Group diff --git a/cmd/zetae2e/local/utils.go b/cmd/zetae2e/local/utils.go index b1ac34924a..8e1ab210c1 100644 --- a/cmd/zetae2e/local/utils.go +++ b/cmd/zetae2e/local/utils.go @@ -2,6 +2,7 @@ package local import ( "context" + "path/filepath" "time" sdk "github.com/cosmos/cosmos-sdk/types" @@ -27,6 +28,11 @@ func getConfig(cmd *cobra.Command) (config.Config, error) { return config.DefaultConfig(), nil } + configFile, err = filepath.Abs(configFile) + if err != nil { + return config.Config{}, err + } + return config.ReadConfig(configFile) } @@ -77,7 +83,7 @@ func waitKeygenHeight( cctxClient crosschaintypes.QueryClient, logger *runner.Logger, ) { - // wait for keygen to be completed. ~ height 30 + // wait for keygen to be completed keygenHeight := int64(60) logger.Print("⏳ wait height %v for keygen to be completed", keygenHeight) for { diff --git a/contrib/localnet/README.md b/contrib/localnet/README.md index 467e0bc877..96143b06d5 100644 --- a/contrib/localnet/README.md +++ b/contrib/localnet/README.md @@ -76,6 +76,30 @@ which does the following docker compose command: # in zeta-node/contrib/localnet/orchestrator $ docker compose down --remove-orphans ``` +### Run monitoring setup +Before starting the monitoring setup, make sure the Zetacore API is up at http://localhost:1317. +You can also add any additional ETH addresses to monitor in zeta-node/contrib/localnet/grafana/addresses.txt file +```bash +# in zeta-node/ +make start-monitoring +``` +which does the following docker compose command: +```bash +# in zeta-node/contrib/localnet/ +$ docker compose -f docker-compose-monitoring.yml up -d +``` +### Grafana credentials and dashboards +The Grafana default credentials are admin:admin. The dashboards are located at http://localhost:3000. +### Stop monitoring setup +```bash +# in zeta-node/ +make stop-monitoring +``` +which does the following docker compose command: +```bash +# in zeta-node/contrib/localnet/ +$ docker compose -f docker-compose-monitoring.yml down --remove-orphans +``` ## Useful data diff --git a/contrib/localnet/docker-compose-monitoring.yml b/contrib/localnet/docker-compose-monitoring.yml new file mode 100644 index 0000000000..ad66f828ec --- /dev/null +++ b/contrib/localnet/docker-compose-monitoring.yml @@ -0,0 +1,47 @@ +version: '3' + +services: + grafana: + image: grafana/grafana:latest + container_name: grafana + hostname: grafana + volumes: + - ./grafana/datasource.yaml:/etc/grafana/provisioning/datasources/datasource.yaml + - ./grafana/dashboards/:/etc/grafana/provisioning/dashboards + ports: + - "3000:3000" + networks: + mynetwork: + ipv4_address: 172.20.0.30 + + prometheus: + image: prom/prometheus:latest + container_name: prometheus + hostname: prometheus + volumes: + - ./prometheus/prometheus.yml:/etc/prometheus/prometheus.yml + ports: + - "9090:9090" + networks: + mynetwork: + ipv4_address: 172.20.0.31 + + zetachain-exporter: + image: zetachain/zetachain-exporter:latest + container_name: zetachain-exporter + hostname: zetachain-exporter + volumes: + - ./grafana/addresses.txt:/app/addresses.txt + ports: + - "9015:9015" + networks: + mynetwork: + ipv4_address: 172.20.0.32 + environment: + - GETH=http://eth:8545 + +networks: + mynetwork: + ipam: + config: + - subnet: 172.20.0.0/24 \ No newline at end of file diff --git a/contrib/localnet/docker-compose.yml b/contrib/localnet/docker-compose.yml index a618bab292..14f1435776 100644 --- a/contrib/localnet/docker-compose.yml +++ b/contrib/localnet/docker-compose.yml @@ -6,7 +6,6 @@ networks: config: - subnet: 172.20.0.0/24 - services: rosetta: image: zetanode:latest diff --git a/contrib/localnet/grafana/dashboards/cosmos_dashboard.json b/contrib/localnet/grafana/dashboards/cosmos_dashboard.json new file mode 100644 index 0000000000..85ca855f22 --- /dev/null +++ b/contrib/localnet/grafana/dashboards/cosmos_dashboard.json @@ -0,0 +1,1458 @@ +{ + "annotations": { + "list": [ + { + "builtIn": 1, + "datasource": { + "type": "datasource", + "uid": "grafana" + }, + "enable": true, + "hide": true, + "iconColor": "rgba(0, 211, 255, 1)", + "name": "Annotations & Alerts", + "type": "dashboard" + } + ] + }, + "description": "A Grafana dashboard compatible with all the cosmos-sdk and tendermint based blockchains.", + "editable": true, + "fiscalYearStartMonth": 0, + "gnetId": 11036, + "graphTooltip": 0, + "id": 1, + "links": [], + "liveNow": false, + "panels": [ + { + "collapsed": false, + "datasource": { + "type": "prometheus", + "uid": "PBFA97CFB590B2093" + }, + "gridPos": { + "h": 1, + "w": 24, + "x": 0, + "y": 0 + }, + "id": 64, + "panels": [], + "targets": [ + { + "datasource": { + "type": "prometheus", + "uid": "PBFA97CFB590B2093" + }, + "refId": "A" + } + ], + "title": "$chain_id overview", + "type": "row" + }, + { + "datasource": { + "type": "prometheus", + "uid": "PBFA97CFB590B2093" + }, + "gridPos": { + "h": 2, + "w": 24, + "x": 0, + "y": 1 + }, + "id": 62, + "links": [], + "options": { + "code": { + "language": "plaintext", + "showLineNumbers": false, + "showMiniMap": false + }, + "content": "", + "mode": "html" + }, + "pluginVersion": "10.2.2", + "targets": [ + { + "datasource": { + "type": "prometheus", + "uid": "PBFA97CFB590B2093" + }, + "refId": "A" + } + ], + "transparent": true, + "type": "text" + }, + { + "datasource": { + "uid": "$DS" + }, + "description": "", + "fieldConfig": { + "defaults": { + "color": { + "mode": "thresholds" + }, + "decimals": 0, + "mappings": [], + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + }, + { + "color": "red", + "value": 80 + } + ] + }, + "unit": "locale" + }, + "overrides": [] + }, + "gridPos": { + "h": 4, + "w": 6, + "x": 0, + "y": 3 + }, + "hideTimeOverride": false, + "id": 4, + "links": [], + "maxDataPoints": 100, + "options": { + "colorMode": "value", + "graphMode": "none", + "justifyMode": "auto", + "orientation": "horizontal", + "reduceOptions": { + "calcs": [ + "lastNotNull" + ], + "fields": "", + "values": false + }, + "textMode": "auto", + "wideLayout": true + }, + "pluginVersion": "10.2.2", + "targets": [ + { + "datasource": { + "uid": "$DS" + }, + "expr": "tendermint_consensus_height{chain_id=\"$chain_id\", instance=\"$instance\"}", + "format": "time_series", + "hide": false, + "instant": true, + "interval": "30s", + "intervalFactor": 1, + "refId": "A" + } + ], + "title": "Block Height", + "type": "stat" + }, + { + "datasource": { + "uid": "$DS" + }, + "description": "", + "fieldConfig": { + "defaults": { + "color": { + "mode": "thresholds" + }, + "decimals": 0, + "mappings": [], + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + }, + { + "color": "red", + "value": 80 + } + ] + }, + "unit": "locale" + }, + "overrides": [] + }, + "gridPos": { + "h": 4, + "w": 6, + "x": 6, + "y": 3 + }, + "hideTimeOverride": false, + "id": 40, + "links": [], + "maxDataPoints": 100, + "options": { + "colorMode": "value", + "graphMode": "none", + "justifyMode": "auto", + "orientation": "horizontal", + "reduceOptions": { + "calcs": [ + "lastNotNull" + ], + "fields": "", + "values": false + }, + "textMode": "auto", + "wideLayout": true + }, + "pluginVersion": "10.2.2", + "targets": [ + { + "datasource": { + "uid": "$DS" + }, + "expr": "tendermint_consensus_total_txs{chain_id=\"$chain_id\", instance=\"$instance\"}", + "format": "time_series", + "interval": "30s", + "intervalFactor": 1, + "refId": "A" + } + ], + "title": "Total Transactions", + "type": "stat" + }, + { + "datasource": { + "uid": "$DS" + }, + "description": "", + "fieldConfig": { + "defaults": { + "color": { + "mode": "thresholds" + }, + "decimals": 2, + "mappings": [ + { + "options": { + "match": "null", + "result": { + "text": "N/A" + } + }, + "type": "special" + } + ], + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + }, + { + "color": "red", + "value": 80 + } + ] + }, + "unit": "s" + }, + "overrides": [] + }, + "gridPos": { + "h": 4, + "w": 6, + "x": 12, + "y": 3 + }, + "hideTimeOverride": true, + "id": 39, + "links": [], + "maxDataPoints": 100, + "options": { + "colorMode": "value", + "graphMode": "area", + "justifyMode": "auto", + "orientation": "horizontal", + "reduceOptions": { + "calcs": [ + "mean" + ], + "fields": "", + "values": false + }, + "textMode": "auto", + "wideLayout": true + }, + "pluginVersion": "10.2.2", + "targets": [ + { + "datasource": { + "uid": "$DS" + }, + "expr": "tendermint_consensus_block_interval_seconds{chain_id=\"$chain_id\", instance=\"$instance\"}", + "format": "time_series", + "interval": "30s", + "intervalFactor": 1, + "refId": "A" + } + ], + "timeFrom": "1h", + "title": "Avg Block Time", + "type": "stat" + }, + { + "datasource": { + "uid": "$DS" + }, + "description": "", + "fieldConfig": { + "defaults": { + "color": { + "mode": "thresholds" + }, + "decimals": 0, + "mappings": [], + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + }, + { + "color": "red", + "value": 80 + } + ] + }, + "unit": "short" + }, + "overrides": [] + }, + "gridPos": { + "h": 4, + "w": 6, + "x": 18, + "y": 3 + }, + "hideTimeOverride": false, + "id": 47, + "links": [], + "maxDataPoints": 100, + "options": { + "colorMode": "value", + "graphMode": "area", + "justifyMode": "auto", + "orientation": "horizontal", + "reduceOptions": { + "calcs": [ + "lastNotNull" + ], + "fields": "", + "values": false + }, + "textMode": "auto", + "wideLayout": true + }, + "pluginVersion": "10.2.2", + "targets": [ + { + "datasource": { + "uid": "$DS" + }, + "expr": "tendermint_consensus_validators_power{chain_id=\"$chain_id\", instance=\"$instance\"}", + "format": "time_series", + "instant": false, + "interval": "30s", + "intervalFactor": 1, + "refId": "A" + } + ], + "title": "Bonded Tokens", + "type": "stat" + }, + { + "aliasColors": { + "Height for last 3 hours": "#447ebc", + "Total Transactions for last 3 hours": "#ef843c" + }, + "bars": false, + "dashLength": 10, + "dashes": false, + "datasource": { + "uid": "$DS" + }, + "decimals": 0, + "fieldConfig": { + "defaults": { + "links": [] + }, + "overrides": [] + }, + "fill": 3, + "fillGradient": 0, + "gridPos": { + "h": 9, + "w": 12, + "x": 0, + "y": 7 + }, + "hiddenSeries": false, + "hideTimeOverride": false, + "id": 15, + "legend": { + "alignAsTable": true, + "avg": false, + "current": true, + "max": true, + "min": true, + "rightSide": false, + "show": true, + "sideWidth": 350, + "total": false, + "values": true + }, + "lines": true, + "linewidth": 1, + "links": [], + "nullPointMode": "null", + "options": { + "alertThreshold": true + }, + "percentage": false, + "pluginVersion": "10.2.2", + "pointradius": 5, + "points": false, + "renderer": "flot", + "seriesOverrides": [], + "spaceLength": 10, + "stack": false, + "steppedLine": false, + "targets": [ + { + "datasource": { + "uid": "$DS" + }, + "expr": "tendermint_consensus_validators{chain_id=\"$chain_id\", instance=\"$instance\"}", + "format": "time_series", + "instant": false, + "interval": "", + "intervalFactor": 1, + "legendFormat": "Active", + "refId": "A" + }, + { + "datasource": { + "uid": "$DS" + }, + "expr": "tendermint_consensus_missing_validators{chain_id=\"$chain_id\", instance=\"$instance\"}", + "format": "time_series", + "interval": "", + "intervalFactor": 1, + "legendFormat": "Missing", + "refId": "B" + }, + { + "datasource": { + "uid": "$DS" + }, + "expr": "tendermint_consensus_byzantine_validators{chain_id=\"$chain_id\", instance=\"$instance\"}", + "format": "time_series", + "intervalFactor": 1, + "legendFormat": "Byzantine", + "refId": "C" + } + ], + "thresholds": [], + "timeRegions": [], + "title": "Validators", + "tooltip": { + "shared": true, + "sort": 0, + "value_type": "individual" + }, + "type": "graph", + "xaxis": { + "mode": "time", + "show": true, + "values": [] + }, + "yaxes": [ + { + "decimals": 0, + "format": "locale", + "label": "", + "logBase": 1, + "min": "0", + "show": true + }, + { + "format": "none", + "logBase": 1, + "show": false + } + ], + "yaxis": { + "align": false + } + }, + { + "aliasColors": { + "Height for last 3 hours": "#447ebc", + "Total Transactions for last 3 hours": "#ef843c" + }, + "bars": false, + "dashLength": 10, + "dashes": false, + "datasource": { + "uid": "$DS" + }, + "fieldConfig": { + "defaults": { + "links": [] + }, + "overrides": [] + }, + "fill": 3, + "fillGradient": 0, + "gridPos": { + "h": 9, + "w": 12, + "x": 12, + "y": 7 + }, + "hiddenSeries": false, + "hideTimeOverride": false, + "id": 48, + "legend": { + "alignAsTable": true, + "avg": false, + "current": true, + "max": true, + "min": true, + "rightSide": false, + "show": true, + "sideWidth": 350, + "total": false, + "values": true + }, + "lines": true, + "linewidth": 1, + "links": [], + "nullPointMode": "null", + "options": { + "alertThreshold": true + }, + "percentage": false, + "pluginVersion": "10.2.2", + "pointradius": 5, + "points": false, + "renderer": "flot", + "seriesOverrides": [], + "spaceLength": 10, + "stack": false, + "steppedLine": false, + "targets": [ + { + "datasource": { + "uid": "$DS" + }, + "expr": "tendermint_consensus_validators_power{chain_id=\"$chain_id\", instance=\"$instance\"}", + "format": "time_series", + "instant": false, + "interval": "", + "intervalFactor": 1, + "legendFormat": "Online", + "refId": "A" + }, + { + "datasource": { + "uid": "$DS" + }, + "expr": "tendermint_consensus_missing_validators_power{chain_id=\"$chain_id\", instance=\"$instance\"}", + "format": "time_series", + "interval": "", + "intervalFactor": 1, + "legendFormat": "Missing", + "refId": "B" + }, + { + "datasource": { + "uid": "$DS" + }, + "expr": "tendermint_consensus_byzantine_validators_power{chain_id=\"$chain_id\", instance=\"$instance\"}", + "format": "time_series", + "intervalFactor": 1, + "legendFormat": "Byzantine", + "refId": "C" + } + ], + "thresholds": [], + "timeRegions": [], + "title": "Voting Power", + "tooltip": { + "shared": true, + "sort": 0, + "value_type": "individual" + }, + "type": "graph", + "xaxis": { + "mode": "time", + "show": true, + "values": [] + }, + "yaxes": [ + { + "decimals": 0, + "format": "short", + "label": "", + "logBase": 1, + "min": "0", + "show": true + }, + { + "format": "none", + "logBase": 1, + "show": false + } + ], + "yaxis": { + "align": false + } + }, + { + "aliasColors": { + "Height for last 3 hours": "#447ebc", + "Total Transactions for last 3 hours": "#ef843c" + }, + "bars": false, + "dashLength": 10, + "dashes": false, + "datasource": { + "uid": "$DS" + }, + "fieldConfig": { + "defaults": { + "links": [] + }, + "overrides": [] + }, + "fill": 3, + "fillGradient": 0, + "gridPos": { + "h": 5, + "w": 12, + "x": 0, + "y": 16 + }, + "hiddenSeries": false, + "hideTimeOverride": false, + "id": 49, + "legend": { + "alignAsTable": false, + "avg": true, + "current": false, + "max": true, + "min": false, + "rightSide": false, + "show": true, + "total": false, + "values": true + }, + "lines": true, + "linewidth": 1, + "links": [], + "nullPointMode": "null", + "options": { + "alertThreshold": true + }, + "percentage": false, + "pluginVersion": "10.2.2", + "pointradius": 5, + "points": false, + "renderer": "flot", + "seriesOverrides": [], + "spaceLength": 10, + "stack": false, + "steppedLine": false, + "targets": [ + { + "datasource": { + "uid": "$DS" + }, + "expr": "tendermint_consensus_block_size_bytes{chain_id=\"$chain_id\", instance=\"$instance\"}", + "format": "time_series", + "instant": false, + "interval": "", + "intervalFactor": 1, + "legendFormat": "Block Size", + "refId": "A" + } + ], + "thresholds": [], + "timeRegions": [], + "title": "Block Size", + "tooltip": { + "shared": true, + "sort": 0, + "value_type": "individual" + }, + "type": "graph", + "xaxis": { + "mode": "time", + "show": true, + "values": [] + }, + "yaxes": [ + { + "decimals": 2, + "format": "bytes", + "label": "", + "logBase": 1, + "min": "0", + "show": true + }, + { + "format": "none", + "logBase": 1, + "show": false + } + ], + "yaxis": { + "align": false + } + }, + { + "aliasColors": { + "Height for last 3 hours": "#447ebc", + "Total Transactions for last 3 hours": "#ef843c" + }, + "bars": false, + "dashLength": 10, + "dashes": false, + "datasource": { + "uid": "$DS" + }, + "decimals": 0, + "fieldConfig": { + "defaults": { + "links": [] + }, + "overrides": [] + }, + "fill": 3, + "fillGradient": 0, + "gridPos": { + "h": 5, + "w": 12, + "x": 12, + "y": 16 + }, + "hiddenSeries": false, + "hideTimeOverride": false, + "id": 50, + "legend": { + "alignAsTable": false, + "avg": true, + "current": false, + "max": true, + "min": false, + "rightSide": false, + "show": true, + "total": true, + "values": true + }, + "lines": true, + "linewidth": 1, + "links": [], + "nullPointMode": "null", + "options": { + "alertThreshold": true + }, + "percentage": false, + "pluginVersion": "10.2.2", + "pointradius": 5, + "points": false, + "renderer": "flot", + "seriesOverrides": [], + "spaceLength": 10, + "stack": false, + "steppedLine": false, + "targets": [ + { + "datasource": { + "uid": "$DS" + }, + "expr": "tendermint_consensus_num_txs{chain_id=\"$chain_id\", instance=\"$instance\"}", + "format": "time_series", + "instant": false, + "interval": "", + "intervalFactor": 1, + "legendFormat": "Transactions", + "refId": "A" + } + ], + "thresholds": [], + "timeRegions": [], + "title": "Transactions", + "tooltip": { + "shared": true, + "sort": 0, + "value_type": "individual" + }, + "type": "graph", + "xaxis": { + "mode": "time", + "show": true, + "values": [] + }, + "yaxes": [ + { + "decimals": 0, + "format": "short", + "label": "", + "logBase": 1, + "min": "0", + "show": true + }, + { + "format": "none", + "logBase": 1, + "show": false + } + ], + "yaxis": { + "align": false + } + }, + { + "collapsed": false, + "datasource": { + "type": "prometheus", + "uid": "PBFA97CFB590B2093" + }, + "gridPos": { + "h": 1, + "w": 24, + "x": 0, + "y": 21 + }, + "id": 55, + "panels": [], + "repeat": "instance", + "targets": [ + { + "datasource": { + "type": "prometheus", + "uid": "PBFA97CFB590B2093" + }, + "refId": "A" + } + ], + "title": "instance overview: $instance", + "type": "row" + }, + { + "datasource": { + "uid": "$DS" + }, + "description": "", + "fieldConfig": { + "defaults": { + "color": { + "mode": "thresholds" + }, + "decimals": 0, + "mappings": [], + "max": 20, + "min": 0, + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "#e24d42", + "value": null + }, + { + "color": "#ef843c", + "value": 2 + }, + { + "color": "#7eb26d", + "value": 5 + } + ] + }, + "unit": "short" + }, + "overrides": [] + }, + "gridPos": { + "h": 4, + "w": 6, + "x": 0, + "y": 22 + }, + "hideTimeOverride": true, + "id": 53, + "links": [], + "options": { + "minVizHeight": 75, + "minVizWidth": 75, + "orientation": "horizontal", + "reduceOptions": { + "calcs": [ + "last" + ], + "fields": "", + "values": false + }, + "showThresholdLabels": false, + "showThresholdMarkers": true + }, + "pluginVersion": "10.2.2", + "targets": [ + { + "datasource": { + "uid": "$DS" + }, + "expr": "tendermint_p2p_peers{chain_id=\"$chain_id\", instance=~\"$instance\"}", + "format": "time_series", + "instant": true, + "interval": "30s", + "intervalFactor": 1, + "refId": "A" + } + ], + "title": "Connected Peers", + "type": "gauge" + }, + { + "datasource": { + "uid": "$DS" + }, + "description": "", + "fieldConfig": { + "defaults": { + "color": { + "mode": "thresholds" + }, + "decimals": 0, + "mappings": [], + "max": 50, + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "#7eb26d", + "value": null + }, + { + "color": "#ef843c", + "value": 10 + }, + { + "color": "#e24d42", + "value": 20 + } + ] + }, + "unit": "short" + }, + "overrides": [] + }, + "gridPos": { + "h": 4, + "w": 6, + "x": 6, + "y": 22 + }, + "hideTimeOverride": true, + "id": 56, + "links": [], + "options": { + "minVizHeight": 75, + "minVizWidth": 75, + "orientation": "horizontal", + "reduceOptions": { + "calcs": [ + "last" + ], + "fields": "", + "values": false + }, + "showThresholdLabels": false, + "showThresholdMarkers": true + }, + "pluginVersion": "10.2.2", + "targets": [ + { + "datasource": { + "uid": "$DS" + }, + "expr": "tendermint_mempool_size{chain_id=\"$chain_id\", instance=~\"$instance\"}", + "format": "time_series", + "instant": true, + "interval": "30s", + "intervalFactor": 1, + "refId": "A" + } + ], + "title": "Unconfirmed Transactions", + "type": "gauge" + }, + { + "datasource": { + "uid": "$DS" + }, + "description": "", + "fieldConfig": { + "defaults": { + "color": { + "mode": "thresholds" + }, + "decimals": 0, + "mappings": [], + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + }, + { + "color": "red", + "value": 80 + } + ] + }, + "unit": "short" + }, + "overrides": [] + }, + "gridPos": { + "h": 4, + "w": 6, + "x": 12, + "y": 22 + }, + "hideTimeOverride": true, + "id": 60, + "links": [], + "maxDataPoints": 100, + "options": { + "colorMode": "value", + "graphMode": "none", + "justifyMode": "auto", + "orientation": "horizontal", + "reduceOptions": { + "calcs": [ + "lastNotNull" + ], + "fields": "", + "values": false + }, + "textMode": "auto", + "wideLayout": true + }, + "pluginVersion": "10.2.2", + "targets": [ + { + "datasource": { + "uid": "$DS" + }, + "expr": "tendermint_mempool_failed_txs{chain_id=\"$chain_id\", instance=~\"$instance\"}", + "format": "time_series", + "instant": true, + "interval": "30s", + "intervalFactor": 1, + "refId": "A" + } + ], + "title": "Failed Transactions", + "type": "stat" + }, + { + "datasource": { + "uid": "$DS" + }, + "description": "", + "fieldConfig": { + "defaults": { + "color": { + "mode": "thresholds" + }, + "decimals": 0, + "mappings": [], + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + }, + { + "color": "red", + "value": 80 + } + ] + }, + "unit": "locale" + }, + "overrides": [] + }, + "gridPos": { + "h": 4, + "w": 6, + "x": 18, + "y": 22 + }, + "hideTimeOverride": true, + "id": 61, + "links": [], + "maxDataPoints": 100, + "options": { + "colorMode": "value", + "graphMode": "none", + "justifyMode": "auto", + "orientation": "horizontal", + "reduceOptions": { + "calcs": [ + "lastNotNull" + ], + "fields": "", + "values": false + }, + "textMode": "auto", + "wideLayout": true + }, + "pluginVersion": "10.2.2", + "targets": [ + { + "datasource": { + "uid": "$DS" + }, + "expr": "tendermint_mempool_recheck_times{chain_id=\"$chain_id\", instance=~\"$instance\"}", + "format": "time_series", + "instant": true, + "interval": "30s", + "intervalFactor": 1, + "refId": "A" + } + ], + "title": "Recheck Times", + "type": "stat" + }, + { + "aliasColors": {}, + "bars": true, + "dashLength": 10, + "dashes": false, + "datasource": { + "uid": "$DS" + }, + "fieldConfig": { + "defaults": { + "links": [] + }, + "overrides": [] + }, + "fill": 1, + "fillGradient": 0, + "gridPos": { + "h": 9, + "w": 12, + "x": 0, + "y": 26 + }, + "hiddenSeries": false, + "id": 59, + "legend": { + "avg": false, + "current": false, + "max": false, + "min": false, + "rightSide": false, + "show": false, + "total": false, + "values": false + }, + "lines": false, + "linewidth": 1, + "links": [], + "nullPointMode": "null", + "options": { + "alertThreshold": true + }, + "percentage": false, + "pluginVersion": "10.2.2", + "pointradius": 5, + "points": false, + "renderer": "flot", + "seriesOverrides": [], + "spaceLength": 10, + "stack": false, + "steppedLine": false, + "targets": [ + { + "datasource": { + "uid": "$DS" + }, + "expr": "tendermint_p2p_peer_receive_bytes_total{chain_id=\"$chain_id\", instance=\"$instance\"}", + "format": "time_series", + "intervalFactor": 1, + "legendFormat": "{{peer_id}}", + "refId": "A" + } + ], + "thresholds": [], + "timeRegions": [], + "title": "Total Network Input", + "tooltip": { + "shared": false, + "sort": 0, + "value_type": "individual" + }, + "type": "graph", + "xaxis": { + "mode": "series", + "show": false, + "values": [ + "current" + ] + }, + "yaxes": [ + { + "format": "bytes", + "logBase": 1, + "show": true + }, + { + "format": "short", + "logBase": 1, + "show": false + } + ], + "yaxis": { + "align": false + } + }, + { + "aliasColors": {}, + "bars": true, + "dashLength": 10, + "dashes": false, + "datasource": { + "uid": "$DS" + }, + "fieldConfig": { + "defaults": { + "links": [] + }, + "overrides": [] + }, + "fill": 1, + "fillGradient": 0, + "gridPos": { + "h": 9, + "w": 12, + "x": 12, + "y": 26 + }, + "hiddenSeries": false, + "id": 58, + "legend": { + "avg": false, + "current": false, + "max": false, + "min": false, + "rightSide": false, + "show": false, + "total": false, + "values": false + }, + "lines": false, + "linewidth": 1, + "links": [], + "nullPointMode": "null", + "options": { + "alertThreshold": true + }, + "percentage": false, + "pluginVersion": "10.2.2", + "pointradius": 5, + "points": false, + "renderer": "flot", + "seriesOverrides": [], + "spaceLength": 10, + "stack": false, + "steppedLine": false, + "targets": [ + { + "datasource": { + "uid": "$DS" + }, + "expr": "tendermint_p2p_peer_send_bytes_total{chain_id=\"$chain_id\", instance=\"$instance\"}", + "format": "time_series", + "intervalFactor": 1, + "legendFormat": "{{peer_id}}", + "refId": "A" + } + ], + "thresholds": [], + "timeRegions": [], + "title": "Total Network Output", + "tooltip": { + "shared": false, + "sort": 0, + "value_type": "individual" + }, + "type": "graph", + "xaxis": { + "mode": "series", + "show": false, + "values": [ + "current" + ] + }, + "yaxes": [ + { + "format": "bytes", + "logBase": 1, + "show": true + }, + { + "format": "short", + "logBase": 1, + "show": false + } + ], + "yaxis": { + "align": false + } + } + ], + "refresh": "", + "schemaVersion": 38, + "tags": [ + "Blockchain", + "Cosmos" + ], + "templating": { + "list": [ + { + "current": { + "selected": false, + "text": "Prometheus", + "value": "PBFA97CFB590B2093" + }, + "hide": 0, + "includeAll": false, + "label": "Datasource", + "multi": false, + "name": "DS", + "options": [], + "query": "prometheus", + "refresh": 1, + "regex": "", + "skipUrlSync": false, + "type": "datasource" + }, + { + "current": { + "selected": false, + "text": "athens_101-1", + "value": "athens_101-1" + }, + "datasource": { + "uid": "$DS" + }, + "definition": "label_values(tendermint_consensus_height, chain_id)", + "hide": 0, + "includeAll": false, + "label": "Chain ID", + "multi": false, + "name": "chain_id", + "options": [], + "query": "label_values(tendermint_consensus_height, chain_id)", + "refresh": 1, + "regex": "", + "skipUrlSync": false, + "sort": 0, + "tagValuesQuery": "", + "tagsQuery": "", + "type": "query", + "useTags": false + }, + { + "allValue": "", + "current": { + "selected": false, + "text": "172.20.0.11:26660", + "value": "172.20.0.11:26660" + }, + "datasource": { + "uid": "$DS" + }, + "definition": "label_values(tendermint_consensus_height{chain_id=\"$chain_id\"}, instance)", + "hide": 0, + "includeAll": false, + "label": "Instance", + "multi": false, + "name": "instance", + "options": [], + "query": "label_values(tendermint_consensus_height{chain_id=\"$chain_id\"}, instance)", + "refresh": 1, + "regex": "", + "skipUrlSync": false, + "sort": 5, + "tagValuesQuery": "", + "tagsQuery": "", + "type": "query", + "useTags": false + } + ] + }, + "time": { + "from": "now/d", + "to": "now" + }, + "timepicker": { + "refresh_intervals": [ + "5s", + "10s", + "30s", + "1m", + "5m", + "15m", + "30m", + "1h", + "2h", + "1d" + ], + "time_options": [ + "5m", + "15m", + "1h", + "6h", + "12h", + "24h", + "2d", + "7d", + "30d" + ] + }, + "timezone": "", + "title": "Cosmos Dashboard", + "uid": "UJyurCTWz", + "version": 1, + "weekStart": "" +} \ No newline at end of file diff --git a/contrib/localnet/grafana/dashboards/default.yaml b/contrib/localnet/grafana/dashboards/default.yaml new file mode 100644 index 0000000000..581a362406 --- /dev/null +++ b/contrib/localnet/grafana/dashboards/default.yaml @@ -0,0 +1,8 @@ +apiVersion: 1 + +providers: + - name: Default # A uniquely identifiable name for the provider + folder: Dashboards # The folder where to place the dashboards + type: file + options: + path: /etc/grafana/provisioning/dashboards # Path to dashboard files on disk (required) \ No newline at end of file diff --git a/contrib/localnet/grafana/dashboards/eth_balance.json b/contrib/localnet/grafana/dashboards/eth_balance.json new file mode 100644 index 0000000000..7cafe4c4d9 --- /dev/null +++ b/contrib/localnet/grafana/dashboards/eth_balance.json @@ -0,0 +1,955 @@ +{ + "annotations": { + "list": [ + { + "builtIn": 1, + "datasource": { + "type": "datasource", + "uid": "grafana" + }, + "enable": true, + "hide": true, + "iconColor": "rgba(0, 211, 255, 1)", + "name": "Annotations & Alerts", + "type": "dashboard" + } + ] + }, + "description": "Graph Ethereum Wallet Balances", + "editable": true, + "fiscalYearStartMonth": 0, + "gnetId": 6970, + "graphTooltip": 0, + "id": 4, + "links": [], + "liveNow": false, + "panels": [ + { + "datasource": { + "type": "prometheus", + "uid": "PBFA97CFB590B2093" + }, + "fieldConfig": { + "defaults": { + "color": { + "mode": "thresholds" + }, + "mappings": [ + { + "options": { + "match": "null", + "result": { + "text": "N/A" + } + }, + "type": "special" + } + ], + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + }, + { + "color": "red", + "value": 80 + } + ] + }, + "unit": "none" + }, + "overrides": [] + }, + "gridPos": { + "h": 4, + "w": 4, + "x": 0, + "y": 0 + }, + "id": 3, + "links": [], + "maxDataPoints": 100, + "options": { + "colorMode": "none", + "graphMode": "none", + "justifyMode": "auto", + "orientation": "horizontal", + "reduceOptions": { + "calcs": [ + "lastNotNull" + ], + "fields": "", + "values": false + }, + "textMode": "auto", + "wideLayout": true + }, + "pluginVersion": "10.2.2", + "targets": [ + { + "datasource": { + "type": "prometheus", + "uid": "PBFA97CFB590B2093" + }, + "expr": "eth_total_addresses", + "format": "time_series", + "intervalFactor": 1, + "refId": "A" + } + ], + "title": "Total Addresses Logged", + "type": "stat" + }, + { + "aliasColors": {}, + "bars": false, + "dashLength": 10, + "dashes": false, + "datasource": { + "type": "prometheus", + "uid": "PBFA97CFB590B2093" + }, + "fill": 2, + "fillGradient": 0, + "gridPos": { + "h": 8, + "w": 16, + "x": 4, + "y": 0 + }, + "hiddenSeries": false, + "id": 6, + "legend": { + "avg": false, + "current": false, + "max": false, + "min": false, + "show": true, + "total": false, + "values": false + }, + "lines": true, + "linewidth": 1, + "links": [], + "nullPointMode": "null", + "options": { + "alertThreshold": true + }, + "percentage": false, + "pluginVersion": "10.2.2", + "pointradius": 5, + "points": false, + "renderer": "flot", + "seriesOverrides": [], + "spaceLength": 10, + "stack": false, + "steppedLine": false, + "targets": [ + { + "datasource": { + "type": "prometheus", + "uid": "PBFA97CFB590B2093" + }, + "expr": "topk(5, eth_balance)", + "format": "time_series", + "intervalFactor": 1, + "legendFormat": "{{name}}", + "refId": "A" + } + ], + "thresholds": [], + "timeRegions": [], + "title": "Top 5 Balances", + "tooltip": { + "shared": true, + "sort": 0, + "value_type": "individual" + }, + "type": "graph", + "xaxis": { + "mode": "time", + "show": true, + "values": [] + }, + "yaxes": [ + { + "format": "short", + "logBase": 1, + "show": true + }, + { + "format": "short", + "logBase": 1, + "show": true + } + ], + "yaxis": { + "align": false + } + }, + { + "datasource": { + "type": "prometheus", + "uid": "PBFA97CFB590B2093" + }, + "fieldConfig": { + "defaults": { + "color": { + "mode": "thresholds" + }, + "mappings": [ + { + "options": { + "match": "null", + "result": { + "text": "N/A" + } + }, + "type": "special" + } + ], + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "#299c46", + "value": null + }, + { + "color": "#fce2de", + "value": 0 + }, + { + "color": "#d44a3a", + "value": 100 + } + ] + }, + "unit": "percent" + }, + "overrides": [] + }, + "gridPos": { + "h": 4, + "w": 4, + "x": 20, + "y": 0 + }, + "id": 11, + "links": [], + "maxDataPoints": 100, + "options": { + "colorMode": "value", + "graphMode": "none", + "justifyMode": "auto", + "orientation": "horizontal", + "reduceOptions": { + "calcs": [ + "lastNotNull" + ], + "fields": "", + "values": false + }, + "textMode": "auto", + "wideLayout": true + }, + "pluginVersion": "10.2.2", + "targets": [ + { + "datasource": { + "type": "prometheus", + "uid": "PBFA97CFB590B2093" + }, + "expr": "(eth_balance_total - eth_balance_total offset 1m) / eth_balance_total", + "format": "time_series", + "instant": false, + "intervalFactor": 1, + "refId": "A" + } + ], + "title": "Total ETH 1 Hour Change", + "type": "stat" + }, + { + "datasource": { + "type": "prometheus", + "uid": "PBFA97CFB590B2093" + }, + "fieldConfig": { + "defaults": { + "color": { + "mode": "thresholds" + }, + "mappings": [ + { + "options": { + "match": "null", + "result": { + "text": "N/A" + } + }, + "type": "special" + } + ], + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + }, + { + "color": "red", + "value": 80 + } + ] + }, + "unit": "dtdurations" + }, + "overrides": [] + }, + "gridPos": { + "h": 4, + "w": 4, + "x": 0, + "y": 4 + }, + "id": 2, + "links": [], + "maxDataPoints": 100, + "options": { + "colorMode": "none", + "graphMode": "none", + "justifyMode": "auto", + "orientation": "horizontal", + "reduceOptions": { + "calcs": [ + "lastNotNull" + ], + "fields": "", + "values": false + }, + "textMode": "auto", + "wideLayout": true + }, + "pluginVersion": "10.2.2", + "targets": [ + { + "datasource": { + "type": "prometheus", + "uid": "PBFA97CFB590B2093" + }, + "expr": "eth_load_seconds", + "format": "time_series", + "intervalFactor": 1, + "refId": "A" + } + ], + "title": "Total Load Time", + "type": "stat" + }, + { + "datasource": { + "type": "prometheus", + "uid": "PBFA97CFB590B2093" + }, + "fieldConfig": { + "defaults": { + "color": { + "mode": "thresholds" + }, + "mappings": [ + { + "options": { + "match": "null", + "result": { + "text": "N/A" + } + }, + "type": "special" + } + ], + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "#299c46", + "value": null + }, + { + "color": "#fce2de", + "value": 0 + }, + { + "color": "#d44a3a", + "value": 100 + } + ] + }, + "unit": "percent" + }, + "overrides": [] + }, + "gridPos": { + "h": 4, + "w": 4, + "x": 20, + "y": 4 + }, + "id": 12, + "links": [], + "maxDataPoints": 100, + "options": { + "colorMode": "value", + "graphMode": "none", + "justifyMode": "auto", + "orientation": "horizontal", + "reduceOptions": { + "calcs": [ + "lastNotNull" + ], + "fields": "", + "values": false + }, + "textMode": "auto", + "wideLayout": true + }, + "pluginVersion": "10.2.2", + "targets": [ + { + "datasource": { + "type": "prometheus", + "uid": "PBFA97CFB590B2093" + }, + "expr": "(eth_balance_total - eth_balance_total offset 24h) / eth_balance_total", + "format": "time_series", + "instant": false, + "intervalFactor": 1, + "refId": "A" + } + ], + "title": "Total ETH 24 Hour Change", + "type": "stat" + }, + { + "datasource": { + "type": "datasource", + "uid": "grafana" + }, + "gridPos": { + "h": 3, + "w": 24, + "x": 0, + "y": 8 + }, + "id": 14, + "links": [], + "options": { + "code": { + "language": "plaintext", + "showLineNumbers": false, + "showMiniMap": false + }, + "content": "
${name}
", + "mode": "html" + }, + "pluginVersion": "10.2.2", + "targets": [ + { + "datasource": { + "type": "datasource", + "uid": "grafana" + }, + "refId": "A" + } + ], + "type": "text" + }, + { + "aliasColors": {}, + "bars": false, + "dashLength": 10, + "dashes": false, + "datasource": { + "type": "prometheus", + "uid": "PBFA97CFB590B2093" + }, + "fill": 7, + "fillGradient": 0, + "gridPos": { + "h": 8, + "w": 14, + "x": 0, + "y": 11 + }, + "hiddenSeries": false, + "id": 5, + "legend": { + "avg": false, + "current": false, + "max": false, + "min": false, + "show": false, + "total": false, + "values": false + }, + "lines": true, + "linewidth": 1, + "links": [], + "nullPointMode": "null", + "options": { + "alertThreshold": true + }, + "percentage": false, + "pluginVersion": "10.2.2", + "pointradius": 5, + "points": false, + "renderer": "flot", + "seriesOverrides": [], + "spaceLength": 10, + "stack": false, + "steppedLine": false, + "targets": [ + { + "datasource": { + "type": "prometheus", + "uid": "PBFA97CFB590B2093" + }, + "expr": "eth_balance{name=\"${name}\"}", + "format": "time_series", + "intervalFactor": 1, + "legendFormat": "${name} ETH", + "refId": "A" + } + ], + "thresholds": [], + "timeRegions": [], + "title": "${name} Balance", + "tooltip": { + "shared": true, + "sort": 0, + "value_type": "individual" + }, + "type": "graph", + "xaxis": { + "mode": "time", + "show": true, + "values": [] + }, + "yaxes": [ + { + "format": "locale", + "label": "ETH", + "logBase": 1, + "show": true + }, + { + "format": "short", + "logBase": 1, + "show": true + } + ], + "yaxis": { + "align": false + } + }, + { + "datasource": { + "type": "prometheus", + "uid": "PBFA97CFB590B2093" + }, + "fieldConfig": { + "defaults": { + "color": { + "mode": "thresholds" + }, + "mappings": [ + { + "options": { + "match": "null", + "result": { + "text": "N/A" + } + }, + "type": "special" + } + ], + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + }, + { + "color": "red", + "value": 80 + } + ] + }, + "unit": "locale" + }, + "overrides": [] + }, + "gridPos": { + "h": 4, + "w": 5, + "x": 14, + "y": 11 + }, + "id": 7, + "links": [], + "maxDataPoints": 100, + "options": { + "colorMode": "none", + "graphMode": "none", + "justifyMode": "auto", + "orientation": "horizontal", + "reduceOptions": { + "calcs": [ + "lastNotNull" + ], + "fields": "", + "values": false + }, + "textMode": "auto", + "wideLayout": true + }, + "pluginVersion": "10.2.2", + "targets": [ + { + "datasource": { + "type": "prometheus", + "uid": "PBFA97CFB590B2093" + }, + "expr": "eth_balance{name=\"${name}\"}", + "format": "time_series", + "instant": false, + "intervalFactor": 1, + "refId": "A" + } + ], + "title": "${name} ETH", + "type": "stat" + }, + { + "datasource": { + "type": "prometheus", + "uid": "PBFA97CFB590B2093" + }, + "fieldConfig": { + "defaults": { + "color": { + "mode": "thresholds" + }, + "mappings": [ + { + "options": { + "match": "null", + "result": { + "text": "N/A" + } + }, + "type": "special" + } + ], + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "#299c46", + "value": null + }, + { + "color": "#fce2de", + "value": 0 + }, + { + "color": "#d44a3a", + "value": 100 + } + ] + }, + "unit": "percent" + }, + "overrides": [] + }, + "gridPos": { + "h": 4, + "w": 5, + "x": 19, + "y": 11 + }, + "id": 8, + "links": [], + "maxDataPoints": 100, + "options": { + "colorMode": "value", + "graphMode": "none", + "justifyMode": "auto", + "orientation": "horizontal", + "reduceOptions": { + "calcs": [ + "lastNotNull" + ], + "fields": "", + "values": false + }, + "textMode": "auto", + "wideLayout": true + }, + "pluginVersion": "10.2.2", + "targets": [ + { + "datasource": { + "type": "prometheus", + "uid": "PBFA97CFB590B2093" + }, + "expr": "(eth_balance{name=\"${name}\"} - eth_balance{name=\"${name}\"} offset 1h) / eth_balance{name=\"${name}\"}", + "format": "time_series", + "instant": false, + "intervalFactor": 1, + "refId": "A" + } + ], + "title": "${name} ETH 1 Hour Change", + "type": "stat" + }, + { + "datasource": { + "type": "prometheus", + "uid": "PBFA97CFB590B2093" + }, + "fieldConfig": { + "defaults": { + "color": { + "mode": "thresholds" + }, + "mappings": [ + { + "options": { + "match": "null", + "result": { + "text": "N/A" + } + }, + "type": "special" + } + ], + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "#299c46", + "value": null + }, + { + "color": "#fce2de", + "value": 0 + }, + { + "color": "#d44a3a", + "value": 100 + } + ] + }, + "unit": "percent" + }, + "overrides": [] + }, + "gridPos": { + "h": 4, + "w": 5, + "x": 14, + "y": 15 + }, + "id": 10, + "links": [], + "maxDataPoints": 100, + "options": { + "colorMode": "value", + "graphMode": "none", + "justifyMode": "auto", + "orientation": "horizontal", + "reduceOptions": { + "calcs": [ + "lastNotNull" + ], + "fields": "", + "values": false + }, + "textMode": "auto", + "wideLayout": true + }, + "pluginVersion": "10.2.2", + "targets": [ + { + "datasource": { + "type": "prometheus", + "uid": "PBFA97CFB590B2093" + }, + "expr": "(eth_balance{name=\"${name}\"} - eth_balance{name=\"${name}\"} offset 24h) / eth_balance{name=\"${name}\"}", + "format": "time_series", + "instant": false, + "intervalFactor": 1, + "refId": "A" + } + ], + "title": "${name} ETH 24 Hour Change", + "type": "stat" + }, + { + "datasource": { + "type": "prometheus", + "uid": "PBFA97CFB590B2093" + }, + "fieldConfig": { + "defaults": { + "color": { + "mode": "thresholds" + }, + "mappings": [ + { + "options": { + "match": "null", + "result": { + "text": "N/A" + } + }, + "type": "special" + } + ], + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "#299c46", + "value": null + }, + { + "color": "#fce2de", + "value": 0 + }, + { + "color": "#d44a3a", + "value": 100 + } + ] + }, + "unit": "percent" + }, + "overrides": [] + }, + "gridPos": { + "h": 4, + "w": 5, + "x": 19, + "y": 15 + }, + "id": 9, + "links": [], + "maxDataPoints": 100, + "options": { + "colorMode": "value", + "graphMode": "none", + "justifyMode": "auto", + "orientation": "horizontal", + "reduceOptions": { + "calcs": [ + "lastNotNull" + ], + "fields": "", + "values": false + }, + "textMode": "auto", + "wideLayout": true + }, + "pluginVersion": "10.2.2", + "targets": [ + { + "datasource": { + "type": "prometheus", + "uid": "PBFA97CFB590B2093" + }, + "expr": "(eth_balance{name=\"${name}\"} - eth_balance{name=\"${name}\"} offset 7d) / eth_balance{name=\"${name}\"}", + "format": "time_series", + "instant": false, + "intervalFactor": 1, + "refId": "A" + } + ], + "title": "${name} ETH Week Change", + "type": "stat" + } + ], + "refresh": "", + "schemaVersion": 38, + "tags": [], + "templating": { + "list": [ + { + "current": { + "selected": false, + "text": "ethTSS", + "value": "ethTSS" + }, + "datasource": { + "type": "prometheus", + "uid": "PBFA97CFB590B2093" + }, + "definition": "", + "hide": 0, + "includeAll": false, + "label": "name", + "multi": false, + "name": "name", + "options": [], + "query": "label_values(eth_balance, name)", + "refresh": 1, + "regex": "", + "skipUrlSync": false, + "sort": 1, + "tagValuesQuery": "", + "tagsQuery": "", + "type": "query", + "useTags": false + } + ] + }, + "time": { + "from": "now-6h", + "to": "now" + }, + "timepicker": { + "refresh_intervals": [ + "5s", + "10s", + "30s", + "1m", + "5m", + "15m", + "30m", + "1h", + "2h", + "1d" + ], + "time_options": [ + "5m", + "15m", + "1h", + "6h", + "12h", + "24h", + "2d", + "7d", + "30d" + ] + }, + "timezone": "", + "title": "Ethereum Wallet Monitor", + "uid": "pgGHUOdmv", + "version": 1, + "weekStart": "" +} \ No newline at end of file diff --git a/contrib/localnet/grafana/dashboards/zetaclient_dashboard.json b/contrib/localnet/grafana/dashboards/zetaclient_dashboard.json new file mode 100644 index 0000000000..68194ee1f9 --- /dev/null +++ b/contrib/localnet/grafana/dashboards/zetaclient_dashboard.json @@ -0,0 +1,551 @@ +{ + "annotations": { + "list": [ + { + "builtIn": 1, + "datasource": { + "type": "grafana", + "uid": "-- Grafana --" + }, + "enable": true, + "hide": true, + "iconColor": "rgba(0, 211, 255, 1)", + "name": "Annotations & Alerts", + "type": "dashboard" + } + ] + }, + "description": "Dashboard for Zetaclient Metrics", + "editable": true, + "fiscalYearStartMonth": 0, + "graphTooltip": 0, + "id": 6, + "links": [], + "liveNow": false, + "panels": [ + { + "collapsed": false, + "gridPos": { + "h": 1, + "w": 24, + "x": 0, + "y": 0 + }, + "id": 6, + "panels": [], + "title": "Zetaclient Dashboard", + "type": "row" + }, + { + "datasource": { + "type": "prometheus", + "uid": "PBFA97CFB590B2093" + }, + "fieldConfig": { + "defaults": { + "color": { + "mode": "palette-classic" + }, + "custom": { + "axisBorderShow": false, + "axisCenteredZero": false, + "axisColorMode": "text", + "axisLabel": "", + "axisPlacement": "auto", + "barAlignment": 0, + "drawStyle": "line", + "fillOpacity": 0, + "gradientMode": "none", + "hideFrom": { + "legend": false, + "tooltip": false, + "viz": false + }, + "insertNulls": false, + "lineInterpolation": "linear", + "lineWidth": 1, + "pointSize": 5, + "scaleDistribution": { + "type": "linear" + }, + "showPoints": "auto", + "spanNulls": false, + "stacking": { + "group": "A", + "mode": "none" + }, + "thresholdsStyle": { + "mode": "off" + } + }, + "mappings": [], + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + }, + { + "color": "red", + "value": 80 + } + ] + } + }, + "overrides": [] + }, + "gridPos": { + "h": 8, + "w": 12, + "x": 0, + "y": 1 + }, + "id": 4, + "options": { + "legend": { + "calcs": [], + "displayMode": "list", + "placement": "bottom", + "showLegend": true + }, + "tooltip": { + "mode": "single", + "sort": "none" + } + }, + "targets": [ + { + "datasource": { + "type": "prometheus", + "uid": "PBFA97CFB590B2093" + }, + "disableTextWrap": false, + "editorMode": "builder", + "expr": "zetaclient_pending_txs_goerli_localnet", + "fullMetaSearch": false, + "includeNullMetadata": true, + "instant": false, + "legendFormat": "__auto", + "range": true, + "refId": "A", + "useBackend": false + } + ], + "title": "Pending Transaction Goerli Localnet", + "type": "timeseries" + }, + { + "datasource": { + "type": "prometheus", + "uid": "PBFA97CFB590B2093" + }, + "fieldConfig": { + "defaults": { + "color": { + "mode": "palette-classic" + }, + "custom": { + "axisBorderShow": false, + "axisCenteredZero": false, + "axisColorMode": "text", + "axisLabel": "", + "axisPlacement": "auto", + "barAlignment": 0, + "drawStyle": "line", + "fillOpacity": 0, + "gradientMode": "none", + "hideFrom": { + "legend": false, + "tooltip": false, + "viz": false + }, + "insertNulls": false, + "lineInterpolation": "linear", + "lineWidth": 1, + "pointSize": 5, + "scaleDistribution": { + "type": "linear" + }, + "showPoints": "auto", + "spanNulls": false, + "stacking": { + "group": "A", + "mode": "none" + }, + "thresholdsStyle": { + "mode": "off" + } + }, + "mappings": [], + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + }, + { + "color": "red", + "value": 80 + } + ] + } + }, + "overrides": [] + }, + "gridPos": { + "h": 8, + "w": 12, + "x": 12, + "y": 1 + }, + "id": 2, + "options": { + "legend": { + "calcs": [], + "displayMode": "list", + "placement": "bottom", + "showLegend": true + }, + "tooltip": { + "mode": "single", + "sort": "none" + } + }, + "targets": [ + { + "datasource": { + "type": "prometheus", + "uid": "PBFA97CFB590B2093" + }, + "disableTextWrap": false, + "editorMode": "builder", + "expr": "zetaclient_hotkey_burn_rate", + "fullMetaSearch": false, + "includeNullMetadata": true, + "instant": false, + "legendFormat": "__auto", + "range": true, + "refId": "A", + "useBackend": false + } + ], + "title": "Hotkey Burn Rate", + "type": "timeseries" + }, + { + "datasource": { + "type": "prometheus", + "uid": "PBFA97CFB590B2093" + }, + "fieldConfig": { + "defaults": { + "color": { + "mode": "palette-classic" + }, + "custom": { + "axisBorderShow": false, + "axisCenteredZero": false, + "axisColorMode": "text", + "axisLabel": "", + "axisPlacement": "auto", + "barAlignment": 0, + "drawStyle": "line", + "fillOpacity": 0, + "gradientMode": "none", + "hideFrom": { + "legend": false, + "tooltip": false, + "viz": false + }, + "insertNulls": false, + "lineInterpolation": "linear", + "lineWidth": 1, + "pointSize": 5, + "scaleDistribution": { + "type": "linear" + }, + "showPoints": "auto", + "spanNulls": false, + "stacking": { + "group": "A", + "mode": "none" + }, + "thresholdsStyle": { + "mode": "off" + } + }, + "mappings": [], + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + }, + { + "color": "red", + "value": 80 + } + ] + } + }, + "overrides": [] + }, + "gridPos": { + "h": 8, + "w": 12, + "x": 0, + "y": 9 + }, + "id": 3, + "options": { + "legend": { + "calcs": [], + "displayMode": "list", + "placement": "bottom", + "showLegend": true + }, + "tooltip": { + "mode": "single", + "sort": "none" + } + }, + "targets": [ + { + "datasource": { + "type": "prometheus", + "uid": "PBFA97CFB590B2093" + }, + "disableTextWrap": false, + "editorMode": "builder", + "expr": "zetaclient_pending_txs_btc_regtest", + "fullMetaSearch": false, + "includeNullMetadata": true, + "instant": false, + "legendFormat": "__auto", + "range": true, + "refId": "A", + "useBackend": false + } + ], + "title": "Pending Transactions BTC", + "type": "timeseries" + }, + { + "datasource": { + "type": "prometheus", + "uid": "PBFA97CFB590B2093" + }, + "fieldConfig": { + "defaults": { + "color": { + "mode": "palette-classic" + }, + "custom": { + "axisBorderShow": false, + "axisCenteredZero": false, + "axisColorMode": "text", + "axisLabel": "", + "axisPlacement": "auto", + "barAlignment": 0, + "drawStyle": "line", + "fillOpacity": 0, + "gradientMode": "none", + "hideFrom": { + "legend": false, + "tooltip": false, + "viz": false + }, + "insertNulls": false, + "lineInterpolation": "linear", + "lineWidth": 1, + "pointSize": 5, + "scaleDistribution": { + "type": "linear" + }, + "showPoints": "auto", + "spanNulls": false, + "stacking": { + "group": "A", + "mode": "none" + }, + "thresholdsStyle": { + "mode": "off" + } + }, + "mappings": [], + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + }, + { + "color": "red", + "value": 80 + } + ] + } + }, + "overrides": [] + }, + "gridPos": { + "h": 8, + "w": 12, + "x": 12, + "y": 9 + }, + "id": 1, + "options": { + "legend": { + "calcs": [], + "displayMode": "list", + "placement": "bottom", + "showLegend": true + }, + "tooltip": { + "mode": "single", + "sort": "none" + } + }, + "targets": [ + { + "datasource": { + "type": "prometheus", + "uid": "PBFA97CFB590B2093" + }, + "disableTextWrap": false, + "editorMode": "builder", + "expr": "zetaclient_Outbound_tx_sign_count{instance=\"172.20.0.21:8886\"}", + "fullMetaSearch": false, + "includeNullMetadata": true, + "instant": false, + "legendFormat": "__auto", + "range": true, + "refId": "A", + "useBackend": false + } + ], + "title": "Outbound Transaction Sign Count", + "type": "timeseries" + }, + { + "datasource": { + "type": "prometheus", + "uid": "PBFA97CFB590B2093" + }, + "fieldConfig": { + "defaults": { + "color": { + "mode": "palette-classic" + }, + "custom": { + "axisBorderShow": false, + "axisCenteredZero": false, + "axisColorMode": "text", + "axisLabel": "", + "axisPlacement": "auto", + "barAlignment": 0, + "drawStyle": "line", + "fillOpacity": 0, + "gradientMode": "none", + "hideFrom": { + "legend": false, + "tooltip": false, + "viz": false + }, + "insertNulls": false, + "lineInterpolation": "linear", + "lineWidth": 1, + "pointSize": 5, + "scaleDistribution": { + "type": "linear" + }, + "showPoints": "auto", + "spanNulls": false, + "stacking": { + "group": "A", + "mode": "none" + }, + "thresholdsStyle": { + "mode": "off" + } + }, + "mappings": [], + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + }, + { + "color": "red", + "value": 80 + } + ] + } + }, + "overrides": [] + }, + "gridPos": { + "h": 8, + "w": 12, + "x": 0, + "y": 17 + }, + "id": 5, + "options": { + "legend": { + "calcs": [], + "displayMode": "list", + "placement": "bottom", + "showLegend": true + }, + "tooltip": { + "mode": "single", + "sort": "none" + } + }, + "targets": [ + { + "datasource": { + "type": "prometheus", + "uid": "PBFA97CFB590B2093" + }, + "disableTextWrap": false, + "editorMode": "builder", + "expr": "zetaclient_rpc_getBlockByNumber_count_goerli_localnet", + "fullMetaSearch": false, + "includeNullMetadata": true, + "instant": false, + "legendFormat": "__auto", + "range": true, + "refId": "A", + "useBackend": false + } + ], + "title": "BlockByNo Count Goerli/Localnet", + "type": "timeseries" + } + ], + "refresh": "", + "schemaVersion": 38, + "tags": [], + "templating": { + "list": [] + }, + "time": { + "from": "now-6h", + "to": "now" + }, + "timepicker": {}, + "timezone": "", + "title": "Zetaclient Dashboard", + "uid": "efac1ac6-2adb-4123-8833-a8634c5fa64d", + "version": 9, + "weekStart": "" +} \ No newline at end of file diff --git a/contrib/localnet/grafana/datasource.yaml b/contrib/localnet/grafana/datasource.yaml new file mode 100644 index 0000000000..59cd333a94 --- /dev/null +++ b/contrib/localnet/grafana/datasource.yaml @@ -0,0 +1,16 @@ +apiVersion: 1 + +datasources: + - name: Prometheus + type: prometheus + access: proxy + # Access mode - proxy (server in the UI) or direct (browser in the UI). + url: http://prometheus:9090 + jsonData: + httpMethod: POST + manageAlerts: true + prometheusType: Prometheus + prometheusVersion: 2.48.1 + cacheLevel: 'High' + disableRecordingRules: false + incrementalQueryOverlapWindow: 10m \ No newline at end of file diff --git a/contrib/localnet/grafana/get-tss-address.sh b/contrib/localnet/grafana/get-tss-address.sh new file mode 100755 index 0000000000..eae4b031af --- /dev/null +++ b/contrib/localnet/grafana/get-tss-address.sh @@ -0,0 +1,9 @@ +#!/bin/bash + +/usr/sbin/sshd + +#retrieve value of ETH TSS Address from localnet +ethTSS_address=$(curl 'http://localhost:1317/zeta-chain/observer/get_tss_address' | jq -r '.eth') + +#write value of ETH TSS Address to addresses.txt file +printf "ethTSS:$ethTSS_address\n" > addresses.txt \ No newline at end of file diff --git a/contrib/localnet/orchestrator/Dockerfile-upgrade.fastbuild b/contrib/localnet/orchestrator/Dockerfile-upgrade.fastbuild index 3fb6b69e67..5cbccbc0a6 100644 --- a/contrib/localnet/orchestrator/Dockerfile-upgrade.fastbuild +++ b/contrib/localnet/orchestrator/Dockerfile-upgrade.fastbuild @@ -16,9 +16,7 @@ COPY contrib/localnet/orchestrator/start-upgrade.sh /work/ COPY contrib/localnet/orchestrator/restart-zetaclientd.sh /work/ RUN chmod +x /work/*.sh - -COPY --from=zeta /go/bin/old/smoketest /usr/local/bin/smoketest-old -COPY --from=zeta /go/bin/new/smoketest /usr/local/bin/smoketest-new -RUN chmod +x /usr/local/bin/smoketest-* +COPY --from=zeta /usr/local/bin/zetae2e /usr/local/bin/ +RUN chmod +x /usr/local/bin/zetae2e WORKDIR /work diff --git a/contrib/localnet/orchestrator/restart-zetaclientd.sh b/contrib/localnet/orchestrator/restart-zetaclientd.sh index d5f8b1becc..207eebf4aa 100644 --- a/contrib/localnet/orchestrator/restart-zetaclientd.sh +++ b/contrib/localnet/orchestrator/restart-zetaclientd.sh @@ -33,11 +33,13 @@ CURRENT_HEIGHT=0 while [[ $CURRENT_HEIGHT -lt $UPGRADE_HEIGHT ]] do - CURRENT_HEIGHT=$(curl zetacore0:26657/status | jq '.result.sync_info.latest_block_height' | tr -d '"') + CURRENT_HEIGHT=$(curl -s zetacore0:26657/status | jq '.result.sync_info.latest_block_height' | tr -d '"') + echo current height is "$CURRENT_HEIGHT", waiting for "$UPGRADE_HEIGHT" sleep 5 done -echo current height is "$CURRENT_HEIGHT", restarting zetaclients +echo upgrade height reached, restarting zetaclients + for NODE in "${CLIENT_LIST[@]}"; do ssh -o "StrictHostKeyChecking no" "$NODE" -i ~/.ssh/localtest.pem killall zetaclientd ssh -o "StrictHostKeyChecking no" "$NODE" -i ~/.ssh/localtest.pem "$GOPATH/bin/new/zetaclientd start < /dev/null > $HOME/zetaclient.log 2>&1 &" diff --git a/contrib/localnet/orchestrator/smoketest/config/config.go b/contrib/localnet/orchestrator/smoketest/config/config.go index 5685fe38c0..097bc58641 100644 --- a/contrib/localnet/orchestrator/smoketest/config/config.go +++ b/contrib/localnet/orchestrator/smoketest/config/config.go @@ -1,14 +1,12 @@ package config import ( + "errors" "os" "gopkg.in/yaml.v2" ) -// TODO: support pre-deployed addresses for zEVM contracts -// https://github.com/zeta-chain/node-private/issues/41 - // Config contains the configuration for the smoke test type Config struct { Accounts Accounts `yaml:"accounts"` @@ -55,6 +53,9 @@ type ZEVM struct { BTCZRC20Addr string `yaml:"btc_zrc20"` UniswapFactoryAddr string `yaml:"uniswap_factory"` UniswapRouterAddr string `yaml:"uniswap_router"` + ZEVMSwapAppAddr string `yaml:"zevm_swap_app"` + ContextAppAddr string `yaml:"context_app"` + TestDappAddr string `yaml:"test_dapp"` } func DefaultConfig() Config { @@ -77,6 +78,10 @@ func DefaultConfig() Config { // ReadConfig reads the config file func ReadConfig(file string) (config Config, err error) { + if file == "" { + return Config{}, errors.New("file name cannot be empty") + } + // #nosec G304 -- this is a config file b, err := os.ReadFile(file) if err != nil { @@ -91,6 +96,10 @@ func ReadConfig(file string) (config Config, err error) { // WriteConfig writes the config file func WriteConfig(file string, config Config) error { + if file == "" { + return errors.New("file name cannot be empty") + } + b, err := yaml.Marshal(config) if err != nil { return err diff --git a/contrib/localnet/orchestrator/smoketest/runner/bitcoin.go b/contrib/localnet/orchestrator/smoketest/runner/bitcoin.go index 0277710e69..9ee876a04e 100644 --- a/contrib/localnet/orchestrator/smoketest/runner/bitcoin.go +++ b/contrib/localnet/orchestrator/smoketest/runner/bitcoin.go @@ -7,6 +7,9 @@ import ( "math/big" "time" + "github.com/zeta-chain/zetacore/contrib/localnet/orchestrator/smoketest/utils" + crosschaintypes "github.com/zeta-chain/zetacore/x/crosschain/types" + "github.com/btcsuite/btcd/btcjson" "github.com/btcsuite/btcd/chaincfg/chainhash" "github.com/btcsuite/btcd/rpcclient" @@ -65,7 +68,7 @@ func (sm *SmokeTestRunner) DepositBTC(testHeader bool) { panic(err) } amount2 := 0.05 + zetaclient.BtcDepositorFeeMin - _, err = sm.SendToTSSFromDeployerToDeposit(sm.BTCTSSAddress, amount2, utxos[2:4], btc, sm.BTCDeployerAddress) + txHash2, err := sm.SendToTSSFromDeployerToDeposit(sm.BTCTSSAddress, amount2, utxos[2:4], btc, sm.BTCDeployerAddress) if err != nil { panic(err) } @@ -86,25 +89,21 @@ func (sm *SmokeTestRunner) DepositBTC(testHeader bool) { sm.Logger.Info("testing if the deposit into BTC ZRC20 is successful...") - initialBalance, err := sm.BTCZRC20.BalanceOf(&bind.CallOpts{}, sm.DeployerAddress) + cctx := utils.WaitCctxMinedByInTxHash(sm.Ctx, txHash2.String(), sm.CctxClient, sm.Logger, sm.CctxTimeout) + if cctx.CctxStatus.Status != crosschaintypes.CctxStatus_OutboundMined { + panic(fmt.Sprintf( + "expected mined status; got %s, message: %s", + cctx.CctxStatus.Status.String(), + cctx.CctxStatus.StatusMessage), + ) + } + + balance, err := sm.BTCZRC20.BalanceOf(&bind.CallOpts{}, sm.DeployerAddress) if err != nil { panic(err) } - for { - time.Sleep(2 * time.Second) - balance, err := sm.BTCZRC20.BalanceOf(&bind.CallOpts{}, sm.DeployerAddress) - if err != nil { - panic(err) - } - diff := big.NewInt(0) - diff.Sub(balance, initialBalance) - sm.Logger.Info("BTC Difference in balance: %d", diff.Uint64()) - if diff.Cmp(big.NewInt(1.15*btcutil.SatoshiPerBitcoin)) != 0 { - sm.Logger.Info("waiting for BTC balance to show up in ZRC contract... current bal %d", balance) - } else { - sm.Logger.Info("BTC balance is in ZRC contract! Success") - break - } + if balance.Cmp(big.NewInt(0)) != 1 { + panic("balance should be positive") } // due to the high block throughput in localnet, ZetaClient might catch up slowly with the blocks diff --git a/contrib/localnet/orchestrator/smoketest/runner/evm.go b/contrib/localnet/orchestrator/smoketest/runner/evm.go index fc0734e895..f2bb0aaea5 100644 --- a/contrib/localnet/orchestrator/smoketest/runner/evm.go +++ b/contrib/localnet/orchestrator/smoketest/runner/evm.go @@ -110,7 +110,6 @@ func (sm *SmokeTestRunner) DepositERC20WithAmountAndMessage(amount *big.Int, msg sm.Logger.Info(" Amount: %d", event.Amount) sm.Logger.Info(" Message: %x", event.Message) } - sm.Logger.Info("gas limit %d", sm.ZevmAuth.GasLimit) return tx.Hash() } diff --git a/contrib/localnet/orchestrator/smoketest/runner/runner.go b/contrib/localnet/orchestrator/smoketest/runner/runner.go index a09a351036..60698ac114 100644 --- a/contrib/localnet/orchestrator/smoketest/runner/runner.go +++ b/contrib/localnet/orchestrator/smoketest/runner/runner.go @@ -306,3 +306,27 @@ func (sm *SmokeTestRunner) Lock() { func (sm *SmokeTestRunner) Unlock() { sm.mutex.Unlock() } + +// PrintContractAddresses prints the addresses of the contracts +// the printed contracts are grouped in a zevm and evm section +// there is a padding used to print the addresses at the same position +func (sm *SmokeTestRunner) PrintContractAddresses() { + // zevm contracts + sm.Logger.Print(" --- 📜zEVM contracts ---") + sm.Logger.Print("SystemContract: %s", sm.SystemContractAddr.Hex()) + sm.Logger.Print("ETHZRC20: %s", sm.ETHZRC20Addr.Hex()) + sm.Logger.Print("USDTZRC20: %s", sm.USDTZRC20Addr.Hex()) + sm.Logger.Print("BTCZRC20: %s", sm.BTCZRC20Addr.Hex()) + sm.Logger.Print("UniswapFactory: %s", sm.UniswapV2FactoryAddr.Hex()) + sm.Logger.Print("UniswapRouter: %s", sm.UniswapV2RouterAddr.Hex()) + sm.Logger.Print("ZEVMSwapApp: %s", sm.ZEVMSwapAppAddr.Hex()) + sm.Logger.Print("ContextApp: %s", sm.ContextAppAddr.Hex()) + sm.Logger.Print("TestDapp: %s", sm.TestDAppAddr.Hex()) + + // evm contracts + sm.Logger.Print(" --- 📜EVM contracts ---") + sm.Logger.Print("ZetaEth: %s", sm.ZetaEthAddr.Hex()) + sm.Logger.Print("ConnectorEth: %s", sm.ConnectorEthAddr.Hex()) + sm.Logger.Print("ERC20Custody: %s", sm.ERC20CustodyAddr.Hex()) + sm.Logger.Print("USDTERC20: %s", sm.USDTERC20Addr.Hex()) +} diff --git a/contrib/localnet/orchestrator/smoketest/runner/setup_zeta.go b/contrib/localnet/orchestrator/smoketest/runner/setup_zeta.go index 80a7606ba2..5a266f3156 100644 --- a/contrib/localnet/orchestrator/smoketest/runner/setup_zeta.go +++ b/contrib/localnet/orchestrator/smoketest/runner/setup_zeta.go @@ -2,10 +2,11 @@ package runner import ( "math/big" + "strings" "time" + "github.com/btcsuite/btcutil" "github.com/ethereum/go-ethereum/accounts/abi/bind" - ethcommon "github.com/ethereum/go-ethereum/common" "github.com/zeta-chain/protocol-contracts/pkg/contracts/zevm/systemcontract.sol" "github.com/zeta-chain/protocol-contracts/pkg/contracts/zevm/zrc20.sol" @@ -15,6 +16,7 @@ import ( "github.com/zeta-chain/zetacore/contrib/localnet/orchestrator/smoketest/contracts/contextapp" "github.com/zeta-chain/zetacore/contrib/localnet/orchestrator/smoketest/contracts/zevmswap" "github.com/zeta-chain/zetacore/contrib/localnet/orchestrator/smoketest/utils" + crosschaintypes "github.com/zeta-chain/zetacore/x/crosschain/types" fungibletypes "github.com/zeta-chain/zetacore/x/fungible/types" observertypes "github.com/zeta-chain/zetacore/x/observer/types" ) @@ -28,7 +30,14 @@ func (sm *SmokeTestRunner) SetTSSAddresses() { for { res, err = sm.ObserverClient.GetTssAddress(sm.Ctx, &observertypes.QueryGetTssAddressRequest{}) if err != nil { - sm.Logger.Info("cctxClient.TSS error %s", err.Error()) + // if error contains unknown method GetTssAddress for service, we might be using an older version of the chain for upgrade test + // we query the TSS address with legacy method + if strings.Contains(err.Error(), "unknown method GetTssAddress for service") { + sm.SetTSSAddressesLegacy() + return + } + + sm.Logger.Info("ObserverClient.TSS error %s", err.Error()) sm.Logger.Info("TSS not ready yet, waiting for TSS to be appear in zetacore network...") time.Sleep(1 * time.Second) continue @@ -176,3 +185,29 @@ func (sm *SmokeTestRunner) SetupBTCZRC20() { } sm.BTCZRC20 = BTCZRC20 } + +// SetTSSAddressesLegacy set TSS addresses from information queried from ZetaChain using legacy TSS query +// TODO: remove this function after v12 once upgrade testing is no longer needed with v11 +func (sm *SmokeTestRunner) SetTSSAddressesLegacy() { + var err error + res := &crosschaintypes.QueryGetTssAddressResponse{} + for { + res, err = sm.CctxClient.GetTssAddress(sm.Ctx, &crosschaintypes.QueryGetTssAddressRequest{}) + if err != nil { + sm.Logger.Info("cctxClient.TSS (legacy) error %s", err.Error()) + sm.Logger.Info("TSS not ready yet, waiting for TSS to be appear in zetacore network...") + time.Sleep(1 * time.Second) + continue + } + break + } + + tssAddress := ethcommon.HexToAddress(res.Eth) + btcTSSAddress, err := btcutil.DecodeAddress(res.Btc, common.BitcoinRegnetParams) + if err != nil { + panic(err) + } + + sm.TSSAddress = tssAddress + sm.BTCTSSAddress = btcTSSAddress +} diff --git a/contrib/localnet/orchestrator/smoketest/smoketests/test_crosschain_swap.go b/contrib/localnet/orchestrator/smoketest/smoketests/test_crosschain_swap.go index 166a6dfec2..1a1ce1aa3c 100644 --- a/contrib/localnet/orchestrator/smoketest/smoketests/test_crosschain_swap.go +++ b/contrib/localnet/orchestrator/smoketest/smoketests/test_crosschain_swap.go @@ -19,9 +19,9 @@ func TestCrosschainSwap(sm *runner.SmokeTestRunner) { // https://github.com/zeta-chain/node-private/issues/88 // it is kept as is for now to be consistent with the old implementation // if the tx fails due to already initialized, it will be ignored - txCreatePair, err := sm.UniswapV2Factory.CreatePair(sm.ZevmAuth, sm.USDTZRC20Addr, sm.BTCZRC20Addr) + _, err := sm.UniswapV2Factory.CreatePair(sm.ZevmAuth, sm.USDTZRC20Addr, sm.BTCZRC20Addr) if err != nil { - panic(err) + sm.Logger.Print("ℹ️create pair error") } txUSDTApprove, err := sm.USDTZRC20.Approve(sm.ZevmAuth, sm.UniswapV2RouterAddr, big.NewInt(1e18)) if err != nil { @@ -42,9 +42,6 @@ func TestCrosschainSwap(sm *runner.SmokeTestRunner) { panic(err) } - if receipt := utils.MustWaitForTxReceipt(sm.Ctx, sm.ZevmClient, txCreatePair, sm.Logger, sm.ReceiptTimeout); receipt.Status != 1 { - panic("create pair failed") - } if receipt := utils.MustWaitForTxReceipt(sm.Ctx, sm.ZevmClient, txUSDTApprove, sm.Logger, sm.ReceiptTimeout); receipt.Status != 1 { panic("usdt approve failed") } diff --git a/contrib/localnet/orchestrator/smoketest/smoketests/test_zrc20_swap.go b/contrib/localnet/orchestrator/smoketest/smoketests/test_zrc20_swap.go index 1f96c46ff9..203fa1df0a 100644 --- a/contrib/localnet/orchestrator/smoketest/smoketests/test_zrc20_swap.go +++ b/contrib/localnet/orchestrator/smoketest/smoketests/test_zrc20_swap.go @@ -17,10 +17,10 @@ func TestZRC20Swap(sm *runner.SmokeTestRunner) { // if the tx fails due to already initialized, it will be ignored tx, err := sm.UniswapV2Factory.CreatePair(sm.ZevmAuth, sm.USDTZRC20Addr, sm.ETHZRC20Addr) if err != nil { - panic(err) + sm.Logger.Print("ℹ️create pair error") + } else { + utils.MustWaitForTxReceipt(sm.Ctx, sm.ZevmClient, tx, sm.Logger, sm.ReceiptTimeout) } - receipt := utils.MustWaitForTxReceipt(sm.Ctx, sm.ZevmClient, tx, sm.Logger, sm.ReceiptTimeout) - //sm.Logger.Info("USDT-ETH pair receipt txhash %s status %d", receipt.TxHash, receipt.Status) usdtEthPair, err := sm.UniswapV2Factory.GetPair(&bind.CallOpts{}, sm.USDTZRC20Addr, sm.ETHZRC20Addr) if err != nil { @@ -32,7 +32,7 @@ func TestZRC20Swap(sm *runner.SmokeTestRunner) { if err != nil { panic(err) } - receipt = utils.MustWaitForTxReceipt(sm.Ctx, sm.ZevmClient, tx, sm.Logger, sm.ReceiptTimeout) + receipt := utils.MustWaitForTxReceipt(sm.Ctx, sm.ZevmClient, tx, sm.Logger, sm.ReceiptTimeout) sm.Logger.Info("USDT ZRC20 approval receipt txhash %s status %d", receipt.TxHash, receipt.Status) tx, err = sm.ETHZRC20.Approve(sm.ZevmAuth, sm.UniswapV2RouterAddr, big.NewInt(1e18)) diff --git a/contrib/localnet/orchestrator/start-upgrade.sh b/contrib/localnet/orchestrator/start-upgrade.sh index a9e123ad72..1d8c5aa570 100644 --- a/contrib/localnet/orchestrator/start-upgrade.sh +++ b/contrib/localnet/orchestrator/start-upgrade.sh @@ -1,42 +1,67 @@ #!/bin/bash -SMOKETEST_CMD=$1 +ZETAE2E_CMD=$1 echo "waiting for geth RPC to start..." -sleep 6 +sleep 2 + +# unlock the deployer account echo "funding deployer address 0xE5C5367B8224807Ac2207d350E60e1b6F27a7ecC with 100 Ether" geth --exec 'eth.sendTransaction({from: eth.coinbase, to: "0xE5C5367B8224807Ac2207d350E60e1b6F27a7ecC", value: web3.toWei(100,"ether")})' attach http://eth:8545 -echo "funding TSS address 0xF421292cb0d3c97b90EEEADfcD660B893592c6A2 with 1 Ether" -geth --exec 'eth.sendTransaction({from: eth.coinbase, to: "0xF421292cb0d3c97b90EEEADfcD660B893592c6A2", value: web3.toWei(100,"ether")})' attach http://eth:8545 - -echo "waiting for 6s for the transaction to be mined" -sleep 6 -echo "the new balance of the deployer addrees:" -curl -sS http://eth:8545 \ - -X POST \ - -H "Content-Type: application/json" \ - --data '{"method":"eth_getBalance","params":["0xE5C5367B8224807Ac2207d350E60e1b6F27a7ecC", "latest"],"id":1,"jsonrpc":"2.0"}' -curl -sS http://eth:8545 \ - -X POST \ - -H "Content-Type: application/json" \ - --data '{"method":"eth_getBalance","params":["0xF421292cb0d3c97b90EEEADfcD660B893592c6A2", "latest"],"id":1,"jsonrpc":"2.0"}' -echo "running smoketest..." -smoketest-old "$SMOKETEST_CMD" -SMOKETEST_EXIT_CODE=$? -if [ $SMOKETEST_EXIT_CODE -ne 0 ]; then - echo "smoketest failed" + +# unlock erc20 tester accounts +echo "funding deployer address 0x6F57D5E7c6DBb75e59F1524a3dE38Fc389ec5Fd6 with 100 Ether" +geth --exec 'eth.sendTransaction({from: eth.coinbase, to: "0x6F57D5E7c6DBb75e59F1524a3dE38Fc389ec5Fd6", value: web3.toWei(100,"ether")})' attach http://eth:8545 + +# unlock zeta tester accounts +echo "funding deployer address 0x5cC2fBb200A929B372e3016F1925DcF988E081fd with 100 Ether" +geth --exec 'eth.sendTransaction({from: eth.coinbase, to: "0x5cC2fBb200A929B372e3016F1925DcF988E081fd", value: web3.toWei(100,"ether")})' attach http://eth:8545 + +# unlock bitcoin tester accounts +echo "funding deployer address 0x283d810090EdF4043E75247eAeBcE848806237fD with 100 Ether" +geth --exec 'eth.sendTransaction({from: eth.coinbase, to: "0x283d810090EdF4043E75247eAeBcE848806237fD", value: web3.toWei(100,"ether")})' attach http://eth:8545 + +# unlock ethers tester accounts +echo "funding deployer address 0x8D47Db7390AC4D3D449Cc20D799ce4748F97619A with 100 Ether" +geth --exec 'eth.sendTransaction({from: eth.coinbase, to: "0x8D47Db7390AC4D3D449Cc20D799ce4748F97619A", value: web3.toWei(100,"ether")})' attach http://eth:8545 + +# unlock miscellaneous tests accounts +echo "funding deployer address 0x90126d02E41c9eB2a10cfc43aAb3BD3460523Cdf with 100 Ether" +geth --exec 'eth.sendTransaction({from: eth.coinbase, to: "0x90126d02E41c9eB2a10cfc43aAb3BD3460523Cdf", value: web3.toWei(100,"ether")})' attach http://eth:8545 + +# unlock advanced erc20 tests accounts +echo "funding deployer address 0xcC8487562AAc220ea4406196Ee902C7c076966af with 100 Ether" +geth --exec 'eth.sendTransaction({from: eth.coinbase, to: "0xcC8487562AAc220ea4406196Ee902C7c076966af", value: web3.toWei(100,"ether")})' attach http://eth:8545 + + +echo "running E2E command to setup the networks and populate the state..." + +zetae2e "$ZETAE2E_CMD" --config-out deployed.yml + +ZETAE2E_EXIT_CODE=$? +if [ $ZETAE2E_EXIT_CODE -ne 0 ]; then + echo "E2E setup failed" exit 1 fi +echo "E2E setup passed, waiting for upgrade height..." + # Restart zetaclients at upgrade height -/work/restart-zetaclientd.sh -u 400 -n 2 +/work/restart-zetaclientd.sh -u 180 -n 2 + +echo "waiting 10 seconds for node to restart..." + +sleep 10 + +echo "running E2E command to test the network after upgrade..." -smoketest-new "$SMOKETEST_CMD" --deployed --wait-for 405 +zetae2e "$ZETAE2E_CMD" --skip-setup --config deployed.yml -if [ $SMOKETEST_EXIT_CODE -eq 0 ]; then - echo "smoketest passed" +ZETAE2E_EXIT_CODE=$? +if [ $ZETAE2E_EXIT_CODE -eq 0 ]; then + echo "E2E passed after upgrade" exit 0 else - echo "smoketest failed" + echo "E2E failed after upgrade" exit 1 fi \ No newline at end of file diff --git a/contrib/localnet/orchestrator/start.sh b/contrib/localnet/orchestrator/start.sh index e79cb3bb39..2c0901a2c2 100644 --- a/contrib/localnet/orchestrator/start.sh +++ b/contrib/localnet/orchestrator/start.sh @@ -33,22 +33,10 @@ geth --exec 'eth.sendTransaction({from: eth.coinbase, to: "0x90126d02E41c9eB2a10 echo "funding deployer address 0xcC8487562AAc220ea4406196Ee902C7c076966af with 100 Ether" geth --exec 'eth.sendTransaction({from: eth.coinbase, to: "0xcC8487562AAc220ea4406196Ee902C7c076966af", value: web3.toWei(100,"ether")})' attach http://eth:8545 - # unlock the TSS account echo "funding TSS address 0xF421292cb0d3c97b90EEEADfcD660B893592c6A2 with 100 Ether" geth --exec 'eth.sendTransaction({from: eth.coinbase, to: "0xF421292cb0d3c97b90EEEADfcD660B893592c6A2", value: web3.toWei(100,"ether")})' attach http://eth:8545 -## wait for the transaction to be mined -#echo "waiting for 6s for the transaction to be mined" -#sleep 6 - -# note: uncomment the following lines to print the balance of the deployer address if debugging is needed -#echo "the new balance of the deployer address:" -#curl -sS http://eth:8545 \ -# -X POST \ -# -H "Content-Type: application/json" \ -# --data '{"method":"eth_getBalance","params":["0xE5C5367B8224807Ac2207d350E60e1b6F27a7ecC", "latest"],"id":1,"jsonrpc":"2.0"}' - # run e2e tests echo "running e2e tests..." zetae2e "$ZETAE2E_CMD" @@ -56,6 +44,7 @@ ZETAE2E_EXIT_CODE=$? # if e2e passed, exit with 0, otherwise exit with 1 if [ $ZETAE2E_EXIT_CODE -eq 0 ]; then + cat /work/deployed.yml echo "e2e passed" exit 0 else diff --git a/contrib/localnet/prometheus/prometheus.yml b/contrib/localnet/prometheus/prometheus.yml new file mode 100644 index 0000000000..3c73f90385 --- /dev/null +++ b/contrib/localnet/prometheus/prometheus.yml @@ -0,0 +1,39 @@ +# my global config +global: + scrape_interval: 15s # Set the scrape interval to every 15 seconds. Default is every 1 minute. + evaluation_interval: 15s # Evaluate rules every 15 seconds. The default is every 1 minute. + # scrape_timeout is set to the global default (10s). + +# Alertmanager configuration +alerting: + alertmanagers: + - static_configs: + - targets: + # - alertmanager:9093 + +# Load rules once and periodically evaluate them according to the global 'evaluation_interval'. +rule_files: +# - "first_rules.yml" +# - "second_rules.yml" + +# A scrape configuration containing exactly one endpoint to scrape: +# Here it's Prometheus itself. +scrape_configs: + # The job name is added as a label `job=` to any timeseries scraped from this config. + - job_name: "zetacore" + # metrics_path defaults to '/metrics' + # scheme defaults to 'http'. + static_configs: + - targets: ["172.20.0.11:26660"] + + - job_name: "zetaclient" + # metrics_path defaults to '/metrics' + # scheme defaults to 'http'. + static_configs: + - targets: ["172.20.0.21:8886"] + + - job_name: "ethbalance" + # metrics_path defaults to '/metrics' + # scheme defaults to 'http'. + static_configs: + - targets: ["172.20.0.32:9015"] \ No newline at end of file diff --git a/contrib/localnet/scripts/genesis-stateful.sh b/contrib/localnet/scripts/genesis-stateful.sh index cf2923d5f2..5099fcfc4a 100755 --- a/contrib/localnet/scripts/genesis-stateful.sh +++ b/contrib/localnet/scripts/genesis-stateful.sh @@ -58,7 +58,7 @@ source ~/os-info.sh if [ $HOSTNAME != "zetacore0" ] then echo "Waiting for zetacore0 to create genesis.json" - sleep $((7*NUMOFNODES)) + sleep 10 echo "genesis.json created" fi @@ -91,7 +91,7 @@ then # 2. Add the observers , authorizations and required params to the genesis.json zetacored collect-observer-info - zetacored add-observer-list + zetacored add-observer-list --keygen-block 55 cat $HOME/.zetacored/config/genesis.json | jq '.app_state["staking"]["params"]["bond_denom"]="azeta"' > $HOME/.zetacored/config/tmp_genesis.json && mv $HOME/.zetacored/config/tmp_genesis.json $HOME/.zetacored/config/genesis.json cat $HOME/.zetacored/config/genesis.json | jq '.app_state["crisis"]["constant_fee"]["denom"]="azeta"' > $HOME/.zetacored/config/tmp_genesis.json && mv $HOME/.zetacored/config/tmp_genesis.json $HOME/.zetacored/config/genesis.json cat $HOME/.zetacored/config/genesis.json | jq '.app_state["gov"]["deposit_params"]["min_deposit"][0]["denom"]="azeta"' > $HOME/.zetacored/config/tmp_genesis.json && mv $HOME/.zetacored/config/tmp_genesis.json $HOME/.zetacored/config/genesis.json @@ -103,8 +103,8 @@ then # set fungible admin account as admin for fungible token zetacored add-genesis-account zeta1srsq755t654agc0grpxj4y3w0znktrpr9tcdgk 100000000000000000000000000azeta zetacored add-genesis-account zeta1n0rn6sne54hv7w2uu93fl48ncyqz97d3kty6sh 100000000000000000000000000azeta # Funds the localnet_gov_admin account - cat $HOME/.zetacored/config/genesis.json | jq '.app_state["observer"]["params"]["admin_policy"][2]["address"]="zeta1srsq755t654agc0grpxj4y3w0znktrpr9tcdgk"' > $HOME/.zetacored/config/tmp_genesis.json && mv $HOME/.zetacored/config/tmp_genesis.json $HOME/.zetacored/config/genesis.json - + cat $HOME/.zetacored/config/genesis.json | jq '.app_state["observer"]["params"]["admin_policy"][0]["address"]="zeta1srsq755t654agc0grpxj4y3w0znktrpr9tcdgk"' > $HOME/.zetacored/config/tmp_genesis.json && mv $HOME/.zetacored/config/tmp_genesis.json $HOME/.zetacored/config/genesis.json + cat $HOME/.zetacored/config/genesis.json | jq '.app_state["observer"]["params"]["admin_policy"][1]["address"]="zeta1srsq755t654agc0grpxj4y3w0znktrpr9tcdgk"' > $HOME/.zetacored/config/tmp_genesis.json && mv $HOME/.zetacored/config/tmp_genesis.json $HOME/.zetacored/config/genesis.json # 3. Copy the genesis.json to all the nodes .And use it to create a gentx for every node zetacored gentx operator 1000000000000000000000azeta --chain-id=$CHAINID --keyring-backend=$KEYRING @@ -151,36 +151,36 @@ then sed -i -e "/persistent_peers =/s/=.*/= \"$pps\"/" "$HOME"/.zetacored/config/config.toml fi -mkdir -p $DAEMON_HOME/zetavisor/genesis/bin -mkdir -p $DAEMON_HOME/zetavisor/upgrades/"$UpgradeName"/bin +mkdir -p $DAEMON_HOME/cosmovisor/genesis/bin +mkdir -p $DAEMON_HOME/cosmovisor/upgrades/"$UpgradeName"/bin -# Setup zetavisor +# Setup cosmovisor # Genesis -cp $GOPATH/bin/old/zetacored $DAEMON_HOME/zetavisor/genesis/bin -cp $GOPATH/bin/zetaclientd $DAEMON_HOME/zetavisor/genesis/bin +cp $GOPATH/bin/old/zetacored $DAEMON_HOME/cosmovisor/genesis/bin +cp $GOPATH/bin/zetaclientd $DAEMON_HOME/cosmovisor/genesis/bin #Upgrades -cp $GOPATH/bin/new/zetacored $DAEMON_HOME/zetavisor/upgrades/$UpgradeName/bin/ +cp $GOPATH/bin/new/zetacored $DAEMON_HOME/cosmovisor/upgrades/$UpgradeName/bin/ #Permissions -chmod +x $DAEMON_HOME/zetavisor/genesis/bin/zetacored -chmod +x $DAEMON_HOME/zetavisor/genesis/bin/zetaclientd -chmod +x $DAEMON_HOME/zetavisor/upgrades/$UpgradeName/bin/zetacored +chmod +x $DAEMON_HOME/cosmovisor/genesis/bin/zetacored +chmod +x $DAEMON_HOME/cosmovisor/genesis/bin/zetaclientd +chmod +x $DAEMON_HOME/cosmovisor/upgrades/$UpgradeName/bin/zetacored # 7 Start the nodes -zetavisor start --pruning=nothing --minimum-gas-prices=0.0001azeta --json-rpc.api eth,txpool,personal,net,debug,web3,miner --api.enable --home /root/.zetacored >> zetanode.log 2>&1 & +cosmovisor run start --pruning=nothing --minimum-gas-prices=0.0001azeta --json-rpc.api eth,txpool,personal,net,debug,web3,miner --api.enable --home /root/.zetacored >> zetanode.log 2>&1 & sleep 20 echo if [ $HOSTNAME = "zetacore0" ] then -/root/.zetacored/zetavisor/current/bin/zetacored tx gov submit-legacy-proposal software-upgrade $UpgradeName --from hotkey --deposit 100000000azeta --upgrade-height 400 --title $UpgradeName --description $UpgradeName --keyring-backend test --chain-id $CHAINID --yes --no-validate --fees=200azeta --broadcast-mode block +/root/.zetacored/cosmovisor/genesis/bin/zetacored tx gov submit-legacy-proposal software-upgrade $UpgradeName --from hotkey --deposit 100000000azeta --upgrade-height 180 --title $UpgradeName --description $UpgradeName --keyring-backend test --chain-id $CHAINID --yes --no-validate --fees=200azeta --broadcast-mode block fi sleep 8 -/root/.zetacored/zetavisor/current/bin/zetacored tx gov vote 1 yes --from operator --keyring-backend test --chain-id $CHAINID --yes --fees=200azeta --broadcast-mode block +/root/.zetacored/cosmovisor/genesis/bin/zetacored tx gov vote 1 yes --from operator --keyring-backend test --chain-id $CHAINID --yes --fees=200azeta --broadcast-mode block sleep 7 -/root/.zetacored/zetavisor/current/bin/zetacored query gov proposal 1 +/root/.zetacored/cosmovisor/genesis/bin/zetacored query gov proposal 1 tail -f zetanode.log \ No newline at end of file diff --git a/contrib/localnet/scripts/genesis-upgrade.sh b/contrib/localnet/scripts/genesis-upgrade.sh index 489d4f01b5..7e01983e66 100755 --- a/contrib/localnet/scripts/genesis-upgrade.sh +++ b/contrib/localnet/scripts/genesis-upgrade.sh @@ -88,6 +88,11 @@ then cat $HOME/.zetacored/config/genesis.json | jq '.consensus_params["block"]["max_gas"]="500000000"' > $HOME/.zetacored/config/tmp_genesis.json && mv $HOME/.zetacored/config/tmp_genesis.json $HOME/.zetacored/config/genesis.json cat $HOME/.zetacored/config/genesis.json | jq '.app_state["gov"]["voting_params"]["voting_period"]="100s"' > $HOME/.zetacored/config/tmp_genesis.json && mv $HOME/.zetacored/config/tmp_genesis.json $HOME/.zetacored/config/genesis.json + # set admin account + zetacored add-genesis-account zeta1srsq755t654agc0grpxj4y3w0znktrpr9tcdgk 100000000000000000000000000azeta + zetacored add-genesis-account zeta1n0rn6sne54hv7w2uu93fl48ncyqz97d3kty6sh 100000000000000000000000000azeta # Funds the localnet_gov_admin account + cat $HOME/.zetacored/config/genesis.json | jq '.app_state["observer"]["params"]["admin_policy"][0]["address"]="zeta1srsq755t654agc0grpxj4y3w0znktrpr9tcdgk"' > $HOME/.zetacored/config/tmp_genesis.json && mv $HOME/.zetacored/config/tmp_genesis.json $HOME/.zetacored/config/genesis.json + cat $HOME/.zetacored/config/genesis.json | jq '.app_state["observer"]["params"]["admin_policy"][1]["address"]="zeta1srsq755t654agc0grpxj4y3w0znktrpr9tcdgk"' > $HOME/.zetacored/config/tmp_genesis.json && mv $HOME/.zetacored/config/tmp_genesis.json $HOME/.zetacored/config/genesis.json # 3. Copy the genesis.json to all the nodes .And use it to create a gentx for every node zetacored gentx operator 1000000000000000000000azeta --chain-id=$CHAINID --keyring-backend=$KEYRING diff --git a/contrib/localnet/scripts/start-zetaclientd-background.sh b/contrib/localnet/scripts/start-zetaclientd-background.sh index 76726958cc..74ee897fdf 100644 --- a/contrib/localnet/scripts/start-zetaclientd-background.sh +++ b/contrib/localnet/scripts/start-zetaclientd-background.sh @@ -7,8 +7,6 @@ HOSTNAME=$(hostname) cp /root/preparams/PreParams_$HOSTNAME.json /root/preParams.json num=$(echo $HOSTNAME | tr -dc '0-9') node="zetacore$num" -#mv /root/zetacored/zetacored_$node /root/.zetacored -#mv /root/tss/$HOSTNAME /root/.tss echo "Wait for zetacore to exchange genesis file" sleep 30 @@ -20,13 +18,17 @@ if [ $HOSTNAME == "zetaclient0" ] then rm ~/.tss/* MYIP=$(/sbin/ip -o -4 addr list eth0 | awk '{print $4}' | cut -d/ -f1) - zetaclientd init --zetacore-url zetacore0 --chain-id athens_101-1 --operator "$operatorAddress" --log-format=text --public-ip "$MYIP" + zetaclientd init --zetacore-url zetacore0 --chain-id athens_101-1 --operator "$operatorAddress" --log-format=text --public-ip "$MYIP" zetaclientd start > $HOME/zetaclient.log 2>&1 & else num=$(echo $HOSTNAME | tr -dc '0-9') node="zetacore$num" MYIP=$(/sbin/ip -o -4 addr list eth0 | awk '{print $4}' | cut -d/ -f1) - SEED=$(curl --retry 10 --retry-delay 5 --retry-connrefused -s zetaclient0:8123/p2p) + SEED="" + while [ -z "$SEED" ] + do + SEED=$(curl --retry 10 --retry-delay 5 --retry-connrefused -s zetaclient0:8123/p2p) + done rm ~/.tss/* zetaclientd init --peer /ip4/172.20.0.21/tcp/6668/p2p/"$SEED" --zetacore-url "$node" --chain-id athens_101-1 --operator "$operatorAddress" --log-format=text --public-ip "$MYIP" --log-level 0 zetaclientd start > $HOME/zetaclient.log 2>&1 & diff --git a/contrib/localnet/scripts/start-zetaclientd-genesis.sh b/contrib/localnet/scripts/start-zetaclientd-genesis.sh index 1109acaf37..7c23cd0673 100755 --- a/contrib/localnet/scripts/start-zetaclientd-genesis.sh +++ b/contrib/localnet/scripts/start-zetaclientd-genesis.sh @@ -13,8 +13,6 @@ fi cp /root/preparams/PreParams_$HOSTNAME.json /root/preParams.json num=$(echo $HOSTNAME | tr -dc '0-9') node="zetacore$num" -#mv /root/zetacored/zetacored_$node /root/.zetacored -#mv /root/tss/$HOSTNAME /root/.tss echo "Wait for zetacore to exchange genesis file" sleep 40 @@ -26,7 +24,7 @@ if [ $HOSTNAME == "zetaclient0" ] then rm ~/.tss/* MYIP=$(/sbin/ip -o -4 addr list eth0 | awk '{print $4}' | cut -d/ -f1) - zetaclientd init --zetacore-url zetacore0 --chain-id athens_101-1 --operator "$operatorAddress" --log-format=text --public-ip "$MYIP" --keyring-backend "$BACKEND" + zetaclientd init --zetacore-url zetacore0 --chain-id athens_101-1 --operator "$operatorAddress" --log-format=text --public-ip "$MYIP" --keyring-backend "$BACKEND" zetaclientd start else num=$(echo $HOSTNAME | tr -dc '0-9') diff --git a/contrib/localnet/zetacored/common/app.toml b/contrib/localnet/zetacored/common/app.toml index 624e89d40c..7bbf48cf96 100644 --- a/contrib/localnet/zetacored/common/app.toml +++ b/contrib/localnet/zetacored/common/app.toml @@ -80,7 +80,7 @@ service-name = "" # Enabled enables the application telemetry functionality. When enabled, # an in-memory sink is also enabled by default. Operators may also enabled # other sinks such as Prometheus. -enabled = false +enabled = true # Enable prefixing gauge values with hostname. enable-hostname = false diff --git a/contrib/localnet/zetacored/common/config.toml b/contrib/localnet/zetacored/common/config.toml index 29b433e824..c0f955ea4b 100644 --- a/contrib/localnet/zetacored/common/config.toml +++ b/contrib/localnet/zetacored/common/config.toml @@ -451,7 +451,7 @@ psql-conn = "" # When true, Prometheus metrics are served under /metrics on # PrometheusListenAddr. # Check out the documentation for the list of available metrics. -prometheus = false +prometheus = true # Address to listen for Prometheus collector(s) connections prometheus_listen_addr = ":26660" diff --git a/docs/openapi/openapi.swagger.yaml b/docs/openapi/openapi.swagger.yaml index 6d8b1c4e18..cb87e0dfc4 100644 --- a/docs/openapi/openapi.swagger.yaml +++ b/docs/openapi/openapi.swagger.yaml @@ -26696,6 +26696,25 @@ paths: type: string tags: - Query + /zeta-chain/crosschain/get_tss_address: + get: + summary: |- + GetTssAddress queries the tss address of the module. + Deprecated: Moved to observer + TODO: remove after v12 once upgrade testing is no longer needed with v11 + https://github.com/zeta-chain/node/issues/1547 + operationId: Query_GetTssAddress + responses: + "200": + description: A successful response. + schema: + $ref: '#/definitions/zetacorecrosschainQueryGetTssAddressResponse' + default: + description: An unexpected error response. + schema: + $ref: '#/definitions/googlerpcStatus' + tags: + - Query /zeta-chain/crosschain/in_tx_hash_to_cctx_data/{inTxHash}: get: summary: Queries a InTxHashToCctx data by index. @@ -27806,7 +27825,7 @@ paths: "200": description: A successful response. schema: - $ref: '#/definitions/observerQueryGetTssAddressResponse' + $ref: '#/definitions/zetacoreobserverQueryGetTssAddressResponse' default: description: An unexpected error response. schema: @@ -51622,13 +51641,6 @@ definitions: type: string btc: type: string - observerQueryGetTssAddressResponse: - type: object - properties: - eth: - type: string - btc: - type: string observerQueryHasVotedResponse: type: object properties: @@ -51788,6 +51800,17 @@ definitions: enabled: type: boolean description: Params defines the parameters for the module. + zetacorecrosschainQueryGetTssAddressResponse: + type: object + properties: + eth: + type: string + btc: + type: string + title: |- + Deprecated: Moved to observer + TODO: remove after v12 once upgrade testing is no longer needed with v11 + https://github.com/zeta-chain/node/issues/1547 zetacorecrosschainQueryParamsResponse: type: object properties: @@ -51862,6 +51885,13 @@ definitions: type: string format: int64 description: Params defines the parameters for the module. + zetacoreobserverQueryGetTssAddressResponse: + type: object + properties: + eth: + type: string + btc: + type: string zetacoreobserverQueryParamsResponse: type: object properties: diff --git a/go.mod b/go.mod index a8dd44e772..b583a97b16 100644 --- a/go.mod +++ b/go.mod @@ -52,7 +52,7 @@ require ( require ( github.com/jinzhu/inflection v1.0.0 // indirect github.com/jinzhu/now v1.1.5 // indirect - github.com/mattn/go-sqlite3 v1.14.16 // indirect + github.com/mattn/go-sqlite3 v1.14.19 // indirect gorm.io/driver/sqlite v1.4.4 gorm.io/gorm v1.24.6 ) diff --git a/go.sum b/go.sum index 238beaf820..da78e7283c 100644 --- a/go.sum +++ b/go.sum @@ -2154,8 +2154,8 @@ github.com/mattn/go-sqlite3 v1.9.0/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOq github.com/mattn/go-sqlite3 v1.11.0/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc= github.com/mattn/go-sqlite3 v1.14.9/go.mod h1:NyWgC/yNuGj7Q9rpYnZvas74GogHl5/Z4A/KQRfk6bU= github.com/mattn/go-sqlite3 v1.14.15/go.mod h1:2eHXhiwb8IkHr+BDWZGa96P6+rkvnG63S2DGjv9HUNg= -github.com/mattn/go-sqlite3 v1.14.16 h1:yOQRA0RpS5PFz/oikGwBEqvAWhWg5ufRz4ETLjwpU1Y= -github.com/mattn/go-sqlite3 v1.14.16/go.mod h1:2eHXhiwb8IkHr+BDWZGa96P6+rkvnG63S2DGjv9HUNg= +github.com/mattn/go-sqlite3 v1.14.19 h1:fhGleo2h1p8tVChob4I9HpmVFIAkKGpiukdrgQbWfGI= +github.com/mattn/go-sqlite3 v1.14.19/go.mod h1:2eHXhiwb8IkHr+BDWZGa96P6+rkvnG63S2DGjv9HUNg= github.com/mattn/go-tty v0.0.0-20180907095812-13ff1204f104/go.mod h1:XPvLUNfbS4fJH25nqRHfWLMa1ONC8Amw+mIA639KxkE= github.com/mattn/go-zglob v0.0.1/go.mod h1:9fxibJccNxU2cnpIKLRRFA7zX7qhkJIQWBb449FYHOo= github.com/mattn/goveralls v0.0.2/go.mod h1:8d1ZMHsd7fW6IRPKQh46F2WRpyib5/X4FOpevwGNQEw= diff --git a/proto/crosschain/query.proto b/proto/crosschain/query.proto index c9eee26378..0df9d8a0b7 100644 --- a/proto/crosschain/query.proto +++ b/proto/crosschain/query.proto @@ -16,6 +16,14 @@ option go_package = "github.com/zeta-chain/zetacore/x/crosschain/types"; // Query defines the gRPC querier service. service Query { + // GetTssAddress queries the tss address of the module. + // Deprecated: Moved to observer + // TODO: remove after v12 once upgrade testing is no longer needed with v11 + // https://github.com/zeta-chain/node/issues/1547 + rpc GetTssAddress(QueryGetTssAddressRequest) returns (QueryGetTssAddressResponse) { + option (google.api.http).get = "/zeta-chain/crosschain/get_tss_address"; + } + // Parameters queries the parameters of the module. rpc Params(QueryParamsRequest) returns (QueryParamsResponse) { option (google.api.http).get = "/zeta-chain/crosschain/params"; @@ -114,6 +122,19 @@ service Query { } } +// Deprecated: Moved to observer +// TODO: remove after v12 once upgrade testing is no longer needed with v11 +// https://github.com/zeta-chain/node/issues/1547 +message QueryGetTssAddressRequest {} + +// Deprecated: Moved to observer +// TODO: remove after v12 once upgrade testing is no longer needed with v11 +// https://github.com/zeta-chain/node/issues/1547 +message QueryGetTssAddressResponse { + string eth = 1; + string btc = 2; +} + message QueryZetaAccountingRequest {} message QueryZetaAccountingResponse { diff --git a/scripts/protoc-gen-typescript.sh b/scripts/protoc-gen-typescript.sh index 526d4773da..e56c951de1 100755 --- a/scripts/protoc-gen-typescript.sh +++ b/scripts/protoc-gen-typescript.sh @@ -8,7 +8,7 @@ rm -rf $DIR cat < $DIR/package.json { - "name": "@zetachain/blockchain-types", + "name": "@zetachain/node-types", "version": "0.0.0-set-on-publish", "description": "", "main": "", diff --git a/typescript/crosschain/query_pb.d.ts b/typescript/crosschain/query_pb.d.ts index 17bb54ef27..52d504e4e4 100644 --- a/typescript/crosschain/query_pb.d.ts +++ b/typescript/crosschain/query_pb.d.ts @@ -14,6 +14,62 @@ import type { CrossChainTx } from "./cross_chain_tx_pb.js"; import type { GasPrice } from "./gas_price_pb.js"; import type { LastBlockHeight } from "./last_block_height_pb.js"; +/** + * Deprecated: Moved to observer + * TODO: remove after v12 once upgrade testing is no longer needed with v11 + * https://github.com/zeta-chain/node/issues/1547 + * + * @generated from message zetachain.zetacore.crosschain.QueryGetTssAddressRequest + */ +export declare class QueryGetTssAddressRequest extends Message { + constructor(data?: PartialMessage); + + static readonly runtime: typeof proto3; + static readonly typeName = "zetachain.zetacore.crosschain.QueryGetTssAddressRequest"; + static readonly fields: FieldList; + + static fromBinary(bytes: Uint8Array, options?: Partial): QueryGetTssAddressRequest; + + static fromJson(jsonValue: JsonValue, options?: Partial): QueryGetTssAddressRequest; + + static fromJsonString(jsonString: string, options?: Partial): QueryGetTssAddressRequest; + + static equals(a: QueryGetTssAddressRequest | PlainMessage | undefined, b: QueryGetTssAddressRequest | PlainMessage | undefined): boolean; +} + +/** + * Deprecated: Moved to observer + * TODO: remove after v12 once upgrade testing is no longer needed with v11 + * https://github.com/zeta-chain/node/issues/1547 + * + * @generated from message zetachain.zetacore.crosschain.QueryGetTssAddressResponse + */ +export declare class QueryGetTssAddressResponse extends Message { + /** + * @generated from field: string eth = 1; + */ + eth: string; + + /** + * @generated from field: string btc = 2; + */ + btc: string; + + constructor(data?: PartialMessage); + + static readonly runtime: typeof proto3; + static readonly typeName = "zetachain.zetacore.crosschain.QueryGetTssAddressResponse"; + static readonly fields: FieldList; + + static fromBinary(bytes: Uint8Array, options?: Partial): QueryGetTssAddressResponse; + + static fromJson(jsonValue: JsonValue, options?: Partial): QueryGetTssAddressResponse; + + static fromJsonString(jsonString: string, options?: Partial): QueryGetTssAddressResponse; + + static equals(a: QueryGetTssAddressResponse | PlainMessage | undefined, b: QueryGetTssAddressResponse | PlainMessage | undefined): boolean; +} + /** * @generated from message zetachain.zetacore.crosschain.QueryZetaAccountingRequest */ diff --git a/typescript/package.json b/typescript/package.json index 369d5cbb82..31e60016e1 100644 --- a/typescript/package.json +++ b/typescript/package.json @@ -1,5 +1,5 @@ { - "name": "@zetachain/blockchain-types", + "name": "@zetachain/node-types", "version": "0.0.0-set-on-publish", "description": "", "main": "", diff --git a/x/crosschain/keeper/grpc_query.go b/x/crosschain/keeper/grpc_query.go index 720f65c8f7..3b2d06620e 100644 --- a/x/crosschain/keeper/grpc_query.go +++ b/x/crosschain/keeper/grpc_query.go @@ -1,7 +1,19 @@ package keeper import ( + "context" + "github.com/zeta-chain/zetacore/x/crosschain/types" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" ) var _ types.QueryServer = Keeper{} + +// GetTssAddress returns the tss address +// Deprecated: GetTssAddress returns the tss address +// TODO: remove after v12 once upgrade testing is no longer needed with v11 +// https://github.com/zeta-chain/node/issues/1547 +func (k Keeper) GetTssAddress(_ context.Context, _ *types.QueryGetTssAddressRequest) (*types.QueryGetTssAddressResponse, error) { + return nil, status.Error(codes.Unimplemented, "Deprecated") +} diff --git a/x/crosschain/types/query.pb.go b/x/crosschain/types/query.pb.go index 7273180766..e2dc8505bf 100644 --- a/x/crosschain/types/query.pb.go +++ b/x/crosschain/types/query.pb.go @@ -31,6 +31,100 @@ var _ = math.Inf // proto package needs to be updated. const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package +// Deprecated: Moved to observer +// TODO: remove after v12 once upgrade testing is no longer needed with v11 +// https://github.com/zeta-chain/node/issues/1547 +type QueryGetTssAddressRequest struct { +} + +func (m *QueryGetTssAddressRequest) Reset() { *m = QueryGetTssAddressRequest{} } +func (m *QueryGetTssAddressRequest) String() string { return proto.CompactTextString(m) } +func (*QueryGetTssAddressRequest) ProtoMessage() {} +func (*QueryGetTssAddressRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_65a992045e92a606, []int{0} +} +func (m *QueryGetTssAddressRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryGetTssAddressRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryGetTssAddressRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *QueryGetTssAddressRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryGetTssAddressRequest.Merge(m, src) +} +func (m *QueryGetTssAddressRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryGetTssAddressRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryGetTssAddressRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryGetTssAddressRequest proto.InternalMessageInfo + +// Deprecated: Moved to observer +// TODO: remove after v12 once upgrade testing is no longer needed with v11 +// https://github.com/zeta-chain/node/issues/1547 +type QueryGetTssAddressResponse struct { + Eth string `protobuf:"bytes,1,opt,name=eth,proto3" json:"eth,omitempty"` + Btc string `protobuf:"bytes,2,opt,name=btc,proto3" json:"btc,omitempty"` +} + +func (m *QueryGetTssAddressResponse) Reset() { *m = QueryGetTssAddressResponse{} } +func (m *QueryGetTssAddressResponse) String() string { return proto.CompactTextString(m) } +func (*QueryGetTssAddressResponse) ProtoMessage() {} +func (*QueryGetTssAddressResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_65a992045e92a606, []int{1} +} +func (m *QueryGetTssAddressResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryGetTssAddressResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryGetTssAddressResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *QueryGetTssAddressResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryGetTssAddressResponse.Merge(m, src) +} +func (m *QueryGetTssAddressResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryGetTssAddressResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryGetTssAddressResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryGetTssAddressResponse proto.InternalMessageInfo + +func (m *QueryGetTssAddressResponse) GetEth() string { + if m != nil { + return m.Eth + } + return "" +} + +func (m *QueryGetTssAddressResponse) GetBtc() string { + if m != nil { + return m.Btc + } + return "" +} + type QueryZetaAccountingRequest struct { } @@ -38,7 +132,7 @@ func (m *QueryZetaAccountingRequest) Reset() { *m = QueryZetaAccountingR func (m *QueryZetaAccountingRequest) String() string { return proto.CompactTextString(m) } func (*QueryZetaAccountingRequest) ProtoMessage() {} func (*QueryZetaAccountingRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{0} + return fileDescriptor_65a992045e92a606, []int{2} } func (m *QueryZetaAccountingRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -75,7 +169,7 @@ func (m *QueryZetaAccountingResponse) Reset() { *m = QueryZetaAccounting func (m *QueryZetaAccountingResponse) String() string { return proto.CompactTextString(m) } func (*QueryZetaAccountingResponse) ProtoMessage() {} func (*QueryZetaAccountingResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{1} + return fileDescriptor_65a992045e92a606, []int{3} } func (m *QueryZetaAccountingResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -119,7 +213,7 @@ func (m *QueryParamsRequest) Reset() { *m = QueryParamsRequest{} } func (m *QueryParamsRequest) String() string { return proto.CompactTextString(m) } func (*QueryParamsRequest) ProtoMessage() {} func (*QueryParamsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{2} + return fileDescriptor_65a992045e92a606, []int{4} } func (m *QueryParamsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -158,7 +252,7 @@ func (m *QueryParamsResponse) Reset() { *m = QueryParamsResponse{} } func (m *QueryParamsResponse) String() string { return proto.CompactTextString(m) } func (*QueryParamsResponse) ProtoMessage() {} func (*QueryParamsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{3} + return fileDescriptor_65a992045e92a606, []int{5} } func (m *QueryParamsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -203,7 +297,7 @@ func (m *QueryGetOutTxTrackerRequest) Reset() { *m = QueryGetOutTxTracke func (m *QueryGetOutTxTrackerRequest) String() string { return proto.CompactTextString(m) } func (*QueryGetOutTxTrackerRequest) ProtoMessage() {} func (*QueryGetOutTxTrackerRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{4} + return fileDescriptor_65a992045e92a606, []int{6} } func (m *QueryGetOutTxTrackerRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -254,7 +348,7 @@ func (m *QueryGetOutTxTrackerResponse) Reset() { *m = QueryGetOutTxTrack func (m *QueryGetOutTxTrackerResponse) String() string { return proto.CompactTextString(m) } func (*QueryGetOutTxTrackerResponse) ProtoMessage() {} func (*QueryGetOutTxTrackerResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{5} + return fileDescriptor_65a992045e92a606, []int{7} } func (m *QueryGetOutTxTrackerResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -298,7 +392,7 @@ func (m *QueryAllOutTxTrackerRequest) Reset() { *m = QueryAllOutTxTracke func (m *QueryAllOutTxTrackerRequest) String() string { return proto.CompactTextString(m) } func (*QueryAllOutTxTrackerRequest) ProtoMessage() {} func (*QueryAllOutTxTrackerRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{6} + return fileDescriptor_65a992045e92a606, []int{8} } func (m *QueryAllOutTxTrackerRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -343,7 +437,7 @@ func (m *QueryAllOutTxTrackerResponse) Reset() { *m = QueryAllOutTxTrack func (m *QueryAllOutTxTrackerResponse) String() string { return proto.CompactTextString(m) } func (*QueryAllOutTxTrackerResponse) ProtoMessage() {} func (*QueryAllOutTxTrackerResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{7} + return fileDescriptor_65a992045e92a606, []int{9} } func (m *QueryAllOutTxTrackerResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -395,7 +489,7 @@ func (m *QueryAllOutTxTrackerByChainRequest) Reset() { *m = QueryAllOutT func (m *QueryAllOutTxTrackerByChainRequest) String() string { return proto.CompactTextString(m) } func (*QueryAllOutTxTrackerByChainRequest) ProtoMessage() {} func (*QueryAllOutTxTrackerByChainRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{8} + return fileDescriptor_65a992045e92a606, []int{10} } func (m *QueryAllOutTxTrackerByChainRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -447,7 +541,7 @@ func (m *QueryAllOutTxTrackerByChainResponse) Reset() { *m = QueryAllOut func (m *QueryAllOutTxTrackerByChainResponse) String() string { return proto.CompactTextString(m) } func (*QueryAllOutTxTrackerByChainResponse) ProtoMessage() {} func (*QueryAllOutTxTrackerByChainResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{9} + return fileDescriptor_65a992045e92a606, []int{11} } func (m *QueryAllOutTxTrackerByChainResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -499,7 +593,7 @@ func (m *QueryAllInTxTrackerByChainRequest) Reset() { *m = QueryAllInTxT func (m *QueryAllInTxTrackerByChainRequest) String() string { return proto.CompactTextString(m) } func (*QueryAllInTxTrackerByChainRequest) ProtoMessage() {} func (*QueryAllInTxTrackerByChainRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{10} + return fileDescriptor_65a992045e92a606, []int{12} } func (m *QueryAllInTxTrackerByChainRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -551,7 +645,7 @@ func (m *QueryAllInTxTrackerByChainResponse) Reset() { *m = QueryAllInTx func (m *QueryAllInTxTrackerByChainResponse) String() string { return proto.CompactTextString(m) } func (*QueryAllInTxTrackerByChainResponse) ProtoMessage() {} func (*QueryAllInTxTrackerByChainResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{11} + return fileDescriptor_65a992045e92a606, []int{13} } func (m *QueryAllInTxTrackerByChainResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -602,7 +696,7 @@ func (m *QueryAllInTxTrackersRequest) Reset() { *m = QueryAllInTxTracker func (m *QueryAllInTxTrackersRequest) String() string { return proto.CompactTextString(m) } func (*QueryAllInTxTrackersRequest) ProtoMessage() {} func (*QueryAllInTxTrackersRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{12} + return fileDescriptor_65a992045e92a606, []int{14} } func (m *QueryAllInTxTrackersRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -647,7 +741,7 @@ func (m *QueryAllInTxTrackersResponse) Reset() { *m = QueryAllInTxTracke func (m *QueryAllInTxTrackersResponse) String() string { return proto.CompactTextString(m) } func (*QueryAllInTxTrackersResponse) ProtoMessage() {} func (*QueryAllInTxTrackersResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{13} + return fileDescriptor_65a992045e92a606, []int{15} } func (m *QueryAllInTxTrackersResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -698,7 +792,7 @@ func (m *QueryGetInTxHashToCctxRequest) Reset() { *m = QueryGetInTxHashT func (m *QueryGetInTxHashToCctxRequest) String() string { return proto.CompactTextString(m) } func (*QueryGetInTxHashToCctxRequest) ProtoMessage() {} func (*QueryGetInTxHashToCctxRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{14} + return fileDescriptor_65a992045e92a606, []int{16} } func (m *QueryGetInTxHashToCctxRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -742,7 +836,7 @@ func (m *QueryGetInTxHashToCctxResponse) Reset() { *m = QueryGetInTxHash func (m *QueryGetInTxHashToCctxResponse) String() string { return proto.CompactTextString(m) } func (*QueryGetInTxHashToCctxResponse) ProtoMessage() {} func (*QueryGetInTxHashToCctxResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{15} + return fileDescriptor_65a992045e92a606, []int{17} } func (m *QueryGetInTxHashToCctxResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -786,7 +880,7 @@ func (m *QueryInTxHashToCctxDataRequest) Reset() { *m = QueryInTxHashToC func (m *QueryInTxHashToCctxDataRequest) String() string { return proto.CompactTextString(m) } func (*QueryInTxHashToCctxDataRequest) ProtoMessage() {} func (*QueryInTxHashToCctxDataRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{16} + return fileDescriptor_65a992045e92a606, []int{18} } func (m *QueryInTxHashToCctxDataRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -830,7 +924,7 @@ func (m *QueryInTxHashToCctxDataResponse) Reset() { *m = QueryInTxHashTo func (m *QueryInTxHashToCctxDataResponse) String() string { return proto.CompactTextString(m) } func (*QueryInTxHashToCctxDataResponse) ProtoMessage() {} func (*QueryInTxHashToCctxDataResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{17} + return fileDescriptor_65a992045e92a606, []int{19} } func (m *QueryInTxHashToCctxDataResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -874,7 +968,7 @@ func (m *QueryAllInTxHashToCctxRequest) Reset() { *m = QueryAllInTxHashT func (m *QueryAllInTxHashToCctxRequest) String() string { return proto.CompactTextString(m) } func (*QueryAllInTxHashToCctxRequest) ProtoMessage() {} func (*QueryAllInTxHashToCctxRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{18} + return fileDescriptor_65a992045e92a606, []int{20} } func (m *QueryAllInTxHashToCctxRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -919,7 +1013,7 @@ func (m *QueryAllInTxHashToCctxResponse) Reset() { *m = QueryAllInTxHash func (m *QueryAllInTxHashToCctxResponse) String() string { return proto.CompactTextString(m) } func (*QueryAllInTxHashToCctxResponse) ProtoMessage() {} func (*QueryAllInTxHashToCctxResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{19} + return fileDescriptor_65a992045e92a606, []int{21} } func (m *QueryAllInTxHashToCctxResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -970,7 +1064,7 @@ func (m *QueryGetGasPriceRequest) Reset() { *m = QueryGetGasPriceRequest func (m *QueryGetGasPriceRequest) String() string { return proto.CompactTextString(m) } func (*QueryGetGasPriceRequest) ProtoMessage() {} func (*QueryGetGasPriceRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{20} + return fileDescriptor_65a992045e92a606, []int{22} } func (m *QueryGetGasPriceRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1014,7 +1108,7 @@ func (m *QueryGetGasPriceResponse) Reset() { *m = QueryGetGasPriceRespon func (m *QueryGetGasPriceResponse) String() string { return proto.CompactTextString(m) } func (*QueryGetGasPriceResponse) ProtoMessage() {} func (*QueryGetGasPriceResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{21} + return fileDescriptor_65a992045e92a606, []int{23} } func (m *QueryGetGasPriceResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1058,7 +1152,7 @@ func (m *QueryAllGasPriceRequest) Reset() { *m = QueryAllGasPriceRequest func (m *QueryAllGasPriceRequest) String() string { return proto.CompactTextString(m) } func (*QueryAllGasPriceRequest) ProtoMessage() {} func (*QueryAllGasPriceRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{22} + return fileDescriptor_65a992045e92a606, []int{24} } func (m *QueryAllGasPriceRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1103,7 +1197,7 @@ func (m *QueryAllGasPriceResponse) Reset() { *m = QueryAllGasPriceRespon func (m *QueryAllGasPriceResponse) String() string { return proto.CompactTextString(m) } func (*QueryAllGasPriceResponse) ProtoMessage() {} func (*QueryAllGasPriceResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{23} + return fileDescriptor_65a992045e92a606, []int{25} } func (m *QueryAllGasPriceResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1154,7 +1248,7 @@ func (m *QueryGetLastBlockHeightRequest) Reset() { *m = QueryGetLastBloc func (m *QueryGetLastBlockHeightRequest) String() string { return proto.CompactTextString(m) } func (*QueryGetLastBlockHeightRequest) ProtoMessage() {} func (*QueryGetLastBlockHeightRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{24} + return fileDescriptor_65a992045e92a606, []int{26} } func (m *QueryGetLastBlockHeightRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1198,7 +1292,7 @@ func (m *QueryGetLastBlockHeightResponse) Reset() { *m = QueryGetLastBlo func (m *QueryGetLastBlockHeightResponse) String() string { return proto.CompactTextString(m) } func (*QueryGetLastBlockHeightResponse) ProtoMessage() {} func (*QueryGetLastBlockHeightResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{25} + return fileDescriptor_65a992045e92a606, []int{27} } func (m *QueryGetLastBlockHeightResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1242,7 +1336,7 @@ func (m *QueryAllLastBlockHeightRequest) Reset() { *m = QueryAllLastBloc func (m *QueryAllLastBlockHeightRequest) String() string { return proto.CompactTextString(m) } func (*QueryAllLastBlockHeightRequest) ProtoMessage() {} func (*QueryAllLastBlockHeightRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{26} + return fileDescriptor_65a992045e92a606, []int{28} } func (m *QueryAllLastBlockHeightRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1287,7 +1381,7 @@ func (m *QueryAllLastBlockHeightResponse) Reset() { *m = QueryAllLastBlo func (m *QueryAllLastBlockHeightResponse) String() string { return proto.CompactTextString(m) } func (*QueryAllLastBlockHeightResponse) ProtoMessage() {} func (*QueryAllLastBlockHeightResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{27} + return fileDescriptor_65a992045e92a606, []int{29} } func (m *QueryAllLastBlockHeightResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1338,7 +1432,7 @@ func (m *QueryGetCctxRequest) Reset() { *m = QueryGetCctxRequest{} } func (m *QueryGetCctxRequest) String() string { return proto.CompactTextString(m) } func (*QueryGetCctxRequest) ProtoMessage() {} func (*QueryGetCctxRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{28} + return fileDescriptor_65a992045e92a606, []int{30} } func (m *QueryGetCctxRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1383,7 +1477,7 @@ func (m *QueryGetCctxByNonceRequest) Reset() { *m = QueryGetCctxByNonceR func (m *QueryGetCctxByNonceRequest) String() string { return proto.CompactTextString(m) } func (*QueryGetCctxByNonceRequest) ProtoMessage() {} func (*QueryGetCctxByNonceRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{29} + return fileDescriptor_65a992045e92a606, []int{31} } func (m *QueryGetCctxByNonceRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1434,7 +1528,7 @@ func (m *QueryGetCctxResponse) Reset() { *m = QueryGetCctxResponse{} } func (m *QueryGetCctxResponse) String() string { return proto.CompactTextString(m) } func (*QueryGetCctxResponse) ProtoMessage() {} func (*QueryGetCctxResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{30} + return fileDescriptor_65a992045e92a606, []int{32} } func (m *QueryGetCctxResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1478,7 +1572,7 @@ func (m *QueryAllCctxRequest) Reset() { *m = QueryAllCctxRequest{} } func (m *QueryAllCctxRequest) String() string { return proto.CompactTextString(m) } func (*QueryAllCctxRequest) ProtoMessage() {} func (*QueryAllCctxRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{31} + return fileDescriptor_65a992045e92a606, []int{33} } func (m *QueryAllCctxRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1523,7 +1617,7 @@ func (m *QueryAllCctxResponse) Reset() { *m = QueryAllCctxResponse{} } func (m *QueryAllCctxResponse) String() string { return proto.CompactTextString(m) } func (*QueryAllCctxResponse) ProtoMessage() {} func (*QueryAllCctxResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{32} + return fileDescriptor_65a992045e92a606, []int{34} } func (m *QueryAllCctxResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1575,7 +1669,7 @@ func (m *QueryListCctxPendingRequest) Reset() { *m = QueryListCctxPendin func (m *QueryListCctxPendingRequest) String() string { return proto.CompactTextString(m) } func (*QueryListCctxPendingRequest) ProtoMessage() {} func (*QueryListCctxPendingRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{33} + return fileDescriptor_65a992045e92a606, []int{35} } func (m *QueryListCctxPendingRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1627,7 +1721,7 @@ func (m *QueryListCctxPendingResponse) Reset() { *m = QueryListCctxPendi func (m *QueryListCctxPendingResponse) String() string { return proto.CompactTextString(m) } func (*QueryListCctxPendingResponse) ProtoMessage() {} func (*QueryListCctxPendingResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{34} + return fileDescriptor_65a992045e92a606, []int{36} } func (m *QueryListCctxPendingResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1677,7 +1771,7 @@ func (m *QueryLastZetaHeightRequest) Reset() { *m = QueryLastZetaHeightR func (m *QueryLastZetaHeightRequest) String() string { return proto.CompactTextString(m) } func (*QueryLastZetaHeightRequest) ProtoMessage() {} func (*QueryLastZetaHeightRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{35} + return fileDescriptor_65a992045e92a606, []int{37} } func (m *QueryLastZetaHeightRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1714,7 +1808,7 @@ func (m *QueryLastZetaHeightResponse) Reset() { *m = QueryLastZetaHeight func (m *QueryLastZetaHeightResponse) String() string { return proto.CompactTextString(m) } func (*QueryLastZetaHeightResponse) ProtoMessage() {} func (*QueryLastZetaHeightResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{36} + return fileDescriptor_65a992045e92a606, []int{38} } func (m *QueryLastZetaHeightResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1759,7 +1853,7 @@ func (m *QueryConvertGasToZetaRequest) Reset() { *m = QueryConvertGasToZ func (m *QueryConvertGasToZetaRequest) String() string { return proto.CompactTextString(m) } func (*QueryConvertGasToZetaRequest) ProtoMessage() {} func (*QueryConvertGasToZetaRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{37} + return fileDescriptor_65a992045e92a606, []int{39} } func (m *QueryConvertGasToZetaRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1812,7 +1906,7 @@ func (m *QueryConvertGasToZetaResponse) Reset() { *m = QueryConvertGasTo func (m *QueryConvertGasToZetaResponse) String() string { return proto.CompactTextString(m) } func (*QueryConvertGasToZetaResponse) ProtoMessage() {} func (*QueryConvertGasToZetaResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{38} + return fileDescriptor_65a992045e92a606, []int{40} } func (m *QueryConvertGasToZetaResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1869,7 +1963,7 @@ func (m *QueryMessagePassingProtocolFeeRequest) Reset() { *m = QueryMess func (m *QueryMessagePassingProtocolFeeRequest) String() string { return proto.CompactTextString(m) } func (*QueryMessagePassingProtocolFeeRequest) ProtoMessage() {} func (*QueryMessagePassingProtocolFeeRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{39} + return fileDescriptor_65a992045e92a606, []int{41} } func (m *QueryMessagePassingProtocolFeeRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1908,7 +2002,7 @@ func (m *QueryMessagePassingProtocolFeeResponse) Reset() { func (m *QueryMessagePassingProtocolFeeResponse) String() string { return proto.CompactTextString(m) } func (*QueryMessagePassingProtocolFeeResponse) ProtoMessage() {} func (*QueryMessagePassingProtocolFeeResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_65a992045e92a606, []int{40} + return fileDescriptor_65a992045e92a606, []int{42} } func (m *QueryMessagePassingProtocolFeeResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1945,6 +2039,8 @@ func (m *QueryMessagePassingProtocolFeeResponse) GetFeeInZeta() string { } func init() { + proto.RegisterType((*QueryGetTssAddressRequest)(nil), "zetachain.zetacore.crosschain.QueryGetTssAddressRequest") + proto.RegisterType((*QueryGetTssAddressResponse)(nil), "zetachain.zetacore.crosschain.QueryGetTssAddressResponse") proto.RegisterType((*QueryZetaAccountingRequest)(nil), "zetachain.zetacore.crosschain.QueryZetaAccountingRequest") proto.RegisterType((*QueryZetaAccountingResponse)(nil), "zetachain.zetacore.crosschain.QueryZetaAccountingResponse") proto.RegisterType((*QueryParamsRequest)(nil), "zetachain.zetacore.crosschain.QueryParamsRequest") @@ -1991,119 +2087,124 @@ func init() { func init() { proto.RegisterFile("crosschain/query.proto", fileDescriptor_65a992045e92a606) } var fileDescriptor_65a992045e92a606 = []byte{ - // 1782 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x59, 0xdf, 0x6f, 0x14, 0x55, - 0x14, 0xee, 0xed, 0xd2, 0x52, 0x6e, 0x0b, 0x95, 0x4b, 0x85, 0x3a, 0xb4, 0x5b, 0x98, 0x5a, 0x5a, - 0xc1, 0xee, 0xd0, 0x02, 0x45, 0xa0, 0x18, 0xb7, 0x45, 0x0a, 0xb1, 0x40, 0xdd, 0xd4, 0x68, 0x30, - 0x66, 0x73, 0x3b, 0x3b, 0xce, 0x4e, 0x98, 0xce, 0x94, 0x9d, 0x59, 0xd2, 0xd2, 0xf4, 0x85, 0x07, - 0x5f, 0x7c, 0x31, 0x21, 0xd1, 0x17, 0x5f, 0x8d, 0x3e, 0xf8, 0xe0, 0x83, 0xd1, 0x07, 0x13, 0x8c, - 0x51, 0x91, 0x47, 0x12, 0x13, 0x63, 0x34, 0x31, 0x06, 0xfc, 0x43, 0xcc, 0xdc, 0x39, 0xb3, 0x7b, - 0xe7, 0xd7, 0xee, 0xed, 0x76, 0x79, 0xe0, 0xa9, 0x3b, 0x73, 0xef, 0x39, 0xe7, 0xfb, 0xbe, 0xfb, - 0x63, 0xce, 0x39, 0xc5, 0x07, 0xd5, 0x8a, 0xed, 0x38, 0x6a, 0x99, 0x1a, 0x96, 0x72, 0xbb, 0xaa, - 0x55, 0x36, 0x72, 0x6b, 0x15, 0xdb, 0xb5, 0xc9, 0xf0, 0x5d, 0xcd, 0xa5, 0xec, 0x75, 0x8e, 0xfd, - 0xb2, 0x2b, 0x5a, 0xae, 0x3e, 0x55, 0x3a, 0xae, 0xda, 0xce, 0xaa, 0xed, 0x28, 0x2b, 0xd4, 0xd1, - 0x7c, 0x3b, 0xe5, 0xce, 0xd4, 0x8a, 0xe6, 0xd2, 0x29, 0x65, 0x8d, 0xea, 0x86, 0x45, 0x5d, 0xc3, - 0xb6, 0x7c, 0x57, 0xd2, 0x08, 0x17, 0x82, 0xfd, 0x2c, 0xb2, 0xdf, 0x45, 0x77, 0x1d, 0x26, 0x48, - 0xdc, 0x04, 0x9d, 0x3a, 0xc5, 0xb5, 0x8a, 0xa1, 0x6a, 0x30, 0x36, 0xca, 0x8d, 0x31, 0x9b, 0x62, - 0x99, 0x3a, 0xe5, 0xa2, 0x6b, 0x17, 0x55, 0xb5, 0xe6, 0x20, 0x1b, 0x9b, 0xe4, 0x56, 0xa8, 0x7a, - 0x4b, 0xab, 0xc0, 0xb8, 0xcc, 0x8d, 0x9b, 0xd4, 0x71, 0x8b, 0x2b, 0xa6, 0xad, 0xde, 0x2a, 0x96, - 0x35, 0x43, 0x2f, 0xbb, 0x09, 0x28, 0xed, 0xaa, 0x1b, 0x77, 0x72, 0x88, 0x9b, 0xb0, 0x46, 0x2b, - 0x74, 0xd5, 0x81, 0x81, 0x01, 0xdd, 0xd6, 0x6d, 0xf6, 0x53, 0xf1, 0x7e, 0xc1, 0xdb, 0x21, 0xdd, - 0xb6, 0x75, 0x53, 0x53, 0xe8, 0x9a, 0xa1, 0x50, 0xcb, 0xb2, 0x5d, 0x26, 0x09, 0xd8, 0xc8, 0x43, - 0x58, 0x7a, 0xdb, 0x53, 0xed, 0xa6, 0xe6, 0xd2, 0xbc, 0xaa, 0xda, 0x55, 0xcb, 0x35, 0x2c, 0xbd, - 0xa0, 0xdd, 0xae, 0x6a, 0x8e, 0x2b, 0x5f, 0xc3, 0x87, 0x13, 0x47, 0x9d, 0x35, 0xdb, 0x72, 0x34, - 0x92, 0xc3, 0x07, 0xe8, 0x8a, 0x5d, 0x71, 0xb5, 0x52, 0xd1, 0x5b, 0x9b, 0x22, 0x5d, 0xf5, 0x66, - 0x0c, 0xa2, 0x23, 0x68, 0x62, 0x4f, 0x61, 0x3f, 0x0c, 0x31, 0x5b, 0x36, 0x20, 0x0f, 0x60, 0xc2, - 0xdc, 0x2d, 0x31, 0xd4, 0x41, 0x90, 0x9b, 0xf8, 0x40, 0xe8, 0x2d, 0x38, 0x9f, 0xc7, 0xdd, 0x3e, - 0x3b, 0xe6, 0xaf, 0x77, 0x7a, 0x2c, 0xd7, 0x70, 0x27, 0xe4, 0x7c, 0xf3, 0xb9, 0x5d, 0x8f, 0xfe, - 0x19, 0xe9, 0x28, 0x80, 0x69, 0x8d, 0xc0, 0x82, 0xe6, 0xde, 0xa8, 0xba, 0xcb, 0xeb, 0xcb, 0xbe, - 0x92, 0x10, 0x9a, 0x0c, 0xe2, 0xdd, 0xcc, 0xf8, 0xea, 0x25, 0x16, 0x24, 0x53, 0x08, 0x1e, 0xc9, - 0x00, 0xee, 0xb2, 0x6c, 0x4b, 0xd5, 0x06, 0x3b, 0x8f, 0xa0, 0x89, 0x5d, 0x05, 0xff, 0x41, 0xae, - 0xe2, 0xa1, 0x64, 0x77, 0x80, 0xf9, 0x1d, 0xdc, 0x67, 0x73, 0xef, 0x01, 0xf9, 0x89, 0x26, 0xc8, - 0x79, 0x57, 0x80, 0x3f, 0xe4, 0x46, 0xd6, 0x80, 0x45, 0xde, 0x34, 0x93, 0x58, 0x5c, 0xc6, 0xb8, - 0xbe, 0xd7, 0x21, 0xe6, 0xb1, 0x9c, 0x7f, 0x30, 0x72, 0xde, 0xc1, 0xc8, 0xf9, 0x07, 0x0a, 0x0e, - 0x46, 0x6e, 0x89, 0xea, 0x1a, 0xd8, 0x16, 0x38, 0x4b, 0xf9, 0x01, 0x02, 0x7a, 0xb1, 0x38, 0xa9, - 0xf4, 0x32, 0x6d, 0xa0, 0x47, 0x16, 0x42, 0xf8, 0x3b, 0x19, 0xfe, 0xf1, 0xa6, 0xf8, 0x7d, 0x4c, - 0x21, 0x02, 0xf7, 0x10, 0x96, 0x93, 0x08, 0xcc, 0x6d, 0xcc, 0x7b, 0x48, 0x02, 0xbd, 0x06, 0x70, - 0x17, 0x43, 0x06, 0x6b, 0xee, 0x3f, 0x44, 0x54, 0xec, 0x6c, 0x59, 0xc5, 0x5f, 0x11, 0x1e, 0x6d, - 0x08, 0xe2, 0x39, 0x11, 0xf3, 0x23, 0x84, 0x8f, 0x06, 0x3c, 0xae, 0x5a, 0x69, 0x5a, 0xbe, 0x84, - 0x7b, 0xfc, 0x4b, 0xd4, 0x28, 0x85, 0x8f, 0x50, 0xa9, 0x6d, 0x82, 0xfe, 0xc4, 0xad, 0x6a, 0x12, - 0x10, 0xd0, 0xb3, 0x80, 0x7b, 0x0d, 0x2b, 0x2a, 0xe7, 0xf1, 0x26, 0x72, 0xf2, 0xfe, 0x7c, 0x35, - 0x79, 0x27, 0xed, 0x13, 0x93, 0x3b, 0xc1, 0x5c, 0x48, 0xa7, 0xdd, 0x27, 0xf8, 0x07, 0xee, 0x04, - 0x87, 0xe3, 0x3c, 0x0f, 0x22, 0x5d, 0xc0, 0xc3, 0xc1, 0xed, 0xea, 0x85, 0xbc, 0x42, 0x9d, 0xf2, - 0xb2, 0x3d, 0xaf, 0xba, 0xeb, 0x81, 0x4c, 0x12, 0xee, 0x31, 0x60, 0x00, 0x3e, 0x32, 0xb5, 0x67, - 0x79, 0x0b, 0x67, 0xd3, 0x8c, 0x81, 0xfb, 0xfb, 0x78, 0x9f, 0x11, 0x1a, 0x01, 0xa1, 0x27, 0x05, - 0xe8, 0xd7, 0x8d, 0x40, 0x81, 0x88, 0x2b, 0x79, 0x16, 0xc2, 0x87, 0x27, 0x5f, 0xa2, 0x2e, 0x15, - 0x01, 0x7f, 0x17, 0x8f, 0xa4, 0x5a, 0x03, 0xfa, 0x77, 0xf1, 0xde, 0x79, 0x0f, 0x13, 0xdb, 0xf4, - 0xcb, 0xeb, 0x8e, 0xe0, 0x7d, 0xc1, 0xdb, 0x00, 0xf4, 0xb0, 0x1f, 0x59, 0x07, 0xd5, 0x61, 0xcb, - 0xc4, 0x55, 0x6f, 0xd7, 0xe6, 0x7c, 0x88, 0x40, 0xa3, 0x84, 0x48, 0x0d, 0x96, 0x28, 0xd3, 0xa6, - 0x25, 0x6a, 0xdf, 0x3e, 0x55, 0xf0, 0xa1, 0x60, 0xab, 0x2d, 0x50, 0x67, 0xc9, 0x4b, 0x12, 0xb9, - 0x4f, 0x8b, 0x61, 0x95, 0xb4, 0x75, 0x58, 0x61, 0xff, 0x41, 0x2e, 0xe2, 0xc1, 0xb8, 0x41, 0x2d, - 0xcd, 0xe9, 0x09, 0xde, 0x81, 0xb6, 0xe3, 0x4d, 0xc8, 0xd6, 0x5c, 0xd4, 0x0c, 0x65, 0x0a, 0x88, - 0xf2, 0xa6, 0x19, 0x45, 0xd4, 0xae, 0xd5, 0xfb, 0x0a, 0x01, 0x89, 0x50, 0x8c, 0x44, 0x12, 0x99, - 0x96, 0x48, 0xb4, 0x6f, 0x7d, 0x66, 0xea, 0x57, 0xc1, 0x22, 0x75, 0xdc, 0x39, 0x2f, 0xc7, 0xbe, - 0xc2, 0x52, 0xec, 0xc6, 0xcb, 0xb4, 0x09, 0xa7, 0x30, 0xc9, 0x0e, 0x88, 0xbe, 0x87, 0xfb, 0x23, - 0x43, 0x20, 0x69, 0xae, 0x09, 0xdf, 0xa8, 0xc3, 0xa8, 0x1b, 0xb9, 0x5c, 0x3f, 0x1c, 0x29, 0xa0, - 0xdb, 0xb5, 0x92, 0xbf, 0x20, 0xe0, 0x99, 0x14, 0xaa, 0x11, 0xcf, 0x4c, 0x1b, 0x78, 0xb6, 0x6f, - 0x95, 0x4f, 0x40, 0xd9, 0xb0, 0xa0, 0xb9, 0xfc, 0x6d, 0x95, 0xbc, 0xb4, 0x8b, 0x50, 0xe6, 0xc0, - 0xe4, 0xb9, 0x8d, 0xeb, 0x5e, 0x3e, 0xdf, 0x6a, 0x19, 0xa0, 0xe3, 0x81, 0x70, 0x68, 0x50, 0xed, - 0x06, 0xee, 0xe3, 0xef, 0x56, 0xc1, 0xf4, 0x9f, 0x37, 0x29, 0x84, 0x1c, 0xc8, 0x1f, 0x00, 0xc7, - 0xbc, 0x69, 0x3e, 0x8b, 0x1b, 0xf9, 0x1b, 0x04, 0x44, 0x6a, 0xfe, 0x53, 0x89, 0x64, 0x76, 0x44, - 0xa4, 0x7d, 0xab, 0x7e, 0x1d, 0x12, 0xa9, 0x45, 0xc3, 0x61, 0xda, 0x2f, 0x69, 0x56, 0xa9, 0x5e, - 0xb0, 0x36, 0x4a, 0x47, 0x07, 0x70, 0x97, 0x69, 0xac, 0x1a, 0x2e, 0x8b, 0xbe, 0xb7, 0xe0, 0x3f, - 0xc8, 0xf7, 0x83, 0x8c, 0x29, 0xe6, 0xf0, 0x59, 0x49, 0x21, 0xe3, 0x3e, 0xd7, 0x76, 0xa9, 0x09, - 0x81, 0x60, 0x67, 0x85, 0xde, 0xd5, 0xaa, 0x72, 0xef, 0xf0, 0x78, 0xf5, 0x73, 0xe8, 0x22, 0x90, - 0xcf, 0x04, 0x1a, 0x44, 0x46, 0x01, 0xf1, 0x41, 0xdc, 0xcd, 0x5d, 0x4d, 0x99, 0x02, 0x3c, 0xc9, - 0xcb, 0xc0, 0x74, 0xde, 0xb6, 0xee, 0x68, 0x15, 0xef, 0x4b, 0xb4, 0x6c, 0x7b, 0xe6, 0xb1, 0x53, - 0x10, 0x93, 0x4e, 0xc2, 0x3d, 0x3a, 0x75, 0x16, 0x6b, 0xea, 0xed, 0x29, 0xd4, 0x9e, 0xe5, 0x2f, - 0x10, 0xe4, 0x0f, 0x71, 0xb7, 0x80, 0xe7, 0x55, 0xbc, 0xdf, 0xae, 0xba, 0x2b, 0x76, 0xd5, 0x2a, - 0x2d, 0x50, 0xe7, 0xaa, 0xe5, 0x0d, 0x06, 0x3d, 0x82, 0xd8, 0x80, 0x37, 0x9b, 0x75, 0x26, 0x54, - 0xdb, 0xbc, 0xac, 0x69, 0x30, 0xdb, 0x0f, 0x1a, 0x1f, 0x20, 0x13, 0xb8, 0xdf, 0xfb, 0xcb, 0xdf, - 0x53, 0x19, 0xa6, 0x67, 0xf4, 0xb5, 0x3c, 0x8e, 0xc7, 0x18, 0xcc, 0x6b, 0x9a, 0xe3, 0x50, 0x5d, - 0x5b, 0xa2, 0x8e, 0x63, 0x58, 0xfa, 0x52, 0xdd, 0x63, 0xa0, 0xee, 0x65, 0x7c, 0xac, 0xd9, 0x44, - 0x20, 0x36, 0x84, 0xf7, 0x7c, 0x58, 0x83, 0xe8, 0x13, 0xaa, 0xbf, 0x98, 0xfe, 0x78, 0x04, 0x77, - 0x31, 0x47, 0xe4, 0x53, 0x84, 0xbb, 0xfd, 0xee, 0x04, 0x99, 0x6a, 0xb2, 0x6f, 0xe2, 0xed, 0x11, - 0x69, 0x7a, 0x3b, 0x26, 0x3e, 0x32, 0x79, 0xec, 0xde, 0xef, 0xff, 0xdd, 0xef, 0x1c, 0x21, 0xc3, - 0x8a, 0x67, 0x31, 0xc9, 0xb5, 0xbc, 0xf8, 0xb6, 0x11, 0x79, 0x88, 0x70, 0x1f, 0x5f, 0x50, 0x92, - 0xf3, 0x22, 0xb1, 0x92, 0x7b, 0x29, 0xd2, 0x85, 0x96, 0x6c, 0x01, 0xf0, 0x45, 0x06, 0xf8, 0x2c, - 0x39, 0x93, 0x02, 0x98, 0x2f, 0x71, 0x95, 0x4d, 0xb8, 0x9d, 0xb7, 0x94, 0x4d, 0x76, 0x1f, 0x6f, - 0x91, 0xef, 0x11, 0xee, 0xe7, 0xfd, 0xe6, 0x4d, 0x53, 0x8c, 0x4b, 0x72, 0x47, 0x45, 0x8c, 0x4b, - 0x4a, 0x97, 0x44, 0x3e, 0xc1, 0xb8, 0x8c, 0x91, 0x51, 0x01, 0x2e, 0xe4, 0x6f, 0x84, 0x0f, 0x46, - 0x90, 0x43, 0x61, 0x4b, 0xf2, 0x2d, 0x80, 0x08, 0x57, 0xe7, 0xd2, 0xdc, 0x4e, 0x5c, 0x00, 0x9d, - 0xf3, 0x8c, 0xce, 0x69, 0x32, 0x2d, 0x40, 0x07, 0x6c, 0x61, 0x85, 0xb6, 0xc8, 0x5f, 0x08, 0xbf, - 0xc8, 0x55, 0x8f, 0x1c, 0xb9, 0x37, 0x04, 0x91, 0xa5, 0x76, 0x1e, 0xa4, 0xfc, 0x0e, 0x3c, 0x00, - 0xb5, 0x59, 0x46, 0x6d, 0x86, 0x9c, 0x4e, 0xa1, 0x66, 0x58, 0x29, 0xcc, 0x8a, 0x46, 0x69, 0x8b, - 0x7c, 0x87, 0xf0, 0xbe, 0x30, 0x39, 0xe1, 0x3d, 0x97, 0xd0, 0x03, 0x10, 0xde, 0x73, 0x49, 0x75, - 0x7d, 0xd3, 0x3d, 0xc7, 0x31, 0x71, 0xc8, 0x6f, 0x00, 0x9c, 0xab, 0x8d, 0x66, 0x05, 0x0f, 0x6f, - 0x62, 0x85, 0x28, 0x5d, 0x6c, 0xd1, 0x1a, 0xc0, 0xbf, 0xc6, 0xc0, 0x4f, 0x93, 0x93, 0x0d, 0xc0, - 0xd7, 0xcd, 0x94, 0xcd, 0xe0, 0x79, 0x8b, 0xfc, 0x81, 0x30, 0x89, 0xd7, 0xcc, 0x44, 0x08, 0x4f, - 0x6a, 0xa5, 0x2e, 0xbd, 0xde, 0xaa, 0x39, 0xf0, 0xc9, 0x33, 0x3e, 0x17, 0xc8, 0xb9, 0x54, 0x3e, - 0xd1, 0x7f, 0x1f, 0x14, 0x4b, 0xd4, 0xa5, 0x3c, 0xb1, 0x1f, 0x11, 0xde, 0x1f, 0x8e, 0xe0, 0x6d, - 0xaf, 0xd9, 0x6d, 0x6c, 0x91, 0x16, 0x57, 0x29, 0xb5, 0x36, 0x97, 0x27, 0x19, 0xab, 0x71, 0x32, - 0x26, 0xb4, 0x4a, 0xe4, 0x6b, 0x54, 0xaf, 0x09, 0xc9, 0x8c, 0xe0, 0x06, 0x89, 0x14, 0xaf, 0xd2, - 0xd9, 0x6d, 0xdb, 0x01, 0x58, 0x85, 0x81, 0x7d, 0x85, 0x8c, 0xa7, 0x80, 0xd5, 0xc1, 0xc0, 0xd3, - 0xbc, 0xa4, 0xad, 0x6f, 0x91, 0x2f, 0x11, 0xee, 0x0d, 0xbc, 0x78, 0x52, 0xcf, 0x08, 0x8a, 0xd5, - 0x12, 0xe2, 0x84, 0x12, 0x5a, 0x1e, 0x67, 0x88, 0x8f, 0x92, 0x91, 0x26, 0x88, 0xc9, 0x03, 0x84, - 0x5f, 0x88, 0xe6, 0x5a, 0x44, 0xe8, 0xf2, 0x48, 0x49, 0xfc, 0xa4, 0xd9, 0xd6, 0x8c, 0x05, 0xa5, - 0x56, 0xa3, 0x58, 0x1f, 0x22, 0xdc, 0xcb, 0xa5, 0x53, 0xe4, 0x92, 0x48, 0xf8, 0x66, 0x69, 0x9b, - 0xf4, 0xe6, 0x0e, 0xbd, 0x00, 0x9b, 0xe3, 0x8c, 0xcd, 0xcb, 0x44, 0x4e, 0xcb, 0x9c, 0x38, 0xe0, - 0x8f, 0x50, 0xac, 0x4a, 0x26, 0xa2, 0x57, 0x61, 0x72, 0x8d, 0x2f, 0x76, 0xf5, 0xa4, 0xf7, 0x27, - 0xe4, 0x19, 0x06, 0xff, 0x24, 0xc9, 0xa5, 0xc0, 0x37, 0xc3, 0x76, 0xb5, 0xed, 0xff, 0x33, 0xc2, - 0x24, 0xe2, 0xd3, 0x3b, 0x05, 0xa2, 0x57, 0xc6, 0x4e, 0xd8, 0xa4, 0x77, 0x21, 0xe4, 0x1c, 0x63, - 0x33, 0x41, 0x8e, 0x89, 0xb1, 0x21, 0x9f, 0x23, 0xbc, 0x8b, 0x5d, 0x3e, 0xd3, 0x82, 0x32, 0xf2, - 0xd7, 0xe3, 0xa9, 0x6d, 0xd9, 0x08, 0x7e, 0x77, 0x55, 0xf8, 0x60, 0x31, 0x91, 0xbf, 0x45, 0xb8, - 0x97, 0xeb, 0x3e, 0x90, 0x73, 0xdb, 0x88, 0x18, 0xee, 0x58, 0xb4, 0x06, 0xf6, 0x0c, 0x03, 0xab, - 0x90, 0xc9, 0x86, 0x60, 0x63, 0xc9, 0xf5, 0x67, 0x08, 0xef, 0x0e, 0xbe, 0x40, 0xd3, 0x82, 0x2b, - 0xba, 0x6d, 0x61, 0x23, 0x1d, 0x08, 0x79, 0x94, 0x61, 0x1d, 0x26, 0x87, 0x1b, 0x60, 0xf5, 0x32, - 0xb0, 0x7e, 0xcf, 0xca, 0xab, 0xdd, 0xa1, 0x74, 0x16, 0x4b, 0xc1, 0x92, 0xbb, 0x07, 0x62, 0x29, - 0x58, 0x4a, 0xa3, 0xa0, 0xe9, 0xcd, 0xa1, 0xd6, 0x6d, 0x58, 0xea, 0x18, 0xfe, 0x9f, 0xba, 0xd8, - 0x66, 0x48, 0xfc, 0x2f, 0xbd, 0x74, 0xbe, 0x15, 0x53, 0xc1, 0xaf, 0xfa, 0xdd, 0x30, 0x4a, 0x0f, - 0x78, 0xb8, 0xed, 0x20, 0x06, 0x3c, 0xb1, 0x91, 0x21, 0x06, 0x3c, 0xb9, 0xcb, 0xd1, 0x14, 0xb8, - 0x19, 0x32, 0x9b, 0x7b, 0xeb, 0xd1, 0x93, 0x2c, 0x7a, 0xfc, 0x24, 0x8b, 0xfe, 0x7d, 0x92, 0x45, - 0x9f, 0x3c, 0xcd, 0x76, 0x3c, 0x7e, 0x9a, 0xed, 0xf8, 0xf3, 0x69, 0xb6, 0xe3, 0xe6, 0x94, 0x6e, - 0xb8, 0xe5, 0xea, 0x4a, 0x4e, 0xb5, 0x57, 0x79, 0x57, 0x01, 0x1e, 0x65, 0x9d, 0xf7, 0xea, 0x6e, - 0xac, 0x69, 0xce, 0x4a, 0x37, 0xfb, 0x0a, 0x9c, 0xfa, 0x3f, 0x00, 0x00, 0xff, 0xff, 0xf5, 0x77, - 0x46, 0x98, 0xb4, 0x22, 0x00, 0x00, + // 1860 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x5a, 0xcd, 0x6f, 0x14, 0xc9, + 0x15, 0x77, 0x79, 0xb0, 0xd7, 0x94, 0xcd, 0x7a, 0xa9, 0x75, 0x58, 0x6f, 0x63, 0x8f, 0x77, 0xdb, + 0x31, 0x26, 0x10, 0xcf, 0xac, 0xbd, 0x60, 0xbe, 0x4c, 0xc4, 0xd8, 0x04, 0x83, 0x62, 0xc0, 0x19, + 0x39, 0x4a, 0x44, 0x14, 0x8d, 0x6a, 0x7a, 0x2a, 0x33, 0x2d, 0xda, 0xdd, 0x66, 0xaa, 0x06, 0xd9, + 0x58, 0xbe, 0x70, 0xc8, 0x39, 0x12, 0x52, 0x72, 0xc9, 0x35, 0x4a, 0x0e, 0x39, 0xe4, 0x80, 0x92, + 0x43, 0x24, 0xa2, 0x7c, 0x11, 0x8e, 0x48, 0x91, 0xa2, 0x28, 0x91, 0xa2, 0x08, 0xf2, 0x87, 0xac, + 0xba, 0xfa, 0xf5, 0x4c, 0x75, 0x4f, 0xf7, 0x4c, 0x79, 0x3c, 0x1c, 0x38, 0x31, 0x5d, 0x55, 0xef, + 0xbd, 0xdf, 0xef, 0x57, 0x5f, 0xaf, 0x1e, 0xc6, 0xa7, 0xac, 0xba, 0xc7, 0xb9, 0x55, 0xa3, 0xb6, + 0x9b, 0x7f, 0xd4, 0x60, 0xf5, 0xbd, 0xdc, 0x4e, 0xdd, 0x13, 0x1e, 0x99, 0x7e, 0xc2, 0x04, 0x95, + 0xcd, 0x39, 0xf9, 0xcb, 0xab, 0xb3, 0x5c, 0x6b, 0xa8, 0x71, 0xce, 0xf2, 0xf8, 0xb6, 0xc7, 0xf3, + 0x65, 0xca, 0x59, 0x60, 0x97, 0x7f, 0xbc, 0x58, 0x66, 0x82, 0x2e, 0xe6, 0x77, 0x68, 0xd5, 0x76, + 0xa9, 0xb0, 0x3d, 0x37, 0x70, 0x65, 0xcc, 0x28, 0x21, 0xe4, 0xcf, 0x92, 0xfc, 0x5d, 0x12, 0xbb, + 0x30, 0xc0, 0x50, 0x06, 0x54, 0x29, 0x2f, 0xed, 0xd4, 0x6d, 0x8b, 0x41, 0xdf, 0xac, 0xd2, 0x27, + 0x6d, 0x4a, 0x35, 0xca, 0x6b, 0x25, 0xe1, 0x95, 0x2c, 0xab, 0xe9, 0x20, 0xdb, 0x36, 0x48, 0xd4, + 0xa9, 0xf5, 0x90, 0xd5, 0xa1, 0xdf, 0x54, 0xfa, 0x1d, 0xca, 0x45, 0xa9, 0xec, 0x78, 0xd6, 0xc3, + 0x52, 0x8d, 0xd9, 0xd5, 0x9a, 0x48, 0x40, 0xe9, 0x35, 0x44, 0xbb, 0x93, 0x4f, 0x94, 0x01, 0x3b, + 0xb4, 0x4e, 0xb7, 0x39, 0x74, 0x4c, 0x54, 0xbd, 0xaa, 0x27, 0x7f, 0xe6, 0xfd, 0x5f, 0xd0, 0x3a, + 0x55, 0xf5, 0xbc, 0xaa, 0xc3, 0xf2, 0x74, 0xc7, 0xce, 0x53, 0xd7, 0xf5, 0x84, 0x94, 0x04, 0x6c, + 0xcc, 0xd3, 0xf8, 0xd3, 0xef, 0xfa, 0xaa, 0xad, 0x33, 0xb1, 0xc5, 0x79, 0xa1, 0x52, 0xa9, 0x33, + 0xce, 0x8b, 0xec, 0x51, 0x83, 0x71, 0x61, 0xde, 0xc0, 0x46, 0x52, 0x27, 0xdf, 0xf1, 0x5c, 0xce, + 0xc8, 0x47, 0x38, 0xc3, 0x44, 0x6d, 0x12, 0x7d, 0x86, 0xce, 0x1e, 0x2f, 0xfa, 0x3f, 0xfd, 0x96, + 0xb2, 0xb0, 0x26, 0x07, 0x83, 0x96, 0xb2, 0xb0, 0xcc, 0x29, 0xf0, 0xf0, 0x80, 0x09, 0x5a, 0xb0, + 0x2c, 0xaf, 0xe1, 0x0a, 0xdb, 0xad, 0x86, 0xfe, 0xef, 0xe2, 0xd3, 0x89, 0xbd, 0x10, 0x20, 0x87, + 0x3f, 0xa6, 0x65, 0xaf, 0x2e, 0x58, 0xa5, 0xe4, 0x4f, 0x7d, 0x89, 0x6e, 0xfb, 0x23, 0x20, 0xe0, + 0x49, 0xe8, 0x92, 0xb6, 0xb2, 0xc3, 0x9c, 0xc0, 0x44, 0xba, 0xdb, 0x94, 0xa2, 0x84, 0x41, 0x1e, + 0xe0, 0x8f, 0x23, 0xad, 0xe0, 0x7c, 0x0d, 0x0f, 0x07, 0xe2, 0x49, 0x7f, 0xa3, 0x4b, 0x73, 0xb9, + 0x8e, 0x0b, 0x2d, 0x17, 0x98, 0xaf, 0x1e, 0x7b, 0xf5, 0xdf, 0x99, 0x81, 0x22, 0x98, 0x36, 0x09, + 0xac, 0x33, 0x71, 0xbf, 0x21, 0xb6, 0x76, 0xb7, 0x82, 0x89, 0x82, 0xd0, 0x64, 0x12, 0x7f, 0x20, + 0x8d, 0xef, 0xdc, 0x94, 0x41, 0x32, 0xc5, 0xf0, 0x93, 0x4c, 0xe0, 0x21, 0xd7, 0x73, 0x2d, 0x26, + 0xb5, 0x3a, 0x56, 0x0c, 0x3e, 0xcc, 0x06, 0x9e, 0x4a, 0x76, 0x07, 0x98, 0xbf, 0x87, 0xc7, 0x3c, + 0xa5, 0x1d, 0x90, 0x9f, 0xef, 0x82, 0x5c, 0x75, 0x05, 0xf8, 0x23, 0x6e, 0x4c, 0x06, 0x2c, 0x0a, + 0x8e, 0x93, 0xc4, 0xe2, 0x16, 0xc6, 0xad, 0xad, 0x04, 0x31, 0xcf, 0xe4, 0x82, 0x7d, 0x97, 0xf3, + 0xf7, 0x5d, 0x2e, 0xd8, 0xaf, 0xb0, 0xef, 0x72, 0x9b, 0xb4, 0xca, 0xc0, 0xb6, 0xa8, 0x58, 0x9a, + 0x2f, 0x10, 0xd0, 0x6b, 0x8b, 0x93, 0x4a, 0x2f, 0xd3, 0x07, 0x7a, 0x64, 0x3d, 0x82, 0x7f, 0x50, + 0xe2, 0x9f, 0xef, 0x8a, 0x3f, 0xc0, 0x14, 0x21, 0xf0, 0x14, 0x61, 0x33, 0x89, 0xc0, 0xea, 0xde, + 0x9a, 0x8f, 0x24, 0xd4, 0x6b, 0x02, 0x0f, 0x49, 0x64, 0x30, 0xe7, 0xc1, 0x47, 0x4c, 0xc5, 0xc1, + 0x9e, 0x55, 0xfc, 0x1b, 0xc2, 0xb3, 0x1d, 0x41, 0xbc, 0x27, 0x62, 0xfe, 0x04, 0xe1, 0xcf, 0x43, + 0x1e, 0x77, 0xdc, 0x34, 0x2d, 0x3f, 0xc5, 0x23, 0xc1, 0x19, 0x6d, 0x57, 0xa2, 0x5b, 0xa8, 0xd2, + 0x37, 0x41, 0xff, 0xa4, 0xcc, 0x6a, 0x12, 0x10, 0xd0, 0xb3, 0x88, 0x47, 0x6d, 0x37, 0x2e, 0xe7, + 0xb9, 0x2e, 0x72, 0xaa, 0xfe, 0x02, 0x35, 0x55, 0x27, 0xfd, 0x13, 0x53, 0xd9, 0xc1, 0x4a, 0x48, + 0xde, 0xef, 0x1d, 0xfc, 0x07, 0x65, 0x07, 0x47, 0xe3, 0xbc, 0x0f, 0x22, 0x5d, 0xc3, 0xd3, 0xe1, + 0xe9, 0xea, 0x87, 0xbc, 0x4d, 0x79, 0x6d, 0xcb, 0x5b, 0xb3, 0xc4, 0x6e, 0x28, 0x93, 0x81, 0x47, + 0x6c, 0xe8, 0x80, 0x4b, 0xa6, 0xf9, 0x6d, 0x1e, 0xe0, 0x6c, 0x9a, 0x31, 0x70, 0xff, 0x21, 0xfe, + 0xd0, 0x8e, 0xf4, 0x80, 0xd0, 0x0b, 0x1a, 0xf4, 0x5b, 0x46, 0xa0, 0x40, 0xcc, 0x95, 0xb9, 0x02, + 0xe1, 0xa3, 0x83, 0x6f, 0x52, 0x41, 0x75, 0xc0, 0x3f, 0xc1, 0x33, 0xa9, 0xd6, 0x80, 0xfe, 0xfb, + 0xf8, 0xc4, 0x9a, 0x8f, 0x49, 0x2e, 0xfa, 0xad, 0x5d, 0xae, 0x79, 0x5e, 0xa8, 0x36, 0x00, 0x3d, + 0xea, 0xc7, 0xac, 0x82, 0xea, 0xb0, 0x64, 0xda, 0x55, 0xef, 0xd7, 0xe2, 0x7c, 0x89, 0x40, 0xa3, + 0x84, 0x48, 0x1d, 0xa6, 0x28, 0xd3, 0xa7, 0x29, 0xea, 0xdf, 0x3a, 0xcd, 0xe3, 0x4f, 0xc2, 0xa5, + 0xb6, 0x4e, 0xf9, 0xa6, 0x9f, 0x83, 0x2a, 0x57, 0x8b, 0xed, 0x56, 0xd8, 0x2e, 0xcc, 0x70, 0xf0, + 0x61, 0x96, 0xf0, 0x64, 0xbb, 0x41, 0x33, 0xcd, 0x19, 0x09, 0xdb, 0x40, 0xdb, 0xf9, 0x2e, 0x64, + 0x9b, 0x2e, 0x9a, 0x86, 0x26, 0x05, 0x44, 0x05, 0xc7, 0x89, 0x23, 0xea, 0xd7, 0xec, 0xfd, 0x1a, + 0x01, 0x89, 0x48, 0x8c, 0x44, 0x12, 0x99, 0x9e, 0x48, 0xf4, 0x6f, 0x7e, 0x96, 0x5b, 0x47, 0xc1, + 0x06, 0xe5, 0x62, 0xd5, 0x4f, 0xe1, 0x6f, 0xcb, 0x0c, 0xbe, 0xf3, 0x34, 0xed, 0xc3, 0x2e, 0x4c, + 0xb2, 0x03, 0xa2, 0x3f, 0xc0, 0xe3, 0xb1, 0x2e, 0x90, 0x34, 0xd7, 0x85, 0x6f, 0xdc, 0x61, 0xdc, + 0x8d, 0x59, 0x6b, 0x6d, 0x8e, 0x14, 0xd0, 0xfd, 0x9a, 0xc9, 0xbf, 0x22, 0xe0, 0x99, 0x14, 0xaa, + 0x13, 0xcf, 0x4c, 0x1f, 0x78, 0xf6, 0x6f, 0x96, 0xcf, 0xc3, 0xb3, 0x61, 0x9d, 0x09, 0xf5, 0xb4, + 0x4a, 0x9e, 0xda, 0x8d, 0xd6, 0x43, 0x49, 0x9e, 0x10, 0x7b, 0xf7, 0xfc, 0x7c, 0xbe, 0xd7, 0x67, + 0x40, 0x15, 0x4f, 0x44, 0x43, 0x83, 0x6a, 0xf7, 0xf1, 0x98, 0x7a, 0xb6, 0x6a, 0xa6, 0xff, 0xaa, + 0x49, 0x31, 0xe2, 0xc0, 0xfc, 0x11, 0x70, 0x2c, 0x38, 0xce, 0xbb, 0x38, 0x91, 0x7f, 0x8b, 0x80, + 0x48, 0xd3, 0x7f, 0x2a, 0x91, 0xcc, 0x91, 0x88, 0xf4, 0x6f, 0xd6, 0xef, 0x41, 0x22, 0xb5, 0x61, + 0x73, 0xa9, 0xfd, 0x26, 0x73, 0x2b, 0xad, 0x07, 0x6b, 0xa7, 0x74, 0x74, 0x02, 0x0f, 0x39, 0xf6, + 0xb6, 0x2d, 0x64, 0xf4, 0x13, 0xc5, 0xe0, 0xc3, 0x7c, 0x16, 0x66, 0x4c, 0x6d, 0x0e, 0xdf, 0x95, + 0x14, 0x26, 0x1e, 0x13, 0x9e, 0xa0, 0x0e, 0x04, 0x82, 0x95, 0x15, 0x69, 0x6b, 0xbe, 0xca, 0xfd, + 0xcd, 0xe3, 0xbf, 0x9f, 0x23, 0x07, 0x81, 0x79, 0x31, 0xd4, 0x20, 0xd6, 0x0b, 0x88, 0x4f, 0xe1, + 0x61, 0xe5, 0x68, 0xca, 0x14, 0xe1, 0xcb, 0xdc, 0x02, 0xa6, 0x6b, 0x9e, 0xfb, 0x98, 0xd5, 0xfd, + 0x9b, 0x68, 0xcb, 0xf3, 0xcd, 0xdb, 0x76, 0x41, 0x9b, 0x74, 0x06, 0x1e, 0xa9, 0x52, 0xbe, 0xd1, + 0x54, 0xef, 0x78, 0xb1, 0xf9, 0x6d, 0xfe, 0x12, 0x41, 0xfe, 0xd0, 0xee, 0x16, 0xf0, 0x7c, 0x13, + 0x9f, 0xf4, 0x1a, 0xa2, 0xec, 0x35, 0xdc, 0xca, 0x3a, 0xe5, 0x77, 0x5c, 0xbf, 0x33, 0xac, 0x11, + 0xb4, 0x75, 0xf8, 0xa3, 0x65, 0xe1, 0xc3, 0xf2, 0x9c, 0x5b, 0x8c, 0xc1, 0xe8, 0x20, 0x68, 0x7b, + 0x07, 0x39, 0x8b, 0xc7, 0xfd, 0x7f, 0xd5, 0x73, 0x2a, 0x23, 0xf5, 0x8c, 0x37, 0x9b, 0xf3, 0x78, + 0x4e, 0xc2, 0xbc, 0xcb, 0x38, 0xa7, 0x55, 0xb6, 0x49, 0x39, 0xb7, 0xdd, 0xea, 0x66, 0xcb, 0x63, + 0xa8, 0xee, 0x2d, 0x7c, 0xa6, 0xdb, 0x40, 0x20, 0x36, 0x85, 0x8f, 0xff, 0xb8, 0x09, 0x31, 0x20, + 0xd4, 0x6a, 0x58, 0xfa, 0xf3, 0x67, 0x78, 0x48, 0x3a, 0x22, 0xcf, 0x11, 0x3e, 0x11, 0xa9, 0xd0, + 0x90, 0xcb, 0x5d, 0x96, 0x4f, 0x6a, 0xc5, 0xc7, 0xb8, 0xd2, 0x83, 0x65, 0x00, 0xd7, 0xcc, 0x3d, + 0xfd, 0xc7, 0xff, 0x9f, 0x0d, 0x9e, 0x25, 0x67, 0xf2, 0xbe, 0xe1, 0x82, 0x52, 0x66, 0x83, 0x82, + 0x1a, 0x13, 0x25, 0xc1, 0x79, 0x89, 0x02, 0xc8, 0x9f, 0x21, 0x3c, 0x1c, 0x14, 0x55, 0xc8, 0xa2, + 0x4e, 0xd4, 0x48, 0x55, 0xc7, 0x58, 0x3a, 0x8c, 0x09, 0x20, 0x9c, 0x93, 0x08, 0x67, 0xc8, 0x74, + 0x0a, 0xc2, 0xa0, 0xa8, 0x43, 0x5e, 0x22, 0x3c, 0xa6, 0xbe, 0x83, 0xc9, 0x55, 0x4d, 0x51, 0x12, + 0x8a, 0x27, 0xc6, 0xb5, 0x9e, 0x6c, 0x01, 0xf0, 0x75, 0x09, 0xf8, 0x12, 0xb9, 0x98, 0x02, 0x58, + 0x7d, 0x99, 0xe7, 0xf7, 0xe1, 0x52, 0x39, 0xc8, 0xef, 0xcb, 0x6b, 0xe4, 0x80, 0xfc, 0x1e, 0xe1, + 0x71, 0xd5, 0x6f, 0xc1, 0x71, 0xf4, 0xb8, 0x24, 0x17, 0x82, 0xf4, 0xb8, 0xa4, 0x14, 0x77, 0xcc, + 0xf3, 0x92, 0xcb, 0x1c, 0x99, 0xd5, 0xe0, 0x42, 0xfe, 0x83, 0xf0, 0xa9, 0x18, 0x72, 0x78, 0x8f, + 0x93, 0x42, 0x0f, 0x20, 0xa2, 0x45, 0x05, 0x63, 0xf5, 0x28, 0x2e, 0x80, 0xce, 0x55, 0x49, 0xe7, + 0x02, 0x59, 0xd2, 0xa0, 0x03, 0xb6, 0x30, 0x43, 0x07, 0xe4, 0xdf, 0x08, 0x7f, 0x4d, 0x79, 0xf4, + 0x2a, 0xe4, 0x6e, 0x68, 0x22, 0x4b, 0x2d, 0x98, 0x18, 0x85, 0x23, 0x78, 0x00, 0x6a, 0x2b, 0x92, + 0xda, 0x32, 0xb9, 0x90, 0x42, 0xcd, 0x76, 0x53, 0x98, 0x95, 0xec, 0xca, 0x01, 0xf9, 0x1d, 0xc2, + 0x1f, 0x46, 0xc9, 0x69, 0xaf, 0xb9, 0x84, 0xd2, 0x85, 0xf6, 0x9a, 0x4b, 0x2a, 0x47, 0x74, 0x5d, + 0x73, 0x0a, 0x13, 0x4e, 0xfe, 0x0e, 0xc0, 0x95, 0x27, 0xdd, 0x8a, 0xe6, 0xe6, 0x4d, 0x7c, 0xd8, + 0x1a, 0xd7, 0x7b, 0xb4, 0x06, 0xf0, 0x97, 0x25, 0xf8, 0x25, 0xf2, 0x45, 0x07, 0xf0, 0x2d, 0xb3, + 0xfc, 0x7e, 0xf8, 0x7d, 0x40, 0xfe, 0x89, 0x30, 0x69, 0x7f, 0xea, 0x13, 0x2d, 0x3c, 0xa9, 0x05, + 0x06, 0xe3, 0x5b, 0xbd, 0x9a, 0x03, 0x9f, 0x82, 0xe4, 0x73, 0x8d, 0x5c, 0x49, 0xe5, 0x13, 0xff, + 0x4f, 0x95, 0x52, 0x85, 0x0a, 0xaa, 0x12, 0xfb, 0x23, 0xc2, 0x27, 0xa3, 0x11, 0xfc, 0xe5, 0xb5, + 0x72, 0x88, 0x25, 0xd2, 0xe3, 0x2c, 0xa5, 0x96, 0x14, 0xcc, 0x05, 0xc9, 0x6a, 0x9e, 0xcc, 0x69, + 0xcd, 0x12, 0xf9, 0x0d, 0x6a, 0x3d, 0x65, 0xc9, 0xb2, 0xe6, 0x02, 0x89, 0xbd, 0xb9, 0x8d, 0x4b, + 0x87, 0xb6, 0x03, 0xb0, 0x79, 0x09, 0xf6, 0x1b, 0x64, 0x3e, 0xed, 0x8a, 0x06, 0x03, 0x5f, 0xf3, + 0x0a, 0xdb, 0x3d, 0x20, 0xbf, 0x42, 0x78, 0x34, 0xf4, 0xe2, 0x4b, 0xbd, 0xac, 0x29, 0x56, 0x4f, + 0x88, 0x13, 0x5e, 0xfe, 0xe6, 0xbc, 0x44, 0xfc, 0x39, 0x99, 0xe9, 0x82, 0x98, 0xbc, 0x40, 0xf8, + 0xa3, 0x78, 0x8a, 0x48, 0xb4, 0x0e, 0x8f, 0x94, 0x7c, 0xd5, 0x58, 0xe9, 0xcd, 0x58, 0x53, 0x6a, + 0x2b, 0x8e, 0xf5, 0x25, 0xc2, 0xa3, 0x4a, 0x16, 0x48, 0x6e, 0xea, 0x84, 0xef, 0x96, 0x6d, 0x1a, + 0xdf, 0x3e, 0xa2, 0x17, 0x60, 0x73, 0x4e, 0xb2, 0xf9, 0x3a, 0x31, 0xd3, 0x32, 0x27, 0x05, 0xf8, + 0x2b, 0xd4, 0xf6, 0xb8, 0x27, 0xba, 0x47, 0x61, 0x72, 0x69, 0x42, 0xef, 0xe8, 0x49, 0x2f, 0xab, + 0x98, 0xcb, 0x12, 0xfe, 0x17, 0x24, 0x97, 0x02, 0xdf, 0x89, 0xda, 0x35, 0x97, 0xff, 0x5f, 0x10, + 0x26, 0x31, 0x9f, 0xfe, 0x2e, 0xd0, 0x3d, 0x32, 0x8e, 0xc2, 0x26, 0xbd, 0x78, 0xd2, 0x35, 0xd1, + 0x8e, 0xb1, 0x21, 0xbf, 0x40, 0xf8, 0x98, 0x3c, 0x7c, 0x96, 0x34, 0x65, 0x54, 0x8f, 0xc7, 0x2f, + 0x0f, 0x65, 0xa3, 0x79, 0xef, 0x5a, 0x70, 0x61, 0x49, 0x91, 0x9f, 0x23, 0x3c, 0xaa, 0x14, 0x4d, + 0xc8, 0x95, 0x43, 0x44, 0x8c, 0x16, 0x5a, 0x7a, 0x03, 0x7b, 0x51, 0x82, 0xcd, 0x93, 0x85, 0x8e, + 0x60, 0xdb, 0x92, 0xeb, 0x9f, 0x23, 0xfc, 0x41, 0x78, 0x03, 0x2d, 0x69, 0xce, 0xe8, 0xa1, 0x85, + 0x8d, 0x15, 0x4e, 0xcc, 0x59, 0x89, 0x75, 0x9a, 0x9c, 0xee, 0x80, 0xd5, 0xcf, 0xc0, 0xc6, 0x7d, + 0xab, 0x0d, 0x9b, 0x0b, 0x78, 0xf1, 0xeb, 0xa5, 0x60, 0xc9, 0x45, 0x0f, 0xbd, 0x14, 0x2c, 0xa5, + 0xbe, 0xd1, 0xf5, 0xe4, 0xb0, 0x5a, 0x36, 0x32, 0x75, 0x8c, 0xfe, 0x29, 0x80, 0xde, 0x62, 0x48, + 0xfc, 0xe3, 0x02, 0xe3, 0x6a, 0x2f, 0xa6, 0x9a, 0xb7, 0xfa, 0x93, 0x28, 0x4a, 0x1f, 0x78, 0xb4, + 0x5a, 0xa2, 0x07, 0x3c, 0xb1, 0xfe, 0xa2, 0x07, 0x3c, 0xb9, 0x38, 0xd3, 0x15, 0xb8, 0x13, 0x31, + 0x5b, 0xfd, 0xce, 0xab, 0x37, 0x59, 0xf4, 0xfa, 0x4d, 0x16, 0xfd, 0xef, 0x4d, 0x16, 0xfd, 0xf4, + 0x6d, 0x76, 0xe0, 0xf5, 0xdb, 0xec, 0xc0, 0xbf, 0xde, 0x66, 0x07, 0x1e, 0x2c, 0x56, 0x6d, 0x51, + 0x6b, 0x94, 0x73, 0x96, 0xb7, 0xad, 0xba, 0x0a, 0xf1, 0xe4, 0x77, 0x55, 0xaf, 0x62, 0x6f, 0x87, + 0xf1, 0xf2, 0xb0, 0xbc, 0x05, 0xbe, 0xfc, 0x2a, 0x00, 0x00, 0xff, 0xff, 0xd6, 0xad, 0xe9, 0xc2, + 0xca, 0x23, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -2118,6 +2219,11 @@ const _ = grpc.SupportPackageIsVersion4 // // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. type QueryClient interface { + // GetTssAddress queries the tss address of the module. + // Deprecated: Moved to observer + // TODO: remove after v12 once upgrade testing is no longer needed with v11 + // https://github.com/zeta-chain/node/issues/1547 + GetTssAddress(ctx context.Context, in *QueryGetTssAddressRequest, opts ...grpc.CallOption) (*QueryGetTssAddressResponse, error) // Parameters queries the parameters of the module. Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error) // Queries a OutTxTracker by index. @@ -2164,6 +2270,15 @@ func NewQueryClient(cc grpc1.ClientConn) QueryClient { return &queryClient{cc} } +func (c *queryClient) GetTssAddress(ctx context.Context, in *QueryGetTssAddressRequest, opts ...grpc.CallOption) (*QueryGetTssAddressResponse, error) { + out := new(QueryGetTssAddressResponse) + err := c.cc.Invoke(ctx, "/zetachain.zetacore.crosschain.Query/GetTssAddress", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *queryClient) Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error) { out := new(QueryParamsResponse) err := c.cc.Invoke(ctx, "/zetachain.zetacore.crosschain.Query/Params", in, out, opts...) @@ -2355,6 +2470,11 @@ func (c *queryClient) LastZetaHeight(ctx context.Context, in *QueryLastZetaHeigh // QueryServer is the server API for Query service. type QueryServer interface { + // GetTssAddress queries the tss address of the module. + // Deprecated: Moved to observer + // TODO: remove after v12 once upgrade testing is no longer needed with v11 + // https://github.com/zeta-chain/node/issues/1547 + GetTssAddress(context.Context, *QueryGetTssAddressRequest) (*QueryGetTssAddressResponse, error) // Parameters queries the parameters of the module. Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error) // Queries a OutTxTracker by index. @@ -2397,6 +2517,9 @@ type QueryServer interface { type UnimplementedQueryServer struct { } +func (*UnimplementedQueryServer) GetTssAddress(ctx context.Context, req *QueryGetTssAddressRequest) (*QueryGetTssAddressResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetTssAddress not implemented") +} func (*UnimplementedQueryServer) Params(ctx context.Context, req *QueryParamsRequest) (*QueryParamsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Params not implemented") } @@ -2465,6 +2588,24 @@ func RegisterQueryServer(s grpc1.Server, srv QueryServer) { s.RegisterService(&_Query_serviceDesc, srv) } +func _Query_GetTssAddress_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryGetTssAddressRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).GetTssAddress(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/zetachain.zetacore.crosschain.Query/GetTssAddress", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).GetTssAddress(ctx, req.(*QueryGetTssAddressRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _Query_Params_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(QueryParamsRequest) if err := dec(in); err != nil { @@ -2847,6 +2988,10 @@ var _Query_serviceDesc = grpc.ServiceDesc{ ServiceName: "zetachain.zetacore.crosschain.Query", HandlerType: (*QueryServer)(nil), Methods: []grpc.MethodDesc{ + { + MethodName: "GetTssAddress", + Handler: _Query_GetTssAddress_Handler, + }, { MethodName: "Params", Handler: _Query_Params_Handler, @@ -2936,6 +3081,66 @@ var _Query_serviceDesc = grpc.ServiceDesc{ Metadata: "crosschain/query.proto", } +func (m *QueryGetTssAddressRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *QueryGetTssAddressRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryGetTssAddressRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *QueryGetTssAddressResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *QueryGetTssAddressResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryGetTssAddressResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Btc) > 0 { + i -= len(m.Btc) + copy(dAtA[i:], m.Btc) + i = encodeVarintQuery(dAtA, i, uint64(len(m.Btc))) + i-- + dAtA[i] = 0x12 + } + if len(m.Eth) > 0 { + i -= len(m.Eth) + copy(dAtA[i:], m.Eth) + i = encodeVarintQuery(dAtA, i, uint64(len(m.Eth))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + func (m *QueryZetaAccountingRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -4418,6 +4623,32 @@ func encodeVarintQuery(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } +func (m *QueryGetTssAddressRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *QueryGetTssAddressResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Eth) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + l = len(m.Btc) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + func (m *QueryZetaAccountingRequest) Size() (n int) { if m == nil { return 0 @@ -5011,6 +5242,170 @@ func sovQuery(x uint64) (n int) { func sozQuery(x uint64) (n int) { return sovQuery(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } +func (m *QueryGetTssAddressRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryGetTssAddressRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryGetTssAddressRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryGetTssAddressResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: QueryGetTssAddressResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryGetTssAddressResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Eth", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Eth = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Btc", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Btc = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func (m *QueryZetaAccountingRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 diff --git a/x/crosschain/types/query.pb.gw.go b/x/crosschain/types/query.pb.gw.go index 3e7f8b97c6..d7c90c4180 100644 --- a/x/crosschain/types/query.pb.gw.go +++ b/x/crosschain/types/query.pb.gw.go @@ -33,6 +33,24 @@ var _ = utilities.NewDoubleArray var _ = descriptor.ForMessage var _ = metadata.Join +func request_Query_GetTssAddress_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryGetTssAddressRequest + var metadata runtime.ServerMetadata + + msg, err := client.GetTssAddress(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_GetTssAddress_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryGetTssAddressRequest + var metadata runtime.ServerMetadata + + msg, err := server.GetTssAddress(ctx, &protoReq) + return msg, metadata, err + +} + func request_Query_Params_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { var protoReq QueryParamsRequest var metadata runtime.ServerMetadata @@ -965,6 +983,29 @@ func local_request_Query_LastZetaHeight_0(ctx context.Context, marshaler runtime // Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterQueryHandlerFromEndpoint instead. func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, server QueryServer) error { + mux.Handle("GET", pattern_Query_GetTssAddress_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_Query_GetTssAddress_0(rctx, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_GetTssAddress_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + mux.Handle("GET", pattern_Query_Params_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() @@ -1489,6 +1530,26 @@ func RegisterQueryHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc // "QueryClient" to call the correct interceptors. func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, client QueryClient) error { + mux.Handle("GET", pattern_Query_GetTssAddress_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_Query_GetTssAddress_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_GetTssAddress_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + mux.Handle("GET", pattern_Query_Params_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() @@ -1913,6 +1974,8 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie } var ( + pattern_Query_GetTssAddress_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"zeta-chain", "crosschain", "get_tss_address"}, "", runtime.AssumeColonVerbOpt(false))) + pattern_Query_Params_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"zeta-chain", "crosschain", "params"}, "", runtime.AssumeColonVerbOpt(false))) pattern_Query_OutTxTracker_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 1, 0, 4, 1, 5, 4}, []string{"zeta-chain", "crosschain", "outTxTracker", "chainID", "nonce"}, "", runtime.AssumeColonVerbOpt(false))) @@ -1957,6 +2020,8 @@ var ( ) var ( + forward_Query_GetTssAddress_0 = runtime.ForwardResponseMessage + forward_Query_Params_0 = runtime.ForwardResponseMessage forward_Query_OutTxTracker_0 = runtime.ForwardResponseMessage